diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_asyncio.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_asyncio.pyd new file mode 100644 index 0000000000000000000000000000000000000000..eca8c04f92127d9347ea1e60c4213111585eec6b Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_asyncio.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_bz2.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_bz2.pyd new file mode 100644 index 0000000000000000000000000000000000000000..7cbacb3272469e84dfbfbf5972642ea206371247 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_bz2.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_ctypes_test.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_ctypes_test.pyd new file mode 100644 index 0000000000000000000000000000000000000000..88534339a0329d81b822fe41874e8996f8ad14ad Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_ctypes_test.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_elementtree.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_elementtree.pyd new file mode 100644 index 0000000000000000000000000000000000000000..5b46f2c7d564cc1f20e5ddb691fd694225cac6e3 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_elementtree.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_hashlib.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_hashlib.pyd new file mode 100644 index 0000000000000000000000000000000000000000..5488e3f1a233b1a675cbbf00896bf7e6ae98ea7d Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_hashlib.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_lzma.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_lzma.pyd new file mode 100644 index 0000000000000000000000000000000000000000..27fa4d5e632a7adb8dca70eddf91eb89ada9602f Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_lzma.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_msi.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_msi.pyd new file mode 100644 index 0000000000000000000000000000000000000000..8d6f60e7ab393cd2df543ee884558305f7cbb77c Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_msi.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_multiprocessing.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_multiprocessing.pyd new file mode 100644 index 0000000000000000000000000000000000000000..3588f81eda4a762add64092a420bb2df45ee26a9 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_multiprocessing.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_overlapped.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_overlapped.pyd new file mode 100644 index 0000000000000000000000000000000000000000..c8c3a95643f947cb58f93e5be8c34350bae2f946 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_overlapped.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_queue.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_queue.pyd new file mode 100644 index 0000000000000000000000000000000000000000..29c1d12ec04c170bf590faf8cf273841aeef79ef Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_queue.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_socket.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_socket.pyd new file mode 100644 index 0000000000000000000000000000000000000000..4a7e4c2d3a45703e4c94cfc95b62c204c255a08e Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_socket.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_sqlite3.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_sqlite3.pyd new file mode 100644 index 0000000000000000000000000000000000000000..d49a7211a9e4c787d4df3cf0e1818ca06a8f7c9f Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_sqlite3.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_testbuffer.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_testbuffer.pyd new file mode 100644 index 0000000000000000000000000000000000000000..4bb2c82f4536419fbc47df44ff686ee1bc6c6785 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_testbuffer.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_testconsole.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_testconsole.pyd new file mode 100644 index 0000000000000000000000000000000000000000..5c6ed51e34f3c6d30a30de6058fc7ffa7de98647 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_testconsole.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_testimportmultiple.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_testimportmultiple.pyd new file mode 100644 index 0000000000000000000000000000000000000000..93e22d41906eb0f37789c20db8e21025e4b42695 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_testimportmultiple.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_testinternalcapi.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_testinternalcapi.pyd new file mode 100644 index 0000000000000000000000000000000000000000..451da5e3c6fcd81b5bf069379d2c7688b68a2b79 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_testinternalcapi.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_testmultiphase.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_testmultiphase.pyd new file mode 100644 index 0000000000000000000000000000000000000000..3ada48fa132c393ba97a3da33ca3393496b253a0 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_testmultiphase.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_tkinter.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_tkinter.pyd new file mode 100644 index 0000000000000000000000000000000000000000..04b03f8e0d83cf913b30929840a31a5ba04d89fb Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_tkinter.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_uuid.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_uuid.pyd new file mode 100644 index 0000000000000000000000000000000000000000..e5611236850e0b50aaf2672b5e149a8155534b54 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_uuid.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_zoneinfo.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_zoneinfo.pyd new file mode 100644 index 0000000000000000000000000000000000000000..17f85d99b5b3f35b024affc63f12e0fa77364ec7 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/_zoneinfo.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/py.ico b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/py.ico new file mode 100644 index 0000000000000000000000000000000000000000..1d8a79bfb310c71c30d2d59a975c8bae82775ee5 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/py.ico differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/pyc.ico b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/pyc.ico new file mode 100644 index 0000000000000000000000000000000000000000..74dde81b649eedaee58db05851f4f8c4af246501 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/pyc.ico differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/pyexpat.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/pyexpat.pyd new file mode 100644 index 0000000000000000000000000000000000000000..79075610707afaa6daddd233b660b0c6a5ef66be Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/pyexpat.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/select.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/select.pyd new file mode 100644 index 0000000000000000000000000000000000000000..54ee46022e6b9dd60934a550da221ff081c80bae Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/select.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/winsound.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/winsound.pyd new file mode 100644 index 0000000000000000000000000000000000000000..b9417a6a139df7b27afcae69aabe0fcb6ef4754e Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/winsound.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/xxlimited.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/xxlimited.pyd new file mode 100644 index 0000000000000000000000000000000000000000..4e8d256b1d21cb7725ba65defcce35fdc332ef2f Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/xxlimited.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/xxlimited_35.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/xxlimited_35.pyd new file mode 100644 index 0000000000000000000000000000000000000000..a576634e65a6c92f959e92ec35569cab776e9d36 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/DLLs/xxlimited_35.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/Python.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/Python.h new file mode 100644 index 0000000000000000000000000000000000000000..6ee3b0a2f9dc63c557349dcae97d1a03b6596305 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/Python.h @@ -0,0 +1,109 @@ +// Entry point of the Python C API. +// C extensions should only #include , and not include directly +// the other Python header files included by . + +#ifndef Py_PYTHON_H +#define Py_PYTHON_H + +// Since this is a "meta-include" file, no #ifdef __cplusplus / extern "C" { + +// Include Python header files +#include "patchlevel.h" +#include "pyconfig.h" +#include "pymacconfig.h" + +#if defined(__sgi) && !defined(_SGI_MP_SOURCE) +# define _SGI_MP_SOURCE +#endif + +// stdlib.h, stdio.h, errno.h and string.h headers are not used by Python +// headers, but kept for backward compatibility. They are excluded from the +// limited C API of Python 3.11. +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000 +# include +# include // FILE* +# include // errno +# include // memcpy() +#endif +#ifndef MS_WINDOWS +# include +#endif +#ifdef HAVE_STDDEF_H +# include // size_t +#endif + +#include // assert() +#include // wchar_t + +#include "pyport.h" +#include "pymacro.h" +#include "pymath.h" +#include "pymem.h" +#include "pytypedefs.h" +#include "pybuffer.h" +#include "object.h" +#include "objimpl.h" +#include "typeslots.h" +#include "pyhash.h" +#include "cpython/pydebug.h" +#include "bytearrayobject.h" +#include "bytesobject.h" +#include "unicodeobject.h" +#include "cpython/code.h" +#include "cpython/initconfig.h" +#include "pystate.h" +#include "pyerrors.h" +#include "longobject.h" +#include "cpython/longintrepr.h" +#include "boolobject.h" +#include "floatobject.h" +#include "complexobject.h" +#include "rangeobject.h" +#include "memoryobject.h" +#include "tupleobject.h" +#include "listobject.h" +#include "dictobject.h" +#include "cpython/odictobject.h" +#include "enumobject.h" +#include "setobject.h" +#include "methodobject.h" +#include "moduleobject.h" +#include "cpython/funcobject.h" +#include "cpython/classobject.h" +#include "fileobject.h" +#include "pycapsule.h" +#include "pyframe.h" +#include "traceback.h" +#include "sliceobject.h" +#include "cpython/cellobject.h" +#include "iterobject.h" +#include "cpython/genobject.h" +#include "descrobject.h" +#include "genericaliasobject.h" +#include "warnings.h" +#include "weakrefobject.h" +#include "structseq.h" +#include "cpython/picklebufobject.h" +#include "cpython/pytime.h" +#include "codecs.h" +#include "pythread.h" +#include "cpython/context.h" +#include "modsupport.h" +#include "compile.h" +#include "pythonrun.h" +#include "pylifecycle.h" +#include "ceval.h" +#include "sysmodule.h" +#include "osmodule.h" +#include "intrcheck.h" +#include "import.h" +#include "abstract.h" +#include "bltinmodule.h" +#include "cpython/pyctype.h" +#include "pystrtod.h" +#include "pystrcmp.h" +#include "fileutils.h" +#include "cpython/pyfpe.h" +#include "tracemalloc.h" + +#endif /* !Py_PYTHON_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/README.rst b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/README.rst new file mode 100644 index 0000000000000000000000000000000000000000..f52e690eac9a91cabec5e250e6ff3e47e107cd42 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/README.rst @@ -0,0 +1,12 @@ +The Python C API +================ + +The C API is divided into three sections: + +1. ``Include/``: Limited API +2. ``Include/cpython/``: CPython implementation details +3. ``Include/internal/``: The internal API + +Information on changing the C API is available `in the developer guide`_ + +.. _in the developer guide: https://devguide.python.org/c-api/ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/abstract.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/abstract.h new file mode 100644 index 0000000000000000000000000000000000000000..9e06fbbb749138f1846b80655844132452ac2034 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/abstract.h @@ -0,0 +1,873 @@ +/* Abstract Object Interface (many thanks to Jim Fulton) */ + +#ifndef Py_ABSTRACTOBJECT_H +#define Py_ABSTRACTOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +/* === Object Protocol ================================================== */ + +/* Implemented elsewhere: + + int PyObject_Print(PyObject *o, FILE *fp, int flags); + + Print an object 'o' on file 'fp'. Returns -1 on error. The flags argument + is used to enable certain printing options. The only option currently + supported is Py_Print_RAW. + + (What should be said about Py_Print_RAW?). */ + + +/* Implemented elsewhere: + + int PyObject_HasAttrString(PyObject *o, const char *attr_name); + + Returns 1 if object 'o' has the attribute attr_name, and 0 otherwise. + + This is equivalent to the Python expression: hasattr(o,attr_name). + + This function always succeeds. */ + + +/* Implemented elsewhere: + + PyObject* PyObject_GetAttrString(PyObject *o, const char *attr_name); + + Retrieve an attributed named attr_name form object o. + Returns the attribute value on success, or NULL on failure. + + This is the equivalent of the Python expression: o.attr_name. */ + + +/* Implemented elsewhere: + + int PyObject_HasAttr(PyObject *o, PyObject *attr_name); + + Returns 1 if o has the attribute attr_name, and 0 otherwise. + + This is equivalent to the Python expression: hasattr(o,attr_name). + + This function always succeeds. */ + +/* Implemented elsewhere: + + PyObject* PyObject_GetAttr(PyObject *o, PyObject *attr_name); + + Retrieve an attributed named 'attr_name' form object 'o'. + Returns the attribute value on success, or NULL on failure. + + This is the equivalent of the Python expression: o.attr_name. */ + + +/* Implemented elsewhere: + + int PyObject_SetAttrString(PyObject *o, const char *attr_name, PyObject *v); + + Set the value of the attribute named attr_name, for object 'o', + to the value 'v'. Raise an exception and return -1 on failure; return 0 on + success. + + This is the equivalent of the Python statement o.attr_name=v. */ + + +/* Implemented elsewhere: + + int PyObject_SetAttr(PyObject *o, PyObject *attr_name, PyObject *v); + + Set the value of the attribute named attr_name, for object 'o', to the value + 'v'. an exception and return -1 on failure; return 0 on success. + + This is the equivalent of the Python statement o.attr_name=v. */ + +/* Implemented as a macro: + + int PyObject_DelAttrString(PyObject *o, const char *attr_name); + + Delete attribute named attr_name, for object o. Returns + -1 on failure. + + This is the equivalent of the Python statement: del o.attr_name. */ +#define PyObject_DelAttrString(O,A) PyObject_SetAttrString((O),(A), NULL) + + +/* Implemented as a macro: + + int PyObject_DelAttr(PyObject *o, PyObject *attr_name); + + Delete attribute named attr_name, for object o. Returns -1 + on failure. This is the equivalent of the Python + statement: del o.attr_name. */ +#define PyObject_DelAttr(O,A) PyObject_SetAttr((O),(A), NULL) + + +/* Implemented elsewhere: + + PyObject *PyObject_Repr(PyObject *o); + + Compute the string representation of object 'o'. Returns the + string representation on success, NULL on failure. + + This is the equivalent of the Python expression: repr(o). + + Called by the repr() built-in function. */ + + +/* Implemented elsewhere: + + PyObject *PyObject_Str(PyObject *o); + + Compute the string representation of object, o. Returns the + string representation on success, NULL on failure. + + This is the equivalent of the Python expression: str(o). + + Called by the str() and print() built-in functions. */ + + +/* Declared elsewhere + + PyAPI_FUNC(int) PyCallable_Check(PyObject *o); + + Determine if the object, o, is callable. Return 1 if the object is callable + and 0 otherwise. + + This function always succeeds. */ + + +#ifdef PY_SSIZE_T_CLEAN +# define PyObject_CallFunction _PyObject_CallFunction_SizeT +# define PyObject_CallMethod _PyObject_CallMethod_SizeT +#endif + + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 +/* Call a callable Python object without any arguments */ +PyAPI_FUNC(PyObject *) PyObject_CallNoArgs(PyObject *func); +#endif + + +/* Call a callable Python object 'callable' with arguments given by the + tuple 'args' and keywords arguments given by the dictionary 'kwargs'. + + 'args' must not be NULL, use an empty tuple if no arguments are + needed. If no named arguments are needed, 'kwargs' can be NULL. + + This is the equivalent of the Python expression: + callable(*args, **kwargs). */ +PyAPI_FUNC(PyObject *) PyObject_Call(PyObject *callable, + PyObject *args, PyObject *kwargs); + + +/* Call a callable Python object 'callable', with arguments given by the + tuple 'args'. If no arguments are needed, then 'args' can be NULL. + + Returns the result of the call on success, or NULL on failure. + + This is the equivalent of the Python expression: + callable(*args). */ +PyAPI_FUNC(PyObject *) PyObject_CallObject(PyObject *callable, + PyObject *args); + +/* Call a callable Python object, callable, with a variable number of C + arguments. The C arguments are described using a mkvalue-style format + string. + + The format may be NULL, indicating that no arguments are provided. + + Returns the result of the call on success, or NULL on failure. + + This is the equivalent of the Python expression: + callable(arg1, arg2, ...). */ +PyAPI_FUNC(PyObject *) PyObject_CallFunction(PyObject *callable, + const char *format, ...); + +/* Call the method named 'name' of object 'obj' with a variable number of + C arguments. The C arguments are described by a mkvalue format string. + + The format can be NULL, indicating that no arguments are provided. + + Returns the result of the call on success, or NULL on failure. + + This is the equivalent of the Python expression: + obj.name(arg1, arg2, ...). */ +PyAPI_FUNC(PyObject *) PyObject_CallMethod(PyObject *obj, + const char *name, + const char *format, ...); + +PyAPI_FUNC(PyObject *) _PyObject_CallFunction_SizeT(PyObject *callable, + const char *format, + ...); + +PyAPI_FUNC(PyObject *) _PyObject_CallMethod_SizeT(PyObject *obj, + const char *name, + const char *format, + ...); + +/* Call a callable Python object 'callable' with a variable number of C + arguments. The C arguments are provided as PyObject* values, terminated + by a NULL. + + Returns the result of the call on success, or NULL on failure. + + This is the equivalent of the Python expression: + callable(arg1, arg2, ...). */ +PyAPI_FUNC(PyObject *) PyObject_CallFunctionObjArgs(PyObject *callable, + ...); + +/* Call the method named 'name' of object 'obj' with a variable number of + C arguments. The C arguments are provided as PyObject* values, terminated + by NULL. + + Returns the result of the call on success, or NULL on failure. + + This is the equivalent of the Python expression: obj.name(*args). */ + +PyAPI_FUNC(PyObject *) PyObject_CallMethodObjArgs( + PyObject *obj, + PyObject *name, + ...); + + +/* Implemented elsewhere: + + Py_hash_t PyObject_Hash(PyObject *o); + + Compute and return the hash, hash_value, of an object, o. On + failure, return -1. + + This is the equivalent of the Python expression: hash(o). */ + + +/* Implemented elsewhere: + + int PyObject_IsTrue(PyObject *o); + + Returns 1 if the object, o, is considered to be true, 0 if o is + considered to be false and -1 on failure. + + This is equivalent to the Python expression: not not o. */ + + +/* Implemented elsewhere: + + int PyObject_Not(PyObject *o); + + Returns 0 if the object, o, is considered to be true, 1 if o is + considered to be false and -1 on failure. + + This is equivalent to the Python expression: not o. */ + + +/* Get the type of an object. + + On success, returns a type object corresponding to the object type of object + 'o'. On failure, returns NULL. + + This is equivalent to the Python expression: type(o) */ +PyAPI_FUNC(PyObject *) PyObject_Type(PyObject *o); + + +/* Return the size of object 'o'. If the object 'o' provides both sequence and + mapping protocols, the sequence size is returned. + + On error, -1 is returned. + + This is the equivalent to the Python expression: len(o) */ +PyAPI_FUNC(Py_ssize_t) PyObject_Size(PyObject *o); + + +/* For DLL compatibility */ +#undef PyObject_Length +PyAPI_FUNC(Py_ssize_t) PyObject_Length(PyObject *o); +#define PyObject_Length PyObject_Size + +/* Return element of 'o' corresponding to the object 'key'. Return NULL + on failure. + + This is the equivalent of the Python expression: o[key] */ +PyAPI_FUNC(PyObject *) PyObject_GetItem(PyObject *o, PyObject *key); + + +/* Map the object 'key' to the value 'v' into 'o'. + + Raise an exception and return -1 on failure; return 0 on success. + + This is the equivalent of the Python statement: o[key]=v. */ +PyAPI_FUNC(int) PyObject_SetItem(PyObject *o, PyObject *key, PyObject *v); + +/* Remove the mapping for the string 'key' from the object 'o'. + Returns -1 on failure. + + This is equivalent to the Python statement: del o[key]. */ +PyAPI_FUNC(int) PyObject_DelItemString(PyObject *o, const char *key); + +/* Delete the mapping for the object 'key' from the object 'o'. + Returns -1 on failure. + + This is the equivalent of the Python statement: del o[key]. */ +PyAPI_FUNC(int) PyObject_DelItem(PyObject *o, PyObject *key); + + +/* === Old Buffer API ============================================ */ + +/* FIXME: usage of these should all be replaced in Python itself + but for backwards compatibility we will implement them. + Their usage without a corresponding "unlock" mechanism + may create issues (but they would already be there). */ + +/* Takes an arbitrary object which must support the (character, single segment) + buffer interface and returns a pointer to a read-only memory location + usable as character based input for subsequent processing. + + Return 0 on success. buffer and buffer_len are only set in case no error + occurs. Otherwise, -1 is returned and an exception set. */ +Py_DEPRECATED(3.0) +PyAPI_FUNC(int) PyObject_AsCharBuffer(PyObject *obj, + const char **buffer, + Py_ssize_t *buffer_len); + +/* Checks whether an arbitrary object supports the (character, single segment) + buffer interface. + + Returns 1 on success, 0 on failure. */ +Py_DEPRECATED(3.0) PyAPI_FUNC(int) PyObject_CheckReadBuffer(PyObject *obj); + +/* Same as PyObject_AsCharBuffer() except that this API expects (readable, + single segment) buffer interface and returns a pointer to a read-only memory + location which can contain arbitrary data. + + 0 is returned on success. buffer and buffer_len are only set in case no + error occurs. Otherwise, -1 is returned and an exception set. */ +Py_DEPRECATED(3.0) +PyAPI_FUNC(int) PyObject_AsReadBuffer(PyObject *obj, + const void **buffer, + Py_ssize_t *buffer_len); + +/* Takes an arbitrary object which must support the (writable, single segment) + buffer interface and returns a pointer to a writable memory location in + buffer of size 'buffer_len'. + + Return 0 on success. buffer and buffer_len are only set in case no error + occurs. Otherwise, -1 is returned and an exception set. */ +Py_DEPRECATED(3.0) +PyAPI_FUNC(int) PyObject_AsWriteBuffer(PyObject *obj, + void **buffer, + Py_ssize_t *buffer_len); + + +/* === New Buffer API ============================================ */ + +/* Takes an arbitrary object and returns the result of calling + obj.__format__(format_spec). */ +PyAPI_FUNC(PyObject *) PyObject_Format(PyObject *obj, + PyObject *format_spec); + + +/* ==== Iterators ================================================ */ + +/* Takes an object and returns an iterator for it. + This is typically a new iterator but if the argument is an iterator, this + returns itself. */ +PyAPI_FUNC(PyObject *) PyObject_GetIter(PyObject *); + +/* Takes an AsyncIterable object and returns an AsyncIterator for it. + This is typically a new iterator but if the argument is an AsyncIterator, + this returns itself. */ +PyAPI_FUNC(PyObject *) PyObject_GetAIter(PyObject *); + +/* Returns non-zero if the object 'obj' provides iterator protocols, and 0 otherwise. + + This function always succeeds. */ +PyAPI_FUNC(int) PyIter_Check(PyObject *); + +/* Returns non-zero if the object 'obj' provides AsyncIterator protocols, and 0 otherwise. + + This function always succeeds. */ +PyAPI_FUNC(int) PyAIter_Check(PyObject *); + +/* Takes an iterator object and calls its tp_iternext slot, + returning the next value. + + If the iterator is exhausted, this returns NULL without setting an + exception. + + NULL with an exception means an error occurred. */ +PyAPI_FUNC(PyObject *) PyIter_Next(PyObject *); + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 + +/* Takes generator, coroutine or iterator object and sends the value into it. + Returns: + - PYGEN_RETURN (0) if generator has returned. + 'result' parameter is filled with return value + - PYGEN_ERROR (-1) if exception was raised. + 'result' parameter is NULL + - PYGEN_NEXT (1) if generator has yielded. + 'result' parameter is filled with yielded value. */ +PyAPI_FUNC(PySendResult) PyIter_Send(PyObject *, PyObject *, PyObject **); +#endif + + +/* === Number Protocol ================================================== */ + +/* Returns 1 if the object 'o' provides numeric protocols, and 0 otherwise. + + This function always succeeds. */ +PyAPI_FUNC(int) PyNumber_Check(PyObject *o); + +/* Returns the result of adding o1 and o2, or NULL on failure. + + This is the equivalent of the Python expression: o1 + o2. */ +PyAPI_FUNC(PyObject *) PyNumber_Add(PyObject *o1, PyObject *o2); + +/* Returns the result of subtracting o2 from o1, or NULL on failure. + + This is the equivalent of the Python expression: o1 - o2. */ +PyAPI_FUNC(PyObject *) PyNumber_Subtract(PyObject *o1, PyObject *o2); + +/* Returns the result of multiplying o1 and o2, or NULL on failure. + + This is the equivalent of the Python expression: o1 * o2. */ +PyAPI_FUNC(PyObject *) PyNumber_Multiply(PyObject *o1, PyObject *o2); + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 +/* This is the equivalent of the Python expression: o1 @ o2. */ +PyAPI_FUNC(PyObject *) PyNumber_MatrixMultiply(PyObject *o1, PyObject *o2); +#endif + +/* Returns the result of dividing o1 by o2 giving an integral result, + or NULL on failure. + + This is the equivalent of the Python expression: o1 // o2. */ +PyAPI_FUNC(PyObject *) PyNumber_FloorDivide(PyObject *o1, PyObject *o2); + +/* Returns the result of dividing o1 by o2 giving a float result, or NULL on + failure. + + This is the equivalent of the Python expression: o1 / o2. */ +PyAPI_FUNC(PyObject *) PyNumber_TrueDivide(PyObject *o1, PyObject *o2); + +/* Returns the remainder of dividing o1 by o2, or NULL on failure. + + This is the equivalent of the Python expression: o1 % o2. */ +PyAPI_FUNC(PyObject *) PyNumber_Remainder(PyObject *o1, PyObject *o2); + +/* See the built-in function divmod. + + Returns NULL on failure. + + This is the equivalent of the Python expression: divmod(o1, o2). */ +PyAPI_FUNC(PyObject *) PyNumber_Divmod(PyObject *o1, PyObject *o2); + +/* See the built-in function pow. Returns NULL on failure. + + This is the equivalent of the Python expression: pow(o1, o2, o3), + where o3 is optional. */ +PyAPI_FUNC(PyObject *) PyNumber_Power(PyObject *o1, PyObject *o2, + PyObject *o3); + +/* Returns the negation of o on success, or NULL on failure. + + This is the equivalent of the Python expression: -o. */ +PyAPI_FUNC(PyObject *) PyNumber_Negative(PyObject *o); + +/* Returns the positive of o on success, or NULL on failure. + + This is the equivalent of the Python expression: +o. */ +PyAPI_FUNC(PyObject *) PyNumber_Positive(PyObject *o); + +/* Returns the absolute value of 'o', or NULL on failure. + + This is the equivalent of the Python expression: abs(o). */ +PyAPI_FUNC(PyObject *) PyNumber_Absolute(PyObject *o); + +/* Returns the bitwise negation of 'o' on success, or NULL on failure. + + This is the equivalent of the Python expression: ~o. */ +PyAPI_FUNC(PyObject *) PyNumber_Invert(PyObject *o); + +/* Returns the result of left shifting o1 by o2 on success, or NULL on failure. + + This is the equivalent of the Python expression: o1 << o2. */ +PyAPI_FUNC(PyObject *) PyNumber_Lshift(PyObject *o1, PyObject *o2); + +/* Returns the result of right shifting o1 by o2 on success, or NULL on + failure. + + This is the equivalent of the Python expression: o1 >> o2. */ +PyAPI_FUNC(PyObject *) PyNumber_Rshift(PyObject *o1, PyObject *o2); + +/* Returns the result of bitwise and of o1 and o2 on success, or NULL on + failure. + + This is the equivalent of the Python expression: o1 & o2. */ +PyAPI_FUNC(PyObject *) PyNumber_And(PyObject *o1, PyObject *o2); + +/* Returns the bitwise exclusive or of o1 by o2 on success, or NULL on failure. + + This is the equivalent of the Python expression: o1 ^ o2. */ +PyAPI_FUNC(PyObject *) PyNumber_Xor(PyObject *o1, PyObject *o2); + +/* Returns the result of bitwise or on o1 and o2 on success, or NULL on + failure. + + This is the equivalent of the Python expression: o1 | o2. */ +PyAPI_FUNC(PyObject *) PyNumber_Or(PyObject *o1, PyObject *o2); + +/* Returns 1 if obj is an index integer (has the nb_index slot of the + tp_as_number structure filled in), and 0 otherwise. */ +PyAPI_FUNC(int) PyIndex_Check(PyObject *); + +/* Returns the object 'o' converted to a Python int, or NULL with an exception + raised on failure. */ +PyAPI_FUNC(PyObject *) PyNumber_Index(PyObject *o); + +/* Returns the object 'o' converted to Py_ssize_t by going through + PyNumber_Index() first. + + If an overflow error occurs while converting the int to Py_ssize_t, then the + second argument 'exc' is the error-type to return. If it is NULL, then the + overflow error is cleared and the value is clipped. */ +PyAPI_FUNC(Py_ssize_t) PyNumber_AsSsize_t(PyObject *o, PyObject *exc); + +/* Returns the object 'o' converted to an integer object on success, or NULL + on failure. + + This is the equivalent of the Python expression: int(o). */ +PyAPI_FUNC(PyObject *) PyNumber_Long(PyObject *o); + +/* Returns the object 'o' converted to a float object on success, or NULL + on failure. + + This is the equivalent of the Python expression: float(o). */ +PyAPI_FUNC(PyObject *) PyNumber_Float(PyObject *o); + + +/* --- In-place variants of (some of) the above number protocol functions -- */ + +/* Returns the result of adding o2 to o1, possibly in-place, or NULL + on failure. + + This is the equivalent of the Python expression: o1 += o2. */ +PyAPI_FUNC(PyObject *) PyNumber_InPlaceAdd(PyObject *o1, PyObject *o2); + +/* Returns the result of subtracting o2 from o1, possibly in-place or + NULL on failure. + + This is the equivalent of the Python expression: o1 -= o2. */ +PyAPI_FUNC(PyObject *) PyNumber_InPlaceSubtract(PyObject *o1, PyObject *o2); + +/* Returns the result of multiplying o1 by o2, possibly in-place, or NULL on + failure. + + This is the equivalent of the Python expression: o1 *= o2. */ +PyAPI_FUNC(PyObject *) PyNumber_InPlaceMultiply(PyObject *o1, PyObject *o2); + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 +/* This is the equivalent of the Python expression: o1 @= o2. */ +PyAPI_FUNC(PyObject *) PyNumber_InPlaceMatrixMultiply(PyObject *o1, PyObject *o2); +#endif + +/* Returns the result of dividing o1 by o2 giving an integral result, possibly + in-place, or NULL on failure. + + This is the equivalent of the Python expression: o1 /= o2. */ +PyAPI_FUNC(PyObject *) PyNumber_InPlaceFloorDivide(PyObject *o1, + PyObject *o2); + +/* Returns the result of dividing o1 by o2 giving a float result, possibly + in-place, or null on failure. + + This is the equivalent of the Python expression: o1 /= o2. */ +PyAPI_FUNC(PyObject *) PyNumber_InPlaceTrueDivide(PyObject *o1, + PyObject *o2); + +/* Returns the remainder of dividing o1 by o2, possibly in-place, or NULL on + failure. + + This is the equivalent of the Python expression: o1 %= o2. */ +PyAPI_FUNC(PyObject *) PyNumber_InPlaceRemainder(PyObject *o1, PyObject *o2); + +/* Returns the result of raising o1 to the power of o2, possibly in-place, + or NULL on failure. + + This is the equivalent of the Python expression: o1 **= o2, + or o1 = pow(o1, o2, o3) if o3 is present. */ +PyAPI_FUNC(PyObject *) PyNumber_InPlacePower(PyObject *o1, PyObject *o2, + PyObject *o3); + +/* Returns the result of left shifting o1 by o2, possibly in-place, or NULL + on failure. + + This is the equivalent of the Python expression: o1 <<= o2. */ +PyAPI_FUNC(PyObject *) PyNumber_InPlaceLshift(PyObject *o1, PyObject *o2); + +/* Returns the result of right shifting o1 by o2, possibly in-place or NULL + on failure. + + This is the equivalent of the Python expression: o1 >>= o2. */ +PyAPI_FUNC(PyObject *) PyNumber_InPlaceRshift(PyObject *o1, PyObject *o2); + +/* Returns the result of bitwise and of o1 and o2, possibly in-place, or NULL + on failure. + + This is the equivalent of the Python expression: o1 &= o2. */ +PyAPI_FUNC(PyObject *) PyNumber_InPlaceAnd(PyObject *o1, PyObject *o2); + +/* Returns the bitwise exclusive or of o1 by o2, possibly in-place, or NULL + on failure. + + This is the equivalent of the Python expression: o1 ^= o2. */ +PyAPI_FUNC(PyObject *) PyNumber_InPlaceXor(PyObject *o1, PyObject *o2); + +/* Returns the result of bitwise or of o1 and o2, possibly in-place, + or NULL on failure. + + This is the equivalent of the Python expression: o1 |= o2. */ +PyAPI_FUNC(PyObject *) PyNumber_InPlaceOr(PyObject *o1, PyObject *o2); + +/* Returns the integer n converted to a string with a base, with a base + marker of 0b, 0o or 0x prefixed if applicable. + + If n is not an int object, it is converted with PyNumber_Index first. */ +PyAPI_FUNC(PyObject *) PyNumber_ToBase(PyObject *n, int base); + + +/* === Sequence protocol ================================================ */ + +/* Return 1 if the object provides sequence protocol, and zero + otherwise. + + This function always succeeds. */ +PyAPI_FUNC(int) PySequence_Check(PyObject *o); + +/* Return the size of sequence object o, or -1 on failure. */ +PyAPI_FUNC(Py_ssize_t) PySequence_Size(PyObject *o); + +/* For DLL compatibility */ +#undef PySequence_Length +PyAPI_FUNC(Py_ssize_t) PySequence_Length(PyObject *o); +#define PySequence_Length PySequence_Size + + +/* Return the concatenation of o1 and o2 on success, and NULL on failure. + + This is the equivalent of the Python expression: o1 + o2. */ +PyAPI_FUNC(PyObject *) PySequence_Concat(PyObject *o1, PyObject *o2); + +/* Return the result of repeating sequence object 'o' 'count' times, + or NULL on failure. + + This is the equivalent of the Python expression: o * count. */ +PyAPI_FUNC(PyObject *) PySequence_Repeat(PyObject *o, Py_ssize_t count); + +/* Return the ith element of o, or NULL on failure. + + This is the equivalent of the Python expression: o[i]. */ +PyAPI_FUNC(PyObject *) PySequence_GetItem(PyObject *o, Py_ssize_t i); + +/* Return the slice of sequence object o between i1 and i2, or NULL on failure. + + This is the equivalent of the Python expression: o[i1:i2]. */ +PyAPI_FUNC(PyObject *) PySequence_GetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2); + +/* Assign object 'v' to the ith element of the sequence 'o'. Raise an exception + and return -1 on failure; return 0 on success. + + This is the equivalent of the Python statement o[i] = v. */ +PyAPI_FUNC(int) PySequence_SetItem(PyObject *o, Py_ssize_t i, PyObject *v); + +/* Delete the 'i'-th element of the sequence 'v'. Returns -1 on failure. + + This is the equivalent of the Python statement: del o[i]. */ +PyAPI_FUNC(int) PySequence_DelItem(PyObject *o, Py_ssize_t i); + +/* Assign the sequence object 'v' to the slice in sequence object 'o', + from 'i1' to 'i2'. Returns -1 on failure. + + This is the equivalent of the Python statement: o[i1:i2] = v. */ +PyAPI_FUNC(int) PySequence_SetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2, + PyObject *v); + +/* Delete the slice in sequence object 'o' from 'i1' to 'i2'. + Returns -1 on failure. + + This is the equivalent of the Python statement: del o[i1:i2]. */ +PyAPI_FUNC(int) PySequence_DelSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2); + +/* Returns the sequence 'o' as a tuple on success, and NULL on failure. + + This is equivalent to the Python expression: tuple(o). */ +PyAPI_FUNC(PyObject *) PySequence_Tuple(PyObject *o); + +/* Returns the sequence 'o' as a list on success, and NULL on failure. + This is equivalent to the Python expression: list(o) */ +PyAPI_FUNC(PyObject *) PySequence_List(PyObject *o); + +/* Return the sequence 'o' as a list, unless it's already a tuple or list. + + Use PySequence_Fast_GET_ITEM to access the members of this list, and + PySequence_Fast_GET_SIZE to get its length. + + Returns NULL on failure. If the object does not support iteration, raises a + TypeError exception with 'm' as the message text. */ +PyAPI_FUNC(PyObject *) PySequence_Fast(PyObject *o, const char* m); + +/* Return the size of the sequence 'o', assuming that 'o' was returned by + PySequence_Fast and is not NULL. */ +#define PySequence_Fast_GET_SIZE(o) \ + (PyList_Check(o) ? PyList_GET_SIZE(o) : PyTuple_GET_SIZE(o)) + +/* Return the 'i'-th element of the sequence 'o', assuming that o was returned + by PySequence_Fast, and that i is within bounds. */ +#define PySequence_Fast_GET_ITEM(o, i)\ + (PyList_Check(o) ? PyList_GET_ITEM(o, i) : PyTuple_GET_ITEM(o, i)) + +/* Return a pointer to the underlying item array for + an object returned by PySequence_Fast */ +#define PySequence_Fast_ITEMS(sf) \ + (PyList_Check(sf) ? ((PyListObject *)(sf))->ob_item \ + : ((PyTupleObject *)(sf))->ob_item) + +/* Return the number of occurrences on value on 'o', that is, return + the number of keys for which o[key] == value. + + On failure, return -1. This is equivalent to the Python expression: + o.count(value). */ +PyAPI_FUNC(Py_ssize_t) PySequence_Count(PyObject *o, PyObject *value); + +/* Return 1 if 'ob' is in the sequence 'seq'; 0 if 'ob' is not in the sequence + 'seq'; -1 on error. + + Use __contains__ if possible, else _PySequence_IterSearch(). */ +PyAPI_FUNC(int) PySequence_Contains(PyObject *seq, PyObject *ob); + +/* For DLL-level backwards compatibility */ +#undef PySequence_In +/* Determine if the sequence 'o' contains 'value'. If an item in 'o' is equal + to 'value', return 1, otherwise return 0. On error, return -1. + + This is equivalent to the Python expression: value in o. */ +PyAPI_FUNC(int) PySequence_In(PyObject *o, PyObject *value); + +/* For source-level backwards compatibility */ +#define PySequence_In PySequence_Contains + + +/* Return the first index for which o[i] == value. + On error, return -1. + + This is equivalent to the Python expression: o.index(value). */ +PyAPI_FUNC(Py_ssize_t) PySequence_Index(PyObject *o, PyObject *value); + + +/* --- In-place versions of some of the above Sequence functions --- */ + +/* Append sequence 'o2' to sequence 'o1', in-place when possible. Return the + resulting object, which could be 'o1', or NULL on failure. + + This is the equivalent of the Python expression: o1 += o2. */ +PyAPI_FUNC(PyObject *) PySequence_InPlaceConcat(PyObject *o1, PyObject *o2); + +/* Repeat sequence 'o' by 'count', in-place when possible. Return the resulting + object, which could be 'o', or NULL on failure. + + This is the equivalent of the Python expression: o1 *= count. */ +PyAPI_FUNC(PyObject *) PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count); + + +/* === Mapping protocol ================================================= */ + +/* Return 1 if the object provides mapping protocol, and 0 otherwise. + + This function always succeeds. */ +PyAPI_FUNC(int) PyMapping_Check(PyObject *o); + +/* Returns the number of keys in mapping object 'o' on success, and -1 on + failure. This is equivalent to the Python expression: len(o). */ +PyAPI_FUNC(Py_ssize_t) PyMapping_Size(PyObject *o); + +/* For DLL compatibility */ +#undef PyMapping_Length +PyAPI_FUNC(Py_ssize_t) PyMapping_Length(PyObject *o); +#define PyMapping_Length PyMapping_Size + + +/* Implemented as a macro: + + int PyMapping_DelItemString(PyObject *o, const char *key); + + Remove the mapping for the string 'key' from the mapping 'o'. Returns -1 on + failure. + + This is equivalent to the Python statement: del o[key]. */ +#define PyMapping_DelItemString(O,K) PyObject_DelItemString((O),(K)) + +/* Implemented as a macro: + + int PyMapping_DelItem(PyObject *o, PyObject *key); + + Remove the mapping for the object 'key' from the mapping object 'o'. + Returns -1 on failure. + + This is equivalent to the Python statement: del o[key]. */ +#define PyMapping_DelItem(O,K) PyObject_DelItem((O),(K)) + +/* On success, return 1 if the mapping object 'o' has the key 'key', + and 0 otherwise. + + This is equivalent to the Python expression: key in o. + + This function always succeeds. */ +PyAPI_FUNC(int) PyMapping_HasKeyString(PyObject *o, const char *key); + +/* Return 1 if the mapping object has the key 'key', and 0 otherwise. + + This is equivalent to the Python expression: key in o. + + This function always succeeds. */ +PyAPI_FUNC(int) PyMapping_HasKey(PyObject *o, PyObject *key); + +/* On success, return a list or tuple of the keys in mapping object 'o'. + On failure, return NULL. */ +PyAPI_FUNC(PyObject *) PyMapping_Keys(PyObject *o); + +/* On success, return a list or tuple of the values in mapping object 'o'. + On failure, return NULL. */ +PyAPI_FUNC(PyObject *) PyMapping_Values(PyObject *o); + +/* On success, return a list or tuple of the items in mapping object 'o', + where each item is a tuple containing a key-value pair. On failure, return + NULL. */ +PyAPI_FUNC(PyObject *) PyMapping_Items(PyObject *o); + +/* Return element of 'o' corresponding to the string 'key' or NULL on failure. + + This is the equivalent of the Python expression: o[key]. */ +PyAPI_FUNC(PyObject *) PyMapping_GetItemString(PyObject *o, + const char *key); + +/* Map the string 'key' to the value 'v' in the mapping 'o'. + Returns -1 on failure. + + This is the equivalent of the Python statement: o[key]=v. */ +PyAPI_FUNC(int) PyMapping_SetItemString(PyObject *o, const char *key, + PyObject *value); + +/* isinstance(object, typeorclass) */ +PyAPI_FUNC(int) PyObject_IsInstance(PyObject *object, PyObject *typeorclass); + +/* issubclass(object, typeorclass) */ +PyAPI_FUNC(int) PyObject_IsSubclass(PyObject *object, PyObject *typeorclass); + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_ABSTRACTOBJECT_H +# include "cpython/abstract.h" +# undef Py_CPYTHON_ABSTRACTOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* Py_ABSTRACTOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/bltinmodule.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/bltinmodule.h new file mode 100644 index 0000000000000000000000000000000000000000..868c9e6443bfc1d1d48fb0806af1bf21490fc44c --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/bltinmodule.h @@ -0,0 +1,14 @@ +#ifndef Py_BLTINMODULE_H +#define Py_BLTINMODULE_H +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_DATA(PyTypeObject) PyFilter_Type; +PyAPI_DATA(PyTypeObject) PyMap_Type; +PyAPI_DATA(PyTypeObject) PyZip_Type; + +#ifdef __cplusplus +} +#endif +#endif /* !Py_BLTINMODULE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/boolobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/boolobject.h new file mode 100644 index 0000000000000000000000000000000000000000..28068d1cbe593933dcbd5525e1cfad80956ca243 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/boolobject.h @@ -0,0 +1,43 @@ +/* Boolean object interface */ + +#ifndef Py_BOOLOBJECT_H +#define Py_BOOLOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + + +PyAPI_DATA(PyTypeObject) PyBool_Type; + +#define PyBool_Check(x) Py_IS_TYPE(x, &PyBool_Type) + +/* Py_False and Py_True are the only two bools in existence. +Don't forget to apply Py_INCREF() when returning either!!! */ + +/* Don't use these directly */ +PyAPI_DATA(PyLongObject) _Py_FalseStruct; +PyAPI_DATA(PyLongObject) _Py_TrueStruct; + +/* Use these macros */ +#define Py_False ((PyObject *) &_Py_FalseStruct) +#define Py_True ((PyObject *) &_Py_TrueStruct) + +// Test if an object is the True singleton, the same as "x is True" in Python. +PyAPI_FUNC(int) Py_IsTrue(PyObject *x); +#define Py_IsTrue(x) Py_Is((x), Py_True) + +// Test if an object is the False singleton, the same as "x is False" in Python. +PyAPI_FUNC(int) Py_IsFalse(PyObject *x); +#define Py_IsFalse(x) Py_Is((x), Py_False) + +/* Macros for returning Py_True or Py_False, respectively */ +#define Py_RETURN_TRUE return Py_NewRef(Py_True) +#define Py_RETURN_FALSE return Py_NewRef(Py_False) + +/* Function to return a bool from a C long */ +PyAPI_FUNC(PyObject *) PyBool_FromLong(long); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_BOOLOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/bytearrayobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/bytearrayobject.h new file mode 100644 index 0000000000000000000000000000000000000000..ae2bde1c30356540223f23716469a4707b9455b1 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/bytearrayobject.h @@ -0,0 +1,44 @@ +/* ByteArray object interface */ + +#ifndef Py_BYTEARRAYOBJECT_H +#define Py_BYTEARRAYOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +/* Type PyByteArrayObject represents a mutable array of bytes. + * The Python API is that of a sequence; + * the bytes are mapped to ints in [0, 256). + * Bytes are not characters; they may be used to encode characters. + * The only way to go between bytes and str/unicode is via encoding + * and decoding. + * For the convenience of C programmers, the bytes type is considered + * to contain a char pointer, not an unsigned char pointer. + */ + +/* Type object */ +PyAPI_DATA(PyTypeObject) PyByteArray_Type; +PyAPI_DATA(PyTypeObject) PyByteArrayIter_Type; + +/* Type check macros */ +#define PyByteArray_Check(self) PyObject_TypeCheck(self, &PyByteArray_Type) +#define PyByteArray_CheckExact(self) Py_IS_TYPE(self, &PyByteArray_Type) + +/* Direct API functions */ +PyAPI_FUNC(PyObject *) PyByteArray_FromObject(PyObject *); +PyAPI_FUNC(PyObject *) PyByteArray_Concat(PyObject *, PyObject *); +PyAPI_FUNC(PyObject *) PyByteArray_FromStringAndSize(const char *, Py_ssize_t); +PyAPI_FUNC(Py_ssize_t) PyByteArray_Size(PyObject *); +PyAPI_FUNC(char *) PyByteArray_AsString(PyObject *); +PyAPI_FUNC(int) PyByteArray_Resize(PyObject *, Py_ssize_t); + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_BYTEARRAYOBJECT_H +# include "cpython/bytearrayobject.h" +# undef Py_CPYTHON_BYTEARRAYOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_BYTEARRAYOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/bytesobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/bytesobject.h new file mode 100644 index 0000000000000000000000000000000000000000..4c4dc40d705d71432b1d0ef713ba0a590d8367cb --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/bytesobject.h @@ -0,0 +1,69 @@ + +/* Bytes object interface */ + +#ifndef Py_BYTESOBJECT_H +#define Py_BYTESOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#include // va_list + +/* +Type PyBytesObject represents a byte string. An extra zero byte is +reserved at the end to ensure it is zero-terminated, but a size is +present so strings with null bytes in them can be represented. This +is an immutable object type. + +There are functions to create new bytes objects, to test +an object for bytes-ness, and to get the +byte string value. The latter function returns a null pointer +if the object is not of the proper type. +There is a variant that takes an explicit size as well as a +variant that assumes a zero-terminated string. Note that none of the +functions should be applied to NULL pointer. +*/ + +PyAPI_DATA(PyTypeObject) PyBytes_Type; +PyAPI_DATA(PyTypeObject) PyBytesIter_Type; + +#define PyBytes_Check(op) \ + PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_BYTES_SUBCLASS) +#define PyBytes_CheckExact(op) Py_IS_TYPE(op, &PyBytes_Type) + +PyAPI_FUNC(PyObject *) PyBytes_FromStringAndSize(const char *, Py_ssize_t); +PyAPI_FUNC(PyObject *) PyBytes_FromString(const char *); +PyAPI_FUNC(PyObject *) PyBytes_FromObject(PyObject *); +PyAPI_FUNC(PyObject *) PyBytes_FromFormatV(const char*, va_list) + Py_GCC_ATTRIBUTE((format(printf, 1, 0))); +PyAPI_FUNC(PyObject *) PyBytes_FromFormat(const char*, ...) + Py_GCC_ATTRIBUTE((format(printf, 1, 2))); +PyAPI_FUNC(Py_ssize_t) PyBytes_Size(PyObject *); +PyAPI_FUNC(char *) PyBytes_AsString(PyObject *); +PyAPI_FUNC(PyObject *) PyBytes_Repr(PyObject *, int); +PyAPI_FUNC(void) PyBytes_Concat(PyObject **, PyObject *); +PyAPI_FUNC(void) PyBytes_ConcatAndDel(PyObject **, PyObject *); +PyAPI_FUNC(PyObject *) PyBytes_DecodeEscape(const char *, Py_ssize_t, + const char *, Py_ssize_t, + const char *); + +/* Provides access to the internal data buffer and size of a bytes object. + Passing NULL as len parameter will force the string buffer to be + 0-terminated (passing a string with embedded NUL characters will + cause an exception). */ +PyAPI_FUNC(int) PyBytes_AsStringAndSize( + PyObject *obj, /* bytes object */ + char **s, /* pointer to buffer variable */ + Py_ssize_t *len /* pointer to length variable or NULL */ + ); + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_BYTESOBJECT_H +# include "cpython/bytesobject.h" +# undef Py_CPYTHON_BYTESOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_BYTESOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/ceval.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/ceval.h new file mode 100644 index 0000000000000000000000000000000000000000..1b57f6ea20f6f069bb71a3b2191f955ac56f0fac --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/ceval.h @@ -0,0 +1,168 @@ +/* Interface to random parts in ceval.c */ + +#ifndef Py_CEVAL_H +#define Py_CEVAL_H +#ifdef __cplusplus +extern "C" { +#endif + + +PyAPI_FUNC(PyObject *) PyEval_EvalCode(PyObject *, PyObject *, PyObject *); + +PyAPI_FUNC(PyObject *) PyEval_EvalCodeEx(PyObject *co, + PyObject *globals, + PyObject *locals, + PyObject *const *args, int argc, + PyObject *const *kwds, int kwdc, + PyObject *const *defs, int defc, + PyObject *kwdefs, PyObject *closure); + +/* PyEval_CallObjectWithKeywords(), PyEval_CallObject(), PyEval_CallFunction + * and PyEval_CallMethod are deprecated. Since they are officially part of the + * stable ABI (PEP 384), they must be kept for backward compatibility. + * PyObject_Call(), PyObject_CallFunction() and PyObject_CallMethod() are + * recommended to call a callable object. + */ + +Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyEval_CallObjectWithKeywords( + PyObject *callable, + PyObject *args, + PyObject *kwargs); + +/* Deprecated since PyEval_CallObjectWithKeywords is deprecated */ +#define PyEval_CallObject(callable, arg) \ + PyEval_CallObjectWithKeywords(callable, arg, (PyObject *)NULL) + +Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyEval_CallFunction( + PyObject *callable, const char *format, ...); +Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyEval_CallMethod( + PyObject *obj, const char *name, const char *format, ...); + +PyAPI_FUNC(PyObject *) PyEval_GetBuiltins(void); +PyAPI_FUNC(PyObject *) PyEval_GetGlobals(void); +PyAPI_FUNC(PyObject *) PyEval_GetLocals(void); +PyAPI_FUNC(PyFrameObject *) PyEval_GetFrame(void); + +PyAPI_FUNC(int) Py_AddPendingCall(int (*func)(void *), void *arg); +PyAPI_FUNC(int) Py_MakePendingCalls(void); + +/* Protection against deeply nested recursive calls + + In Python 3.0, this protection has two levels: + * normal anti-recursion protection is triggered when the recursion level + exceeds the current recursion limit. It raises a RecursionError, and sets + the "overflowed" flag in the thread state structure. This flag + temporarily *disables* the normal protection; this allows cleanup code + to potentially outgrow the recursion limit while processing the + RecursionError. + * "last chance" anti-recursion protection is triggered when the recursion + level exceeds "current recursion limit + 50". By construction, this + protection can only be triggered when the "overflowed" flag is set. It + means the cleanup code has itself gone into an infinite loop, or the + RecursionError has been mistakingly ignored. When this protection is + triggered, the interpreter aborts with a Fatal Error. + + In addition, the "overflowed" flag is automatically reset when the + recursion level drops below "current recursion limit - 50". This heuristic + is meant to ensure that the normal anti-recursion protection doesn't get + disabled too long. + + Please note: this scheme has its own limitations. See: + http://mail.python.org/pipermail/python-dev/2008-August/082106.html + for some observations. +*/ +PyAPI_FUNC(void) Py_SetRecursionLimit(int); +PyAPI_FUNC(int) Py_GetRecursionLimit(void); + +PyAPI_FUNC(int) Py_EnterRecursiveCall(const char *where); +PyAPI_FUNC(void) Py_LeaveRecursiveCall(void); + +PyAPI_FUNC(const char *) PyEval_GetFuncName(PyObject *); +PyAPI_FUNC(const char *) PyEval_GetFuncDesc(PyObject *); + +PyAPI_FUNC(PyObject *) PyEval_EvalFrame(PyFrameObject *); +PyAPI_FUNC(PyObject *) PyEval_EvalFrameEx(PyFrameObject *f, int exc); + +/* Interface for threads. + + A module that plans to do a blocking system call (or something else + that lasts a long time and doesn't touch Python data) can allow other + threads to run as follows: + + ...preparations here... + Py_BEGIN_ALLOW_THREADS + ...blocking system call here... + Py_END_ALLOW_THREADS + ...interpret result here... + + The Py_BEGIN_ALLOW_THREADS/Py_END_ALLOW_THREADS pair expands to a + {}-surrounded block. + To leave the block in the middle (e.g., with return), you must insert + a line containing Py_BLOCK_THREADS before the return, e.g. + + if (...premature_exit...) { + Py_BLOCK_THREADS + PyErr_SetFromErrno(PyExc_OSError); + return NULL; + } + + An alternative is: + + Py_BLOCK_THREADS + if (...premature_exit...) { + PyErr_SetFromErrno(PyExc_OSError); + return NULL; + } + Py_UNBLOCK_THREADS + + For convenience, that the value of 'errno' is restored across + Py_END_ALLOW_THREADS and Py_BLOCK_THREADS. + + WARNING: NEVER NEST CALLS TO Py_BEGIN_ALLOW_THREADS AND + Py_END_ALLOW_THREADS!!! + + Note that not yet all candidates have been converted to use this + mechanism! +*/ + +PyAPI_FUNC(PyThreadState *) PyEval_SaveThread(void); +PyAPI_FUNC(void) PyEval_RestoreThread(PyThreadState *); + +Py_DEPRECATED(3.9) PyAPI_FUNC(int) PyEval_ThreadsInitialized(void); +Py_DEPRECATED(3.9) PyAPI_FUNC(void) PyEval_InitThreads(void); +/* PyEval_AcquireLock() and PyEval_ReleaseLock() are part of stable ABI. + * They will be removed from this header file in the future version. + * But they will be remained in ABI until Python 4.0. + */ +Py_DEPRECATED(3.2) PyAPI_FUNC(void) PyEval_AcquireLock(void); +Py_DEPRECATED(3.2) PyAPI_FUNC(void) PyEval_ReleaseLock(void); +PyAPI_FUNC(void) PyEval_AcquireThread(PyThreadState *tstate); +PyAPI_FUNC(void) PyEval_ReleaseThread(PyThreadState *tstate); + +#define Py_BEGIN_ALLOW_THREADS { \ + PyThreadState *_save; \ + _save = PyEval_SaveThread(); +#define Py_BLOCK_THREADS PyEval_RestoreThread(_save); +#define Py_UNBLOCK_THREADS _save = PyEval_SaveThread(); +#define Py_END_ALLOW_THREADS PyEval_RestoreThread(_save); \ + } + +/* Masks and values used by FORMAT_VALUE opcode. */ +#define FVC_MASK 0x3 +#define FVC_NONE 0x0 +#define FVC_STR 0x1 +#define FVC_REPR 0x2 +#define FVC_ASCII 0x3 +#define FVS_MASK 0x4 +#define FVS_HAVE_SPEC 0x4 + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_CEVAL_H +# include "cpython/ceval.h" +# undef Py_CPYTHON_CEVAL_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_CEVAL_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/codecs.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/codecs.h new file mode 100644 index 0000000000000000000000000000000000000000..37ecfb4ab757b416a70873220832905238116846 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/codecs.h @@ -0,0 +1,248 @@ +#ifndef Py_CODECREGISTRY_H +#define Py_CODECREGISTRY_H +#ifdef __cplusplus +extern "C" { +#endif + +/* ------------------------------------------------------------------------ + + Python Codec Registry and support functions + + +Written by Marc-Andre Lemburg (mal@lemburg.com). + +Copyright (c) Corporation for National Research Initiatives. + + ------------------------------------------------------------------------ */ + +/* Register a new codec search function. + + As side effect, this tries to load the encodings package, if not + yet done, to make sure that it is always first in the list of + search functions. + + The search_function's refcount is incremented by this function. */ + +PyAPI_FUNC(int) PyCodec_Register( + PyObject *search_function + ); + +/* Unregister a codec search function and clear the registry's cache. + If the search function is not registered, do nothing. + Return 0 on success. Raise an exception and return -1 on error. */ + +PyAPI_FUNC(int) PyCodec_Unregister( + PyObject *search_function + ); + +/* Codec registry lookup API. + + Looks up the given encoding and returns a CodecInfo object with + function attributes which implement the different aspects of + processing the encoding. + + The encoding string is looked up converted to all lower-case + characters. This makes encodings looked up through this mechanism + effectively case-insensitive. + + If no codec is found, a KeyError is set and NULL returned. + + As side effect, this tries to load the encodings package, if not + yet done. This is part of the lazy load strategy for the encodings + package. + + */ + +#ifndef Py_LIMITED_API +PyAPI_FUNC(PyObject *) _PyCodec_Lookup( + const char *encoding + ); + +PyAPI_FUNC(int) _PyCodec_Forget( + const char *encoding + ); +#endif + +/* Codec registry encoding check API. + + Returns 1/0 depending on whether there is a registered codec for + the given encoding. + +*/ + +PyAPI_FUNC(int) PyCodec_KnownEncoding( + const char *encoding + ); + +/* Generic codec based encoding API. + + object is passed through the encoder function found for the given + encoding using the error handling method defined by errors. errors + may be NULL to use the default method defined for the codec. + + Raises a LookupError in case no encoder can be found. + + */ + +PyAPI_FUNC(PyObject *) PyCodec_Encode( + PyObject *object, + const char *encoding, + const char *errors + ); + +/* Generic codec based decoding API. + + object is passed through the decoder function found for the given + encoding using the error handling method defined by errors. errors + may be NULL to use the default method defined for the codec. + + Raises a LookupError in case no encoder can be found. + + */ + +PyAPI_FUNC(PyObject *) PyCodec_Decode( + PyObject *object, + const char *encoding, + const char *errors + ); + +#ifndef Py_LIMITED_API +/* Text codec specific encoding and decoding API. + + Checks the encoding against a list of codecs which do not + implement a str<->bytes encoding before attempting the + operation. + + Please note that these APIs are internal and should not + be used in Python C extensions. + + XXX (ncoghlan): should we make these, or something like them, public + in Python 3.5+? + + */ +PyAPI_FUNC(PyObject *) _PyCodec_LookupTextEncoding( + const char *encoding, + const char *alternate_command + ); + +PyAPI_FUNC(PyObject *) _PyCodec_EncodeText( + PyObject *object, + const char *encoding, + const char *errors + ); + +PyAPI_FUNC(PyObject *) _PyCodec_DecodeText( + PyObject *object, + const char *encoding, + const char *errors + ); + +/* These two aren't actually text encoding specific, but _io.TextIOWrapper + * is the only current API consumer. + */ +PyAPI_FUNC(PyObject *) _PyCodecInfo_GetIncrementalDecoder( + PyObject *codec_info, + const char *errors + ); + +PyAPI_FUNC(PyObject *) _PyCodecInfo_GetIncrementalEncoder( + PyObject *codec_info, + const char *errors + ); +#endif + + + +/* --- Codec Lookup APIs -------------------------------------------------- + + All APIs return a codec object with incremented refcount and are + based on _PyCodec_Lookup(). The same comments w/r to the encoding + name also apply to these APIs. + +*/ + +/* Get an encoder function for the given encoding. */ + +PyAPI_FUNC(PyObject *) PyCodec_Encoder( + const char *encoding + ); + +/* Get a decoder function for the given encoding. */ + +PyAPI_FUNC(PyObject *) PyCodec_Decoder( + const char *encoding + ); + +/* Get an IncrementalEncoder object for the given encoding. */ + +PyAPI_FUNC(PyObject *) PyCodec_IncrementalEncoder( + const char *encoding, + const char *errors + ); + +/* Get an IncrementalDecoder object function for the given encoding. */ + +PyAPI_FUNC(PyObject *) PyCodec_IncrementalDecoder( + const char *encoding, + const char *errors + ); + +/* Get a StreamReader factory function for the given encoding. */ + +PyAPI_FUNC(PyObject *) PyCodec_StreamReader( + const char *encoding, + PyObject *stream, + const char *errors + ); + +/* Get a StreamWriter factory function for the given encoding. */ + +PyAPI_FUNC(PyObject *) PyCodec_StreamWriter( + const char *encoding, + PyObject *stream, + const char *errors + ); + +/* Unicode encoding error handling callback registry API */ + +/* Register the error handling callback function error under the given + name. This function will be called by the codec when it encounters + unencodable characters/undecodable bytes and doesn't know the + callback name, when name is specified as the error parameter + in the call to the encode/decode function. + Return 0 on success, -1 on error */ +PyAPI_FUNC(int) PyCodec_RegisterError(const char *name, PyObject *error); + +/* Lookup the error handling callback function registered under the given + name. As a special case NULL can be passed, in which case + the error handling callback for "strict" will be returned. */ +PyAPI_FUNC(PyObject *) PyCodec_LookupError(const char *name); + +/* raise exc as an exception */ +PyAPI_FUNC(PyObject *) PyCodec_StrictErrors(PyObject *exc); + +/* ignore the unicode error, skipping the faulty input */ +PyAPI_FUNC(PyObject *) PyCodec_IgnoreErrors(PyObject *exc); + +/* replace the unicode encode error with ? or U+FFFD */ +PyAPI_FUNC(PyObject *) PyCodec_ReplaceErrors(PyObject *exc); + +/* replace the unicode encode error with XML character references */ +PyAPI_FUNC(PyObject *) PyCodec_XMLCharRefReplaceErrors(PyObject *exc); + +/* replace the unicode encode error with backslash escapes (\x, \u and \U) */ +PyAPI_FUNC(PyObject *) PyCodec_BackslashReplaceErrors(PyObject *exc); + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 +/* replace the unicode encode error with backslash escapes (\N, \x, \u and \U) */ +PyAPI_FUNC(PyObject *) PyCodec_NameReplaceErrors(PyObject *exc); +#endif + +#ifndef Py_LIMITED_API +PyAPI_DATA(const char *) Py_hexdigits; +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_CODECREGISTRY_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/compile.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/compile.h new file mode 100644 index 0000000000000000000000000000000000000000..3c5acd7209f763e1713d2bd816a96b025ee0f8e2 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/compile.h @@ -0,0 +1,25 @@ +#ifndef Py_COMPILE_H +#define Py_COMPILE_H +#ifdef __cplusplus +extern "C" { +#endif + +/* These definitions must match corresponding definitions in graminit.h. */ +#define Py_single_input 256 +#define Py_file_input 257 +#define Py_eval_input 258 +#define Py_func_type_input 345 + +/* This doesn't need to match anything */ +#define Py_fstring_input 800 + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_COMPILE_H +# include "cpython/compile.h" +# undef Py_CPYTHON_COMPILE_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_COMPILE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/complexobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/complexobject.h new file mode 100644 index 0000000000000000000000000000000000000000..c7764e43803d652b766897d7145e4354d6e3d944 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/complexobject.h @@ -0,0 +1,30 @@ +/* Complex number structure */ + +#ifndef Py_COMPLEXOBJECT_H +#define Py_COMPLEXOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +/* Complex object interface */ + +PyAPI_DATA(PyTypeObject) PyComplex_Type; + +#define PyComplex_Check(op) PyObject_TypeCheck(op, &PyComplex_Type) +#define PyComplex_CheckExact(op) Py_IS_TYPE(op, &PyComplex_Type) + +PyAPI_FUNC(PyObject *) PyComplex_FromDoubles(double real, double imag); + +PyAPI_FUNC(double) PyComplex_RealAsDouble(PyObject *op); +PyAPI_FUNC(double) PyComplex_ImagAsDouble(PyObject *op); + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_COMPLEXOBJECT_H +# include "cpython/complexobject.h" +# undef Py_CPYTHON_COMPLEXOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_COMPLEXOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/datetime.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/datetime.h new file mode 100644 index 0000000000000000000000000000000000000000..bb565201a164d7ed66c66697ae3ac5d6951b54b2 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/datetime.h @@ -0,0 +1,267 @@ +/* datetime.h + */ +#ifndef Py_LIMITED_API +#ifndef DATETIME_H +#define DATETIME_H +#ifdef __cplusplus +extern "C" { +#endif + +/* Fields are packed into successive bytes, each viewed as unsigned and + * big-endian, unless otherwise noted: + * + * byte offset + * 0 year 2 bytes, 1-9999 + * 2 month 1 byte, 1-12 + * 3 day 1 byte, 1-31 + * 4 hour 1 byte, 0-23 + * 5 minute 1 byte, 0-59 + * 6 second 1 byte, 0-59 + * 7 usecond 3 bytes, 0-999999 + * 10 + */ + +/* # of bytes for year, month, and day. */ +#define _PyDateTime_DATE_DATASIZE 4 + +/* # of bytes for hour, minute, second, and usecond. */ +#define _PyDateTime_TIME_DATASIZE 6 + +/* # of bytes for year, month, day, hour, minute, second, and usecond. */ +#define _PyDateTime_DATETIME_DATASIZE 10 + + +typedef struct +{ + PyObject_HEAD + Py_hash_t hashcode; /* -1 when unknown */ + int days; /* -MAX_DELTA_DAYS <= days <= MAX_DELTA_DAYS */ + int seconds; /* 0 <= seconds < 24*3600 is invariant */ + int microseconds; /* 0 <= microseconds < 1000000 is invariant */ +} PyDateTime_Delta; + +typedef struct +{ + PyObject_HEAD /* a pure abstract base class */ +} PyDateTime_TZInfo; + + +/* The datetime and time types have hashcodes, and an optional tzinfo member, + * present if and only if hastzinfo is true. + */ +#define _PyTZINFO_HEAD \ + PyObject_HEAD \ + Py_hash_t hashcode; \ + char hastzinfo; /* boolean flag */ + +/* No _PyDateTime_BaseTZInfo is allocated; it's just to have something + * convenient to cast to, when getting at the hastzinfo member of objects + * starting with _PyTZINFO_HEAD. + */ +typedef struct +{ + _PyTZINFO_HEAD +} _PyDateTime_BaseTZInfo; + +/* All time objects are of PyDateTime_TimeType, but that can be allocated + * in two ways, with or without a tzinfo member. Without is the same as + * tzinfo == None, but consumes less memory. _PyDateTime_BaseTime is an + * internal struct used to allocate the right amount of space for the + * "without" case. + */ +#define _PyDateTime_TIMEHEAD \ + _PyTZINFO_HEAD \ + unsigned char data[_PyDateTime_TIME_DATASIZE]; + +typedef struct +{ + _PyDateTime_TIMEHEAD +} _PyDateTime_BaseTime; /* hastzinfo false */ + +typedef struct +{ + _PyDateTime_TIMEHEAD + unsigned char fold; + PyObject *tzinfo; +} PyDateTime_Time; /* hastzinfo true */ + + +/* All datetime objects are of PyDateTime_DateTimeType, but that can be + * allocated in two ways too, just like for time objects above. In addition, + * the plain date type is a base class for datetime, so it must also have + * a hastzinfo member (although it's unused there). + */ +typedef struct +{ + _PyTZINFO_HEAD + unsigned char data[_PyDateTime_DATE_DATASIZE]; +} PyDateTime_Date; + +#define _PyDateTime_DATETIMEHEAD \ + _PyTZINFO_HEAD \ + unsigned char data[_PyDateTime_DATETIME_DATASIZE]; + +typedef struct +{ + _PyDateTime_DATETIMEHEAD +} _PyDateTime_BaseDateTime; /* hastzinfo false */ + +typedef struct +{ + _PyDateTime_DATETIMEHEAD + unsigned char fold; + PyObject *tzinfo; +} PyDateTime_DateTime; /* hastzinfo true */ + + +/* Apply for date and datetime instances. */ + +// o is a pointer to a time or a datetime object. +#define _PyDateTime_HAS_TZINFO(o) (((_PyDateTime_BaseTZInfo *)(o))->hastzinfo) + +#define PyDateTime_GET_YEAR(o) ((((PyDateTime_Date*)o)->data[0] << 8) | \ + ((PyDateTime_Date*)o)->data[1]) +#define PyDateTime_GET_MONTH(o) (((PyDateTime_Date*)o)->data[2]) +#define PyDateTime_GET_DAY(o) (((PyDateTime_Date*)o)->data[3]) + +#define PyDateTime_DATE_GET_HOUR(o) (((PyDateTime_DateTime*)o)->data[4]) +#define PyDateTime_DATE_GET_MINUTE(o) (((PyDateTime_DateTime*)o)->data[5]) +#define PyDateTime_DATE_GET_SECOND(o) (((PyDateTime_DateTime*)o)->data[6]) +#define PyDateTime_DATE_GET_MICROSECOND(o) \ + ((((PyDateTime_DateTime*)o)->data[7] << 16) | \ + (((PyDateTime_DateTime*)o)->data[8] << 8) | \ + ((PyDateTime_DateTime*)o)->data[9]) +#define PyDateTime_DATE_GET_FOLD(o) (((PyDateTime_DateTime*)o)->fold) +#define PyDateTime_DATE_GET_TZINFO(o) (_PyDateTime_HAS_TZINFO(o) ? \ + ((PyDateTime_DateTime *)(o))->tzinfo : Py_None) + +/* Apply for time instances. */ +#define PyDateTime_TIME_GET_HOUR(o) (((PyDateTime_Time*)o)->data[0]) +#define PyDateTime_TIME_GET_MINUTE(o) (((PyDateTime_Time*)o)->data[1]) +#define PyDateTime_TIME_GET_SECOND(o) (((PyDateTime_Time*)o)->data[2]) +#define PyDateTime_TIME_GET_MICROSECOND(o) \ + ((((PyDateTime_Time*)o)->data[3] << 16) | \ + (((PyDateTime_Time*)o)->data[4] << 8) | \ + ((PyDateTime_Time*)o)->data[5]) +#define PyDateTime_TIME_GET_FOLD(o) (((PyDateTime_Time*)o)->fold) +#define PyDateTime_TIME_GET_TZINFO(o) (_PyDateTime_HAS_TZINFO(o) ? \ + ((PyDateTime_Time *)(o))->tzinfo : Py_None) + +/* Apply for time delta instances */ +#define PyDateTime_DELTA_GET_DAYS(o) (((PyDateTime_Delta*)o)->days) +#define PyDateTime_DELTA_GET_SECONDS(o) (((PyDateTime_Delta*)o)->seconds) +#define PyDateTime_DELTA_GET_MICROSECONDS(o) \ + (((PyDateTime_Delta*)o)->microseconds) + + +/* Define structure for C API. */ +typedef struct { + /* type objects */ + PyTypeObject *DateType; + PyTypeObject *DateTimeType; + PyTypeObject *TimeType; + PyTypeObject *DeltaType; + PyTypeObject *TZInfoType; + + /* singletons */ + PyObject *TimeZone_UTC; + + /* constructors */ + PyObject *(*Date_FromDate)(int, int, int, PyTypeObject*); + PyObject *(*DateTime_FromDateAndTime)(int, int, int, int, int, int, int, + PyObject*, PyTypeObject*); + PyObject *(*Time_FromTime)(int, int, int, int, PyObject*, PyTypeObject*); + PyObject *(*Delta_FromDelta)(int, int, int, int, PyTypeObject*); + PyObject *(*TimeZone_FromTimeZone)(PyObject *offset, PyObject *name); + + /* constructors for the DB API */ + PyObject *(*DateTime_FromTimestamp)(PyObject*, PyObject*, PyObject*); + PyObject *(*Date_FromTimestamp)(PyObject*, PyObject*); + + /* PEP 495 constructors */ + PyObject *(*DateTime_FromDateAndTimeAndFold)(int, int, int, int, int, int, int, + PyObject*, int, PyTypeObject*); + PyObject *(*Time_FromTimeAndFold)(int, int, int, int, PyObject*, int, PyTypeObject*); + +} PyDateTime_CAPI; + +#define PyDateTime_CAPSULE_NAME "datetime.datetime_CAPI" + + +/* This block is only used as part of the public API and should not be + * included in _datetimemodule.c, which does not use the C API capsule. + * See bpo-35081 for more details. + * */ +#ifndef _PY_DATETIME_IMPL +/* Define global variable for the C API and a macro for setting it. */ +static PyDateTime_CAPI *PyDateTimeAPI = NULL; + +#define PyDateTime_IMPORT \ + PyDateTimeAPI = (PyDateTime_CAPI *)PyCapsule_Import(PyDateTime_CAPSULE_NAME, 0) + +/* Macro for access to the UTC singleton */ +#define PyDateTime_TimeZone_UTC PyDateTimeAPI->TimeZone_UTC + +/* Macros for type checking when not building the Python core. */ +#define PyDate_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DateType) +#define PyDate_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->DateType) + +#define PyDateTime_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DateTimeType) +#define PyDateTime_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->DateTimeType) + +#define PyTime_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->TimeType) +#define PyTime_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->TimeType) + +#define PyDelta_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DeltaType) +#define PyDelta_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->DeltaType) + +#define PyTZInfo_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->TZInfoType) +#define PyTZInfo_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->TZInfoType) + + +/* Macros for accessing constructors in a simplified fashion. */ +#define PyDate_FromDate(year, month, day) \ + PyDateTimeAPI->Date_FromDate(year, month, day, PyDateTimeAPI->DateType) + +#define PyDateTime_FromDateAndTime(year, month, day, hour, min, sec, usec) \ + PyDateTimeAPI->DateTime_FromDateAndTime(year, month, day, hour, \ + min, sec, usec, Py_None, PyDateTimeAPI->DateTimeType) + +#define PyDateTime_FromDateAndTimeAndFold(year, month, day, hour, min, sec, usec, fold) \ + PyDateTimeAPI->DateTime_FromDateAndTimeAndFold(year, month, day, hour, \ + min, sec, usec, Py_None, fold, PyDateTimeAPI->DateTimeType) + +#define PyTime_FromTime(hour, minute, second, usecond) \ + PyDateTimeAPI->Time_FromTime(hour, minute, second, usecond, \ + Py_None, PyDateTimeAPI->TimeType) + +#define PyTime_FromTimeAndFold(hour, minute, second, usecond, fold) \ + PyDateTimeAPI->Time_FromTimeAndFold(hour, minute, second, usecond, \ + Py_None, fold, PyDateTimeAPI->TimeType) + +#define PyDelta_FromDSU(days, seconds, useconds) \ + PyDateTimeAPI->Delta_FromDelta(days, seconds, useconds, 1, \ + PyDateTimeAPI->DeltaType) + +#define PyTimeZone_FromOffset(offset) \ + PyDateTimeAPI->TimeZone_FromTimeZone(offset, NULL) + +#define PyTimeZone_FromOffsetAndName(offset, name) \ + PyDateTimeAPI->TimeZone_FromTimeZone(offset, name) + +/* Macros supporting the DB API. */ +#define PyDateTime_FromTimestamp(args) \ + PyDateTimeAPI->DateTime_FromTimestamp( \ + (PyObject*) (PyDateTimeAPI->DateTimeType), args, NULL) + +#define PyDate_FromTimestamp(args) \ + PyDateTimeAPI->Date_FromTimestamp( \ + (PyObject*) (PyDateTimeAPI->DateType), args) + +#endif /* !defined(_PY_DATETIME_IMPL) */ + +#ifdef __cplusplus +} +#endif +#endif +#endif /* !Py_LIMITED_API */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/descrobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/descrobject.h new file mode 100644 index 0000000000000000000000000000000000000000..77f221df07714fe59555426855b2d2be019652cd --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/descrobject.h @@ -0,0 +1,44 @@ +/* Descriptors */ +#ifndef Py_DESCROBJECT_H +#define Py_DESCROBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +typedef PyObject *(*getter)(PyObject *, void *); +typedef int (*setter)(PyObject *, PyObject *, void *); + +struct PyGetSetDef { + const char *name; + getter get; + setter set; + const char *doc; + void *closure; +}; + +PyAPI_DATA(PyTypeObject) PyClassMethodDescr_Type; +PyAPI_DATA(PyTypeObject) PyGetSetDescr_Type; +PyAPI_DATA(PyTypeObject) PyMemberDescr_Type; +PyAPI_DATA(PyTypeObject) PyMethodDescr_Type; +PyAPI_DATA(PyTypeObject) PyWrapperDescr_Type; +PyAPI_DATA(PyTypeObject) PyDictProxy_Type; +PyAPI_DATA(PyTypeObject) PyProperty_Type; + +PyAPI_FUNC(PyObject *) PyDescr_NewMethod(PyTypeObject *, PyMethodDef *); +PyAPI_FUNC(PyObject *) PyDescr_NewClassMethod(PyTypeObject *, PyMethodDef *); +PyAPI_FUNC(PyObject *) PyDescr_NewMember(PyTypeObject *, PyMemberDef *); +PyAPI_FUNC(PyObject *) PyDescr_NewGetSet(PyTypeObject *, PyGetSetDef *); + +PyAPI_FUNC(PyObject *) PyDictProxy_New(PyObject *); +PyAPI_FUNC(PyObject *) PyWrapper_New(PyObject *, PyObject *); + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_DESCROBJECT_H +# include "cpython/descrobject.h" +# undef Py_CPYTHON_DESCROBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_DESCROBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/dictobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/dictobject.h new file mode 100644 index 0000000000000000000000000000000000000000..a6233d8ae2512a517598d03ca65602cbe22365b4 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/dictobject.h @@ -0,0 +1,97 @@ +#ifndef Py_DICTOBJECT_H +#define Py_DICTOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +/* Dictionary object type -- mapping from hashable object to object */ + +/* The distribution includes a separate file, Objects/dictnotes.txt, + describing explorations into dictionary design and optimization. + It covers typical dictionary use patterns, the parameters for + tuning dictionaries, and several ideas for possible optimizations. +*/ + +PyAPI_DATA(PyTypeObject) PyDict_Type; + +#define PyDict_Check(op) \ + PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_DICT_SUBCLASS) +#define PyDict_CheckExact(op) Py_IS_TYPE(op, &PyDict_Type) + +PyAPI_FUNC(PyObject *) PyDict_New(void); +PyAPI_FUNC(PyObject *) PyDict_GetItem(PyObject *mp, PyObject *key); +PyAPI_FUNC(PyObject *) PyDict_GetItemWithError(PyObject *mp, PyObject *key); +PyAPI_FUNC(int) PyDict_SetItem(PyObject *mp, PyObject *key, PyObject *item); +PyAPI_FUNC(int) PyDict_DelItem(PyObject *mp, PyObject *key); +PyAPI_FUNC(void) PyDict_Clear(PyObject *mp); +PyAPI_FUNC(int) PyDict_Next( + PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value); +PyAPI_FUNC(PyObject *) PyDict_Keys(PyObject *mp); +PyAPI_FUNC(PyObject *) PyDict_Values(PyObject *mp); +PyAPI_FUNC(PyObject *) PyDict_Items(PyObject *mp); +PyAPI_FUNC(Py_ssize_t) PyDict_Size(PyObject *mp); +PyAPI_FUNC(PyObject *) PyDict_Copy(PyObject *mp); +PyAPI_FUNC(int) PyDict_Contains(PyObject *mp, PyObject *key); + +/* PyDict_Update(mp, other) is equivalent to PyDict_Merge(mp, other, 1). */ +PyAPI_FUNC(int) PyDict_Update(PyObject *mp, PyObject *other); + +/* PyDict_Merge updates/merges from a mapping object (an object that + supports PyMapping_Keys() and PyObject_GetItem()). If override is true, + the last occurrence of a key wins, else the first. The Python + dict.update(other) is equivalent to PyDict_Merge(dict, other, 1). +*/ +PyAPI_FUNC(int) PyDict_Merge(PyObject *mp, + PyObject *other, + int override); + +/* PyDict_MergeFromSeq2 updates/merges from an iterable object producing + iterable objects of length 2. If override is true, the last occurrence + of a key wins, else the first. The Python dict constructor dict(seq2) + is equivalent to dict={}; PyDict_MergeFromSeq(dict, seq2, 1). +*/ +PyAPI_FUNC(int) PyDict_MergeFromSeq2(PyObject *d, + PyObject *seq2, + int override); + +PyAPI_FUNC(PyObject *) PyDict_GetItemString(PyObject *dp, const char *key); +PyAPI_FUNC(int) PyDict_SetItemString(PyObject *dp, const char *key, PyObject *item); +PyAPI_FUNC(int) PyDict_DelItemString(PyObject *dp, const char *key); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 +PyAPI_FUNC(PyObject *) PyObject_GenericGetDict(PyObject *, void *); +#endif + +/* Dictionary (keys, values, items) views */ + +PyAPI_DATA(PyTypeObject) PyDictKeys_Type; +PyAPI_DATA(PyTypeObject) PyDictValues_Type; +PyAPI_DATA(PyTypeObject) PyDictItems_Type; + +#define PyDictKeys_Check(op) PyObject_TypeCheck(op, &PyDictKeys_Type) +#define PyDictValues_Check(op) PyObject_TypeCheck(op, &PyDictValues_Type) +#define PyDictItems_Check(op) PyObject_TypeCheck(op, &PyDictItems_Type) +/* This excludes Values, since they are not sets. */ +# define PyDictViewSet_Check(op) \ + (PyDictKeys_Check(op) || PyDictItems_Check(op)) + +/* Dictionary (key, value, items) iterators */ + +PyAPI_DATA(PyTypeObject) PyDictIterKey_Type; +PyAPI_DATA(PyTypeObject) PyDictIterValue_Type; +PyAPI_DATA(PyTypeObject) PyDictIterItem_Type; + +PyAPI_DATA(PyTypeObject) PyDictRevIterKey_Type; +PyAPI_DATA(PyTypeObject) PyDictRevIterItem_Type; +PyAPI_DATA(PyTypeObject) PyDictRevIterValue_Type; + + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_DICTOBJECT_H +# include "cpython/dictobject.h" +# undef Py_CPYTHON_DICTOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_DICTOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/dynamic_annotations.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/dynamic_annotations.h new file mode 100644 index 0000000000000000000000000000000000000000..4d4def9bf8983e21209b598fc7cba728ca8c1d4c --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/dynamic_annotations.h @@ -0,0 +1,499 @@ +/* Copyright (c) 2008-2009, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * --- + * Author: Kostya Serebryany + * Copied to CPython by Jeffrey Yasskin, with all macros renamed to + * start with _Py_ to avoid colliding with users embedding Python, and + * with deprecated macros removed. + */ + +/* This file defines dynamic annotations for use with dynamic analysis + tool such as valgrind, PIN, etc. + + Dynamic annotation is a source code annotation that affects + the generated code (that is, the annotation is not a comment). + Each such annotation is attached to a particular + instruction and/or to a particular object (address) in the program. + + The annotations that should be used by users are macros in all upper-case + (e.g., _Py_ANNOTATE_NEW_MEMORY). + + Actual implementation of these macros may differ depending on the + dynamic analysis tool being used. + + See https://code.google.com/p/data-race-test/ for more information. + + This file supports the following dynamic analysis tools: + - None (DYNAMIC_ANNOTATIONS_ENABLED is not defined or zero). + Macros are defined empty. + - ThreadSanitizer, Helgrind, DRD (DYNAMIC_ANNOTATIONS_ENABLED is 1). + Macros are defined as calls to non-inlinable empty functions + that are intercepted by Valgrind. */ + +#ifndef __DYNAMIC_ANNOTATIONS_H__ +#define __DYNAMIC_ANNOTATIONS_H__ + +#ifndef DYNAMIC_ANNOTATIONS_ENABLED +# define DYNAMIC_ANNOTATIONS_ENABLED 0 +#endif + +#if DYNAMIC_ANNOTATIONS_ENABLED != 0 + + /* ------------------------------------------------------------- + Annotations useful when implementing condition variables such as CondVar, + using conditional critical sections (Await/LockWhen) and when constructing + user-defined synchronization mechanisms. + + The annotations _Py_ANNOTATE_HAPPENS_BEFORE() and + _Py_ANNOTATE_HAPPENS_AFTER() can be used to define happens-before arcs in + user-defined synchronization mechanisms: the race detector will infer an + arc from the former to the latter when they share the same argument + pointer. + + Example 1 (reference counting): + + void Unref() { + _Py_ANNOTATE_HAPPENS_BEFORE(&refcount_); + if (AtomicDecrementByOne(&refcount_) == 0) { + _Py_ANNOTATE_HAPPENS_AFTER(&refcount_); + delete this; + } + } + + Example 2 (message queue): + + void MyQueue::Put(Type *e) { + MutexLock lock(&mu_); + _Py_ANNOTATE_HAPPENS_BEFORE(e); + PutElementIntoMyQueue(e); + } + + Type *MyQueue::Get() { + MutexLock lock(&mu_); + Type *e = GetElementFromMyQueue(); + _Py_ANNOTATE_HAPPENS_AFTER(e); + return e; + } + + Note: when possible, please use the existing reference counting and message + queue implementations instead of inventing new ones. */ + + /* Report that wait on the condition variable at address "cv" has succeeded + and the lock at address "lock" is held. */ +#define _Py_ANNOTATE_CONDVAR_LOCK_WAIT(cv, lock) \ + AnnotateCondVarWait(__FILE__, __LINE__, cv, lock) + + /* Report that wait on the condition variable at "cv" has succeeded. Variant + w/o lock. */ +#define _Py_ANNOTATE_CONDVAR_WAIT(cv) \ + AnnotateCondVarWait(__FILE__, __LINE__, cv, NULL) + + /* Report that we are about to signal on the condition variable at address + "cv". */ +#define _Py_ANNOTATE_CONDVAR_SIGNAL(cv) \ + AnnotateCondVarSignal(__FILE__, __LINE__, cv) + + /* Report that we are about to signal_all on the condition variable at "cv". */ +#define _Py_ANNOTATE_CONDVAR_SIGNAL_ALL(cv) \ + AnnotateCondVarSignalAll(__FILE__, __LINE__, cv) + + /* Annotations for user-defined synchronization mechanisms. */ +#define _Py_ANNOTATE_HAPPENS_BEFORE(obj) _Py_ANNOTATE_CONDVAR_SIGNAL(obj) +#define _Py_ANNOTATE_HAPPENS_AFTER(obj) _Py_ANNOTATE_CONDVAR_WAIT(obj) + + /* Report that the bytes in the range [pointer, pointer+size) are about + to be published safely. The race checker will create a happens-before + arc from the call _Py_ANNOTATE_PUBLISH_MEMORY_RANGE(pointer, size) to + subsequent accesses to this memory. + Note: this annotation may not work properly if the race detector uses + sampling, i.e. does not observe all memory accesses. + */ +#define _Py_ANNOTATE_PUBLISH_MEMORY_RANGE(pointer, size) \ + AnnotatePublishMemoryRange(__FILE__, __LINE__, pointer, size) + + /* Instruct the tool to create a happens-before arc between mu->Unlock() and + mu->Lock(). This annotation may slow down the race detector and hide real + races. Normally it is used only when it would be difficult to annotate each + of the mutex's critical sections individually using the annotations above. + This annotation makes sense only for hybrid race detectors. For pure + happens-before detectors this is a no-op. For more details see + https://code.google.com/p/data-race-test/wiki/PureHappensBeforeVsHybrid . */ +#define _Py_ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(mu) \ + AnnotateMutexIsUsedAsCondVar(__FILE__, __LINE__, mu) + + /* ------------------------------------------------------------- + Annotations useful when defining memory allocators, or when memory that + was protected in one way starts to be protected in another. */ + + /* Report that a new memory at "address" of size "size" has been allocated. + This might be used when the memory has been retrieved from a free list and + is about to be reused, or when the locking discipline for a variable + changes. */ +#define _Py_ANNOTATE_NEW_MEMORY(address, size) \ + AnnotateNewMemory(__FILE__, __LINE__, address, size) + + /* ------------------------------------------------------------- + Annotations useful when defining FIFO queues that transfer data between + threads. */ + + /* Report that the producer-consumer queue (such as ProducerConsumerQueue) at + address "pcq" has been created. The _Py_ANNOTATE_PCQ_* annotations should + be used only for FIFO queues. For non-FIFO queues use + _Py_ANNOTATE_HAPPENS_BEFORE (for put) and _Py_ANNOTATE_HAPPENS_AFTER (for + get). */ +#define _Py_ANNOTATE_PCQ_CREATE(pcq) \ + AnnotatePCQCreate(__FILE__, __LINE__, pcq) + + /* Report that the queue at address "pcq" is about to be destroyed. */ +#define _Py_ANNOTATE_PCQ_DESTROY(pcq) \ + AnnotatePCQDestroy(__FILE__, __LINE__, pcq) + + /* Report that we are about to put an element into a FIFO queue at address + "pcq". */ +#define _Py_ANNOTATE_PCQ_PUT(pcq) \ + AnnotatePCQPut(__FILE__, __LINE__, pcq) + + /* Report that we've just got an element from a FIFO queue at address "pcq". */ +#define _Py_ANNOTATE_PCQ_GET(pcq) \ + AnnotatePCQGet(__FILE__, __LINE__, pcq) + + /* ------------------------------------------------------------- + Annotations that suppress errors. It is usually better to express the + program's synchronization using the other annotations, but these can + be used when all else fails. */ + + /* Report that we may have a benign race at "pointer", with size + "sizeof(*(pointer))". "pointer" must be a non-void* pointer. Insert at the + point where "pointer" has been allocated, preferably close to the point + where the race happens. See also _Py_ANNOTATE_BENIGN_RACE_STATIC. */ +#define _Py_ANNOTATE_BENIGN_RACE(pointer, description) \ + AnnotateBenignRaceSized(__FILE__, __LINE__, pointer, \ + sizeof(*(pointer)), description) + + /* Same as _Py_ANNOTATE_BENIGN_RACE(address, description), but applies to + the memory range [address, address+size). */ +#define _Py_ANNOTATE_BENIGN_RACE_SIZED(address, size, description) \ + AnnotateBenignRaceSized(__FILE__, __LINE__, address, size, description) + + /* Request the analysis tool to ignore all reads in the current thread + until _Py_ANNOTATE_IGNORE_READS_END is called. + Useful to ignore intentional racey reads, while still checking + other reads and all writes. + See also _Py_ANNOTATE_UNPROTECTED_READ. */ +#define _Py_ANNOTATE_IGNORE_READS_BEGIN() \ + AnnotateIgnoreReadsBegin(__FILE__, __LINE__) + + /* Stop ignoring reads. */ +#define _Py_ANNOTATE_IGNORE_READS_END() \ + AnnotateIgnoreReadsEnd(__FILE__, __LINE__) + + /* Similar to _Py_ANNOTATE_IGNORE_READS_BEGIN, but ignore writes. */ +#define _Py_ANNOTATE_IGNORE_WRITES_BEGIN() \ + AnnotateIgnoreWritesBegin(__FILE__, __LINE__) + + /* Stop ignoring writes. */ +#define _Py_ANNOTATE_IGNORE_WRITES_END() \ + AnnotateIgnoreWritesEnd(__FILE__, __LINE__) + + /* Start ignoring all memory accesses (reads and writes). */ +#define _Py_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() \ + do {\ + _Py_ANNOTATE_IGNORE_READS_BEGIN();\ + _Py_ANNOTATE_IGNORE_WRITES_BEGIN();\ + }while(0)\ + + /* Stop ignoring all memory accesses. */ +#define _Py_ANNOTATE_IGNORE_READS_AND_WRITES_END() \ + do {\ + _Py_ANNOTATE_IGNORE_WRITES_END();\ + _Py_ANNOTATE_IGNORE_READS_END();\ + }while(0)\ + + /* Similar to _Py_ANNOTATE_IGNORE_READS_BEGIN, but ignore synchronization events: + RWLOCK* and CONDVAR*. */ +#define _Py_ANNOTATE_IGNORE_SYNC_BEGIN() \ + AnnotateIgnoreSyncBegin(__FILE__, __LINE__) + + /* Stop ignoring sync events. */ +#define _Py_ANNOTATE_IGNORE_SYNC_END() \ + AnnotateIgnoreSyncEnd(__FILE__, __LINE__) + + + /* Enable (enable!=0) or disable (enable==0) race detection for all threads. + This annotation could be useful if you want to skip expensive race analysis + during some period of program execution, e.g. during initialization. */ +#define _Py_ANNOTATE_ENABLE_RACE_DETECTION(enable) \ + AnnotateEnableRaceDetection(__FILE__, __LINE__, enable) + + /* ------------------------------------------------------------- + Annotations useful for debugging. */ + + /* Request to trace every access to "address". */ +#define _Py_ANNOTATE_TRACE_MEMORY(address) \ + AnnotateTraceMemory(__FILE__, __LINE__, address) + + /* Report the current thread name to a race detector. */ +#define _Py_ANNOTATE_THREAD_NAME(name) \ + AnnotateThreadName(__FILE__, __LINE__, name) + + /* ------------------------------------------------------------- + Annotations useful when implementing locks. They are not + normally needed by modules that merely use locks. + The "lock" argument is a pointer to the lock object. */ + + /* Report that a lock has been created at address "lock". */ +#define _Py_ANNOTATE_RWLOCK_CREATE(lock) \ + AnnotateRWLockCreate(__FILE__, __LINE__, lock) + + /* Report that the lock at address "lock" is about to be destroyed. */ +#define _Py_ANNOTATE_RWLOCK_DESTROY(lock) \ + AnnotateRWLockDestroy(__FILE__, __LINE__, lock) + + /* Report that the lock at address "lock" has been acquired. + is_w=1 for writer lock, is_w=0 for reader lock. */ +#define _Py_ANNOTATE_RWLOCK_ACQUIRED(lock, is_w) \ + AnnotateRWLockAcquired(__FILE__, __LINE__, lock, is_w) + + /* Report that the lock at address "lock" is about to be released. */ +#define _Py_ANNOTATE_RWLOCK_RELEASED(lock, is_w) \ + AnnotateRWLockReleased(__FILE__, __LINE__, lock, is_w) + + /* ------------------------------------------------------------- + Annotations useful when implementing barriers. They are not + normally needed by modules that merely use barriers. + The "barrier" argument is a pointer to the barrier object. */ + + /* Report that the "barrier" has been initialized with initial "count". + If 'reinitialization_allowed' is true, initialization is allowed to happen + multiple times w/o calling barrier_destroy() */ +#define _Py_ANNOTATE_BARRIER_INIT(barrier, count, reinitialization_allowed) \ + AnnotateBarrierInit(__FILE__, __LINE__, barrier, count, \ + reinitialization_allowed) + + /* Report that we are about to enter barrier_wait("barrier"). */ +#define _Py_ANNOTATE_BARRIER_WAIT_BEFORE(barrier) \ + AnnotateBarrierWaitBefore(__FILE__, __LINE__, barrier) + + /* Report that we just exited barrier_wait("barrier"). */ +#define _Py_ANNOTATE_BARRIER_WAIT_AFTER(barrier) \ + AnnotateBarrierWaitAfter(__FILE__, __LINE__, barrier) + + /* Report that the "barrier" has been destroyed. */ +#define _Py_ANNOTATE_BARRIER_DESTROY(barrier) \ + AnnotateBarrierDestroy(__FILE__, __LINE__, barrier) + + /* ------------------------------------------------------------- + Annotations useful for testing race detectors. */ + + /* Report that we expect a race on the variable at "address". + Use only in unit tests for a race detector. */ +#define _Py_ANNOTATE_EXPECT_RACE(address, description) \ + AnnotateExpectRace(__FILE__, __LINE__, address, description) + + /* A no-op. Insert where you like to test the interceptors. */ +#define _Py_ANNOTATE_NO_OP(arg) \ + AnnotateNoOp(__FILE__, __LINE__, arg) + + /* Force the race detector to flush its state. The actual effect depends on + * the implementation of the detector. */ +#define _Py_ANNOTATE_FLUSH_STATE() \ + AnnotateFlushState(__FILE__, __LINE__) + + +#else /* DYNAMIC_ANNOTATIONS_ENABLED == 0 */ + +#define _Py_ANNOTATE_RWLOCK_CREATE(lock) /* empty */ +#define _Py_ANNOTATE_RWLOCK_DESTROY(lock) /* empty */ +#define _Py_ANNOTATE_RWLOCK_ACQUIRED(lock, is_w) /* empty */ +#define _Py_ANNOTATE_RWLOCK_RELEASED(lock, is_w) /* empty */ +#define _Py_ANNOTATE_BARRIER_INIT(barrier, count, reinitialization_allowed) /* */ +#define _Py_ANNOTATE_BARRIER_WAIT_BEFORE(barrier) /* empty */ +#define _Py_ANNOTATE_BARRIER_WAIT_AFTER(barrier) /* empty */ +#define _Py_ANNOTATE_BARRIER_DESTROY(barrier) /* empty */ +#define _Py_ANNOTATE_CONDVAR_LOCK_WAIT(cv, lock) /* empty */ +#define _Py_ANNOTATE_CONDVAR_WAIT(cv) /* empty */ +#define _Py_ANNOTATE_CONDVAR_SIGNAL(cv) /* empty */ +#define _Py_ANNOTATE_CONDVAR_SIGNAL_ALL(cv) /* empty */ +#define _Py_ANNOTATE_HAPPENS_BEFORE(obj) /* empty */ +#define _Py_ANNOTATE_HAPPENS_AFTER(obj) /* empty */ +#define _Py_ANNOTATE_PUBLISH_MEMORY_RANGE(address, size) /* empty */ +#define _Py_ANNOTATE_UNPUBLISH_MEMORY_RANGE(address, size) /* empty */ +#define _Py_ANNOTATE_SWAP_MEMORY_RANGE(address, size) /* empty */ +#define _Py_ANNOTATE_PCQ_CREATE(pcq) /* empty */ +#define _Py_ANNOTATE_PCQ_DESTROY(pcq) /* empty */ +#define _Py_ANNOTATE_PCQ_PUT(pcq) /* empty */ +#define _Py_ANNOTATE_PCQ_GET(pcq) /* empty */ +#define _Py_ANNOTATE_NEW_MEMORY(address, size) /* empty */ +#define _Py_ANNOTATE_EXPECT_RACE(address, description) /* empty */ +#define _Py_ANNOTATE_BENIGN_RACE(address, description) /* empty */ +#define _Py_ANNOTATE_BENIGN_RACE_SIZED(address, size, description) /* empty */ +#define _Py_ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(mu) /* empty */ +#define _Py_ANNOTATE_MUTEX_IS_USED_AS_CONDVAR(mu) /* empty */ +#define _Py_ANNOTATE_TRACE_MEMORY(arg) /* empty */ +#define _Py_ANNOTATE_THREAD_NAME(name) /* empty */ +#define _Py_ANNOTATE_IGNORE_READS_BEGIN() /* empty */ +#define _Py_ANNOTATE_IGNORE_READS_END() /* empty */ +#define _Py_ANNOTATE_IGNORE_WRITES_BEGIN() /* empty */ +#define _Py_ANNOTATE_IGNORE_WRITES_END() /* empty */ +#define _Py_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() /* empty */ +#define _Py_ANNOTATE_IGNORE_READS_AND_WRITES_END() /* empty */ +#define _Py_ANNOTATE_IGNORE_SYNC_BEGIN() /* empty */ +#define _Py_ANNOTATE_IGNORE_SYNC_END() /* empty */ +#define _Py_ANNOTATE_ENABLE_RACE_DETECTION(enable) /* empty */ +#define _Py_ANNOTATE_NO_OP(arg) /* empty */ +#define _Py_ANNOTATE_FLUSH_STATE() /* empty */ + +#endif /* DYNAMIC_ANNOTATIONS_ENABLED */ + +/* Use the macros above rather than using these functions directly. */ +#ifdef __cplusplus +extern "C" { +#endif +void AnnotateRWLockCreate(const char *file, int line, + const volatile void *lock); +void AnnotateRWLockDestroy(const char *file, int line, + const volatile void *lock); +void AnnotateRWLockAcquired(const char *file, int line, + const volatile void *lock, long is_w); +void AnnotateRWLockReleased(const char *file, int line, + const volatile void *lock, long is_w); +void AnnotateBarrierInit(const char *file, int line, + const volatile void *barrier, long count, + long reinitialization_allowed); +void AnnotateBarrierWaitBefore(const char *file, int line, + const volatile void *barrier); +void AnnotateBarrierWaitAfter(const char *file, int line, + const volatile void *barrier); +void AnnotateBarrierDestroy(const char *file, int line, + const volatile void *barrier); +void AnnotateCondVarWait(const char *file, int line, + const volatile void *cv, + const volatile void *lock); +void AnnotateCondVarSignal(const char *file, int line, + const volatile void *cv); +void AnnotateCondVarSignalAll(const char *file, int line, + const volatile void *cv); +void AnnotatePublishMemoryRange(const char *file, int line, + const volatile void *address, + long size); +void AnnotateUnpublishMemoryRange(const char *file, int line, + const volatile void *address, + long size); +void AnnotatePCQCreate(const char *file, int line, + const volatile void *pcq); +void AnnotatePCQDestroy(const char *file, int line, + const volatile void *pcq); +void AnnotatePCQPut(const char *file, int line, + const volatile void *pcq); +void AnnotatePCQGet(const char *file, int line, + const volatile void *pcq); +void AnnotateNewMemory(const char *file, int line, + const volatile void *address, + long size); +void AnnotateExpectRace(const char *file, int line, + const volatile void *address, + const char *description); +void AnnotateBenignRace(const char *file, int line, + const volatile void *address, + const char *description); +void AnnotateBenignRaceSized(const char *file, int line, + const volatile void *address, + long size, + const char *description); +void AnnotateMutexIsUsedAsCondVar(const char *file, int line, + const volatile void *mu); +void AnnotateTraceMemory(const char *file, int line, + const volatile void *arg); +void AnnotateThreadName(const char *file, int line, + const char *name); +void AnnotateIgnoreReadsBegin(const char *file, int line); +void AnnotateIgnoreReadsEnd(const char *file, int line); +void AnnotateIgnoreWritesBegin(const char *file, int line); +void AnnotateIgnoreWritesEnd(const char *file, int line); +void AnnotateEnableRaceDetection(const char *file, int line, int enable); +void AnnotateNoOp(const char *file, int line, + const volatile void *arg); +void AnnotateFlushState(const char *file, int line); + +/* Return non-zero value if running under valgrind. + + If "valgrind.h" is included into dynamic_annotations.c, + the regular valgrind mechanism will be used. + See http://valgrind.org/docs/manual/manual-core-adv.html about + RUNNING_ON_VALGRIND and other valgrind "client requests". + The file "valgrind.h" may be obtained by doing + svn co svn://svn.valgrind.org/valgrind/trunk/include + + If for some reason you can't use "valgrind.h" or want to fake valgrind, + there are two ways to make this function return non-zero: + - Use environment variable: export RUNNING_ON_VALGRIND=1 + - Make your tool intercept the function RunningOnValgrind() and + change its return value. + */ +int RunningOnValgrind(void); + +#ifdef __cplusplus +} +#endif + +#if DYNAMIC_ANNOTATIONS_ENABLED != 0 && defined(__cplusplus) + + /* _Py_ANNOTATE_UNPROTECTED_READ is the preferred way to annotate racey reads. + + Instead of doing + _Py_ANNOTATE_IGNORE_READS_BEGIN(); + ... = x; + _Py_ANNOTATE_IGNORE_READS_END(); + one can use + ... = _Py_ANNOTATE_UNPROTECTED_READ(x); */ + template + inline T _Py_ANNOTATE_UNPROTECTED_READ(const volatile T &x) { + _Py_ANNOTATE_IGNORE_READS_BEGIN(); + T res = x; + _Py_ANNOTATE_IGNORE_READS_END(); + return res; + } + /* Apply _Py_ANNOTATE_BENIGN_RACE_SIZED to a static variable. */ +#define _Py_ANNOTATE_BENIGN_RACE_STATIC(static_var, description) \ + namespace { \ + class static_var ## _annotator { \ + public: \ + static_var ## _annotator() { \ + _Py_ANNOTATE_BENIGN_RACE_SIZED(&static_var, \ + sizeof(static_var), \ + # static_var ": " description); \ + } \ + }; \ + static static_var ## _annotator the ## static_var ## _annotator;\ + } +#else /* DYNAMIC_ANNOTATIONS_ENABLED == 0 */ + +#define _Py_ANNOTATE_UNPROTECTED_READ(x) (x) +#define _Py_ANNOTATE_BENIGN_RACE_STATIC(static_var, description) /* empty */ + +#endif /* DYNAMIC_ANNOTATIONS_ENABLED */ + +#endif /* __DYNAMIC_ANNOTATIONS_H__ */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/enumobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/enumobject.h new file mode 100644 index 0000000000000000000000000000000000000000..c14dbfc8c37e7c9316b9cca0a5969ee925d729d8 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/enumobject.h @@ -0,0 +1,17 @@ +#ifndef Py_ENUMOBJECT_H +#define Py_ENUMOBJECT_H + +/* Enumerate Object */ + +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_DATA(PyTypeObject) PyEnum_Type; +PyAPI_DATA(PyTypeObject) PyReversed_Type; + +#ifdef __cplusplus +} +#endif + +#endif /* !Py_ENUMOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/errcode.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/errcode.h new file mode 100644 index 0000000000000000000000000000000000000000..19ee83ec73d8cd124ab76440b7046efe432ec7fa --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/errcode.h @@ -0,0 +1,39 @@ +#ifndef Py_ERRCODE_H +#define Py_ERRCODE_H +#ifdef __cplusplus +extern "C" { +#endif + +/* Error codes passed around between file input, tokenizer, parser and + interpreter. This is necessary so we can turn them into Python + exceptions at a higher level. Note that some errors have a + slightly different meaning when passed from the tokenizer to the + parser than when passed from the parser to the interpreter; e.g. + the parser only returns E_EOF when it hits EOF immediately, and it + never returns E_OK. */ + +#define E_OK 10 /* No error */ +#define E_EOF 11 /* End Of File */ +#define E_INTR 12 /* Interrupted */ +#define E_TOKEN 13 /* Bad token */ +#define E_SYNTAX 14 /* Syntax error */ +#define E_NOMEM 15 /* Ran out of memory */ +#define E_DONE 16 /* Parsing complete */ +#define E_ERROR 17 /* Execution error */ +#define E_TABSPACE 18 /* Inconsistent mixing of tabs and spaces */ +#define E_OVERFLOW 19 /* Node had too many children */ +#define E_TOODEEP 20 /* Too many indentation levels */ +#define E_DEDENT 21 /* No matching outer block for dedent */ +#define E_DECODE 22 /* Error in decoding into Unicode */ +#define E_EOFS 23 /* EOF in triple-quoted string */ +#define E_EOLS 24 /* EOL in single-quoted string */ +#define E_LINECONT 25 /* Unexpected characters after a line continuation */ +#define E_BADSINGLE 27 /* Ill-formed single statement input */ +#define E_INTERACT_STOP 28 /* Interactive mode stopped tokenization */ +#define E_COLUMNOVERFLOW 29 /* Column offset overflow */ + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_ERRCODE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/exports.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/exports.h new file mode 100644 index 0000000000000000000000000000000000000000..fc1a5c5ead6276e856de8e07080a125375a8acd0 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/exports.h @@ -0,0 +1,30 @@ +#ifndef Py_EXPORTS_H +#define Py_EXPORTS_H + +#if defined(_WIN32) || defined(__CYGWIN__) + #define Py_IMPORTED_SYMBOL __declspec(dllimport) + #define Py_EXPORTED_SYMBOL __declspec(dllexport) + #define Py_LOCAL_SYMBOL +#else +/* + * If we only ever used gcc >= 5, we could use __has_attribute(visibility) + * as a cross-platform way to determine if visibility is supported. However, + * we may still need to support gcc >= 4, as some Ubuntu LTS and Centos versions + * have 4 < gcc < 5. + */ + #ifndef __has_attribute + #define __has_attribute(x) 0 // Compatibility with non-clang compilers. + #endif + #if (defined(__GNUC__) && (__GNUC__ >= 4)) ||\ + (defined(__clang__) && __has_attribute(visibility)) + #define Py_IMPORTED_SYMBOL __attribute__ ((visibility ("default"))) + #define Py_EXPORTED_SYMBOL __attribute__ ((visibility ("default"))) + #define Py_LOCAL_SYMBOL __attribute__ ((visibility ("hidden"))) + #else + #define Py_IMPORTED_SYMBOL + #define Py_EXPORTED_SYMBOL + #define Py_LOCAL_SYMBOL + #endif +#endif + +#endif /* Py_EXPORTS_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/fileobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/fileobject.h new file mode 100644 index 0000000000000000000000000000000000000000..4c983e7b5daa8ac96a403b52bdcbcf6c05600271 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/fileobject.h @@ -0,0 +1,49 @@ +/* File object interface (what's left of it -- see io.py) */ + +#ifndef Py_FILEOBJECT_H +#define Py_FILEOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#define PY_STDIOTEXTMODE "b" + +PyAPI_FUNC(PyObject *) PyFile_FromFd(int, const char *, const char *, int, + const char *, const char *, + const char *, int); +PyAPI_FUNC(PyObject *) PyFile_GetLine(PyObject *, int); +PyAPI_FUNC(int) PyFile_WriteObject(PyObject *, PyObject *, int); +PyAPI_FUNC(int) PyFile_WriteString(const char *, PyObject *); +PyAPI_FUNC(int) PyObject_AsFileDescriptor(PyObject *); + +/* The default encoding used by the platform file system APIs + If non-NULL, this is different than the default encoding for strings +*/ +PyAPI_DATA(const char *) Py_FileSystemDefaultEncoding; +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000 +PyAPI_DATA(const char *) Py_FileSystemDefaultEncodeErrors; +#endif +PyAPI_DATA(int) Py_HasFileSystemDefaultEncoding; + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000 +PyAPI_DATA(int) Py_UTF8Mode; +#endif + +/* A routine to check if a file descriptor can be select()-ed. */ +#ifdef _MSC_VER + /* On Windows, any socket fd can be select()-ed, no matter how high */ + #define _PyIsSelectable_fd(FD) (1) +#else + #define _PyIsSelectable_fd(FD) ((unsigned int)(FD) < (unsigned int)FD_SETSIZE) +#endif + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_FILEOBJECT_H +# include "cpython/fileobject.h" +# undef Py_CPYTHON_FILEOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_FILEOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/fileutils.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/fileutils.h new file mode 100644 index 0000000000000000000000000000000000000000..ba5acc84fcb18560f27f4f14c1cf44527e98f5ae --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/fileutils.h @@ -0,0 +1,26 @@ +#ifndef Py_FILEUTILS_H +#define Py_FILEUTILS_H +#ifdef __cplusplus +extern "C" { +#endif + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 +PyAPI_FUNC(wchar_t *) Py_DecodeLocale( + const char *arg, + size_t *size); + +PyAPI_FUNC(char*) Py_EncodeLocale( + const wchar_t *text, + size_t *error_pos); +#endif + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_FILEUTILS_H +# include "cpython/fileutils.h" +# undef Py_CPYTHON_FILEUTILS_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_FILEUTILS_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/floatobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/floatobject.h new file mode 100644 index 0000000000000000000000000000000000000000..9d2fff3097e8eca6dbfaefcaa517bc02ec623f8c --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/floatobject.h @@ -0,0 +1,54 @@ + +/* Float object interface */ + +/* +PyFloatObject represents a (double precision) floating point number. +*/ + +#ifndef Py_FLOATOBJECT_H +#define Py_FLOATOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_DATA(PyTypeObject) PyFloat_Type; + +#define PyFloat_Check(op) PyObject_TypeCheck(op, &PyFloat_Type) +#define PyFloat_CheckExact(op) Py_IS_TYPE(op, &PyFloat_Type) + +#define Py_RETURN_NAN return PyFloat_FromDouble(Py_NAN) + +#define Py_RETURN_INF(sign) \ + do { \ + if (copysign(1., sign) == 1.) { \ + return PyFloat_FromDouble(Py_HUGE_VAL); \ + } \ + else { \ + return PyFloat_FromDouble(-Py_HUGE_VAL); \ + } \ + } while(0) + +PyAPI_FUNC(double) PyFloat_GetMax(void); +PyAPI_FUNC(double) PyFloat_GetMin(void); +PyAPI_FUNC(PyObject*) PyFloat_GetInfo(void); + +/* Return Python float from string PyObject. */ +PyAPI_FUNC(PyObject*) PyFloat_FromString(PyObject*); + +/* Return Python float from C double. */ +PyAPI_FUNC(PyObject*) PyFloat_FromDouble(double); + +/* Extract C double from Python float. The macro version trades safety for + speed. */ +PyAPI_FUNC(double) PyFloat_AsDouble(PyObject*); + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_FLOATOBJECT_H +# include "cpython/floatobject.h" +# undef Py_CPYTHON_FLOATOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_FLOATOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/frameobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/frameobject.h new file mode 100644 index 0000000000000000000000000000000000000000..adb628f6314fcfc6bff80b4bb09483158354b91f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/frameobject.h @@ -0,0 +1,20 @@ +/* Frame object interface */ + +#ifndef Py_FRAMEOBJECT_H +#define Py_FRAMEOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#include "pyframe.h" + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_FRAMEOBJECT_H +# include "cpython/frameobject.h" +# undef Py_CPYTHON_FRAMEOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_FRAMEOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/genericaliasobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/genericaliasobject.h new file mode 100644 index 0000000000000000000000000000000000000000..cf002976b27cd7712ee80bf348f55c5c562bc12d --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/genericaliasobject.h @@ -0,0 +1,14 @@ +// Implementation of PEP 585: support list[int] etc. +#ifndef Py_GENERICALIASOBJECT_H +#define Py_GENERICALIASOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_FUNC(PyObject *) Py_GenericAlias(PyObject *, PyObject *); +PyAPI_DATA(PyTypeObject) Py_GenericAliasType; + +#ifdef __cplusplus +} +#endif +#endif /* !Py_GENERICALIASOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/import.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/import.h new file mode 100644 index 0000000000000000000000000000000000000000..a87677bb10c7f441dd980420b525e12de7cf42d3 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/import.h @@ -0,0 +1,98 @@ +/* Module definition and import interface */ + +#ifndef Py_IMPORT_H +#define Py_IMPORT_H +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_FUNC(long) PyImport_GetMagicNumber(void); +PyAPI_FUNC(const char *) PyImport_GetMagicTag(void); +PyAPI_FUNC(PyObject *) PyImport_ExecCodeModule( + const char *name, /* UTF-8 encoded string */ + PyObject *co + ); +PyAPI_FUNC(PyObject *) PyImport_ExecCodeModuleEx( + const char *name, /* UTF-8 encoded string */ + PyObject *co, + const char *pathname /* decoded from the filesystem encoding */ + ); +PyAPI_FUNC(PyObject *) PyImport_ExecCodeModuleWithPathnames( + const char *name, /* UTF-8 encoded string */ + PyObject *co, + const char *pathname, /* decoded from the filesystem encoding */ + const char *cpathname /* decoded from the filesystem encoding */ + ); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 +PyAPI_FUNC(PyObject *) PyImport_ExecCodeModuleObject( + PyObject *name, + PyObject *co, + PyObject *pathname, + PyObject *cpathname + ); +#endif +PyAPI_FUNC(PyObject *) PyImport_GetModuleDict(void); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000 +PyAPI_FUNC(PyObject *) PyImport_GetModule(PyObject *name); +#endif +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 +PyAPI_FUNC(PyObject *) PyImport_AddModuleObject( + PyObject *name + ); +#endif +PyAPI_FUNC(PyObject *) PyImport_AddModule( + const char *name /* UTF-8 encoded string */ + ); +PyAPI_FUNC(PyObject *) PyImport_ImportModule( + const char *name /* UTF-8 encoded string */ + ); +PyAPI_FUNC(PyObject *) PyImport_ImportModuleNoBlock( + const char *name /* UTF-8 encoded string */ + ); +PyAPI_FUNC(PyObject *) PyImport_ImportModuleLevel( + const char *name, /* UTF-8 encoded string */ + PyObject *globals, + PyObject *locals, + PyObject *fromlist, + int level + ); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 +PyAPI_FUNC(PyObject *) PyImport_ImportModuleLevelObject( + PyObject *name, + PyObject *globals, + PyObject *locals, + PyObject *fromlist, + int level + ); +#endif + +#define PyImport_ImportModuleEx(n, g, l, f) \ + PyImport_ImportModuleLevel(n, g, l, f, 0) + +PyAPI_FUNC(PyObject *) PyImport_GetImporter(PyObject *path); +PyAPI_FUNC(PyObject *) PyImport_Import(PyObject *name); +PyAPI_FUNC(PyObject *) PyImport_ReloadModule(PyObject *m); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 +PyAPI_FUNC(int) PyImport_ImportFrozenModuleObject( + PyObject *name + ); +#endif +PyAPI_FUNC(int) PyImport_ImportFrozenModule( + const char *name /* UTF-8 encoded string */ + ); + +PyAPI_FUNC(int) PyImport_AppendInittab( + const char *name, /* ASCII encoded string */ + PyObject* (*initfunc)(void) + ); + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_IMPORT_H +# include "cpython/import.h" +# undef Py_CPYTHON_IMPORT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_IMPORT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/intrcheck.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/intrcheck.h new file mode 100644 index 0000000000000000000000000000000000000000..b8cc65601683cba552aad8eb0208c04f833470e1 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/intrcheck.h @@ -0,0 +1,30 @@ +#ifndef Py_INTRCHECK_H +#define Py_INTRCHECK_H +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_FUNC(int) PyOS_InterruptOccurred(void); +#ifdef HAVE_FORK +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000 +PyAPI_FUNC(void) PyOS_BeforeFork(void); +PyAPI_FUNC(void) PyOS_AfterFork_Parent(void); +PyAPI_FUNC(void) PyOS_AfterFork_Child(void); +#endif +#endif +/* Deprecated, please use PyOS_AfterFork_Child() instead */ +Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyOS_AfterFork(void); + +#ifndef Py_LIMITED_API +PyAPI_FUNC(int) _PyOS_IsMainThread(void); + +#ifdef MS_WINDOWS +/* windows.h is not included by Python.h so use void* instead of HANDLE */ +PyAPI_FUNC(void*) _PyOS_SigintEvent(void); +#endif +#endif /* !Py_LIMITED_API */ + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTRCHECK_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/iterobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/iterobject.h new file mode 100644 index 0000000000000000000000000000000000000000..6454611aebef8a6cad8b923354318374e03fe26f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/iterobject.h @@ -0,0 +1,27 @@ +#ifndef Py_ITEROBJECT_H +#define Py_ITEROBJECT_H +/* Iterators (the basic kind, over a sequence) */ +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_DATA(PyTypeObject) PySeqIter_Type; +PyAPI_DATA(PyTypeObject) PyCallIter_Type; +#ifdef Py_BUILD_CORE +extern PyTypeObject _PyAnextAwaitable_Type; +#endif + +#define PySeqIter_Check(op) Py_IS_TYPE(op, &PySeqIter_Type) + +PyAPI_FUNC(PyObject *) PySeqIter_New(PyObject *); + + +#define PyCallIter_Check(op) Py_IS_TYPE(op, &PyCallIter_Type) + +PyAPI_FUNC(PyObject *) PyCallIter_New(PyObject *, PyObject *); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_ITEROBJECT_H */ + diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/listobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/listobject.h new file mode 100644 index 0000000000000000000000000000000000000000..eff42c188f1ff168bbf2dc107460ff797394a463 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/listobject.h @@ -0,0 +1,52 @@ +/* List object interface + + Another generally useful object type is a list of object pointers. + This is a mutable type: the list items can be changed, and items can be + added or removed. Out-of-range indices or non-list objects are ignored. + + WARNING: PyList_SetItem does not increment the new item's reference count, + but does decrement the reference count of the item it replaces, if not nil. + It does *decrement* the reference count if it is *not* inserted in the list. + Similarly, PyList_GetItem does not increment the returned item's reference + count. +*/ + +#ifndef Py_LISTOBJECT_H +#define Py_LISTOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_DATA(PyTypeObject) PyList_Type; +PyAPI_DATA(PyTypeObject) PyListIter_Type; +PyAPI_DATA(PyTypeObject) PyListRevIter_Type; + +#define PyList_Check(op) \ + PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LIST_SUBCLASS) +#define PyList_CheckExact(op) Py_IS_TYPE(op, &PyList_Type) + +PyAPI_FUNC(PyObject *) PyList_New(Py_ssize_t size); +PyAPI_FUNC(Py_ssize_t) PyList_Size(PyObject *); + +PyAPI_FUNC(PyObject *) PyList_GetItem(PyObject *, Py_ssize_t); +PyAPI_FUNC(int) PyList_SetItem(PyObject *, Py_ssize_t, PyObject *); +PyAPI_FUNC(int) PyList_Insert(PyObject *, Py_ssize_t, PyObject *); +PyAPI_FUNC(int) PyList_Append(PyObject *, PyObject *); + +PyAPI_FUNC(PyObject *) PyList_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t); +PyAPI_FUNC(int) PyList_SetSlice(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *); + +PyAPI_FUNC(int) PyList_Sort(PyObject *); +PyAPI_FUNC(int) PyList_Reverse(PyObject *); +PyAPI_FUNC(PyObject *) PyList_AsTuple(PyObject *); + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_LISTOBJECT_H +# include "cpython/listobject.h" +# undef Py_CPYTHON_LISTOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_LISTOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/longobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/longobject.h new file mode 100644 index 0000000000000000000000000000000000000000..778cb6271903757194bf5c59e60493d631650a5c --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/longobject.h @@ -0,0 +1,108 @@ +#ifndef Py_LONGOBJECT_H +#define Py_LONGOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + + +/* Long (arbitrary precision) integer object interface */ + +PyAPI_DATA(PyTypeObject) PyLong_Type; + +#define PyLong_Check(op) \ + PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LONG_SUBCLASS) +#define PyLong_CheckExact(op) Py_IS_TYPE(op, &PyLong_Type) + +PyAPI_FUNC(PyObject *) PyLong_FromLong(long); +PyAPI_FUNC(PyObject *) PyLong_FromUnsignedLong(unsigned long); +PyAPI_FUNC(PyObject *) PyLong_FromSize_t(size_t); +PyAPI_FUNC(PyObject *) PyLong_FromSsize_t(Py_ssize_t); +PyAPI_FUNC(PyObject *) PyLong_FromDouble(double); +PyAPI_FUNC(long) PyLong_AsLong(PyObject *); +PyAPI_FUNC(long) PyLong_AsLongAndOverflow(PyObject *, int *); +PyAPI_FUNC(Py_ssize_t) PyLong_AsSsize_t(PyObject *); +PyAPI_FUNC(size_t) PyLong_AsSize_t(PyObject *); +PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLong(PyObject *); +PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLongMask(PyObject *); +PyAPI_FUNC(PyObject *) PyLong_GetInfo(void); + +/* It may be useful in the future. I've added it in the PyInt -> PyLong + cleanup to keep the extra information. [CH] */ +#define PyLong_AS_LONG(op) PyLong_AsLong(op) + +/* Issue #1983: pid_t can be longer than a C long on some systems */ +#if !defined(SIZEOF_PID_T) || SIZEOF_PID_T == SIZEOF_INT +#define _Py_PARSE_PID "i" +#define PyLong_FromPid PyLong_FromLong +# ifndef Py_LIMITED_API +# define PyLong_AsPid _PyLong_AsInt +# elif SIZEOF_INT == SIZEOF_LONG +# define PyLong_AsPid PyLong_AsLong +# else +static inline int +PyLong_AsPid(PyObject *obj) +{ + int overflow; + long result = PyLong_AsLongAndOverflow(obj, &overflow); + if (overflow || result > INT_MAX || result < INT_MIN) { + PyErr_SetString(PyExc_OverflowError, + "Python int too large to convert to C int"); + return -1; + } + return (int)result; +} +# endif +#elif SIZEOF_PID_T == SIZEOF_LONG +#define _Py_PARSE_PID "l" +#define PyLong_FromPid PyLong_FromLong +#define PyLong_AsPid PyLong_AsLong +#elif defined(SIZEOF_LONG_LONG) && SIZEOF_PID_T == SIZEOF_LONG_LONG +#define _Py_PARSE_PID "L" +#define PyLong_FromPid PyLong_FromLongLong +#define PyLong_AsPid PyLong_AsLongLong +#else +#error "sizeof(pid_t) is neither sizeof(int), sizeof(long) or sizeof(long long)" +#endif /* SIZEOF_PID_T */ + +#if SIZEOF_VOID_P == SIZEOF_INT +# define _Py_PARSE_INTPTR "i" +# define _Py_PARSE_UINTPTR "I" +#elif SIZEOF_VOID_P == SIZEOF_LONG +# define _Py_PARSE_INTPTR "l" +# define _Py_PARSE_UINTPTR "k" +#elif defined(SIZEOF_LONG_LONG) && SIZEOF_VOID_P == SIZEOF_LONG_LONG +# define _Py_PARSE_INTPTR "L" +# define _Py_PARSE_UINTPTR "K" +#else +# error "void* different in size from int, long and long long" +#endif /* SIZEOF_VOID_P */ + +PyAPI_FUNC(double) PyLong_AsDouble(PyObject *); +PyAPI_FUNC(PyObject *) PyLong_FromVoidPtr(void *); +PyAPI_FUNC(void *) PyLong_AsVoidPtr(PyObject *); + +PyAPI_FUNC(PyObject *) PyLong_FromLongLong(long long); +PyAPI_FUNC(PyObject *) PyLong_FromUnsignedLongLong(unsigned long long); +PyAPI_FUNC(long long) PyLong_AsLongLong(PyObject *); +PyAPI_FUNC(unsigned long long) PyLong_AsUnsignedLongLong(PyObject *); +PyAPI_FUNC(unsigned long long) PyLong_AsUnsignedLongLongMask(PyObject *); +PyAPI_FUNC(long long) PyLong_AsLongLongAndOverflow(PyObject *, int *); + +PyAPI_FUNC(PyObject *) PyLong_FromString(const char *, char **, int); + +/* These aren't really part of the int object, but they're handy. The + functions are in Python/mystrtoul.c. + */ +PyAPI_FUNC(unsigned long) PyOS_strtoul(const char *, char **, int); +PyAPI_FUNC(long) PyOS_strtol(const char *, char **, int); + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_LONGOBJECT_H +# include "cpython/longobject.h" +# undef Py_CPYTHON_LONGOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_LONGOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/marshal.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/marshal.h new file mode 100644 index 0000000000000000000000000000000000000000..f8b0de80cfc38df628992918fc1e6cd19cdf4a6b --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/marshal.h @@ -0,0 +1,31 @@ + +/* Interface for marshal.c */ + +#ifndef Py_MARSHAL_H +#define Py_MARSHAL_H +#ifndef Py_LIMITED_API + +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromString(const char *, + Py_ssize_t); +PyAPI_FUNC(PyObject *) PyMarshal_WriteObjectToString(PyObject *, int); + +#define Py_MARSHAL_VERSION 4 + +PyAPI_FUNC(long) PyMarshal_ReadLongFromFile(FILE *); +PyAPI_FUNC(int) PyMarshal_ReadShortFromFile(FILE *); +PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromFile(FILE *); +PyAPI_FUNC(PyObject *) PyMarshal_ReadLastObjectFromFile(FILE *); + +PyAPI_FUNC(void) PyMarshal_WriteLongToFile(long, FILE *, int); +PyAPI_FUNC(void) PyMarshal_WriteObjectToFile(PyObject *, FILE *, int); + +#ifdef __cplusplus +} +#endif + +#endif /* Py_LIMITED_API */ +#endif /* !Py_MARSHAL_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/memoryobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/memoryobject.h new file mode 100644 index 0000000000000000000000000000000000000000..154397ce1e56d2a9e3acbce880a2063ba64f1191 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/memoryobject.h @@ -0,0 +1,72 @@ +/* Memory view object. In Python this is available as "memoryview". */ + +#ifndef Py_MEMORYOBJECT_H +#define Py_MEMORYOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_LIMITED_API +PyAPI_DATA(PyTypeObject) _PyManagedBuffer_Type; +#endif +PyAPI_DATA(PyTypeObject) PyMemoryView_Type; + +#define PyMemoryView_Check(op) Py_IS_TYPE(op, &PyMemoryView_Type) + +#ifndef Py_LIMITED_API +/* Get a pointer to the memoryview's private copy of the exporter's buffer. */ +#define PyMemoryView_GET_BUFFER(op) (&((PyMemoryViewObject *)(op))->view) +/* Get a pointer to the exporting object (this may be NULL!). */ +#define PyMemoryView_GET_BASE(op) (((PyMemoryViewObject *)(op))->view.obj) +#endif + +PyAPI_FUNC(PyObject *) PyMemoryView_FromObject(PyObject *base); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 +PyAPI_FUNC(PyObject *) PyMemoryView_FromMemory(char *mem, Py_ssize_t size, + int flags); +#endif +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030b0000 +PyAPI_FUNC(PyObject *) PyMemoryView_FromBuffer(const Py_buffer *info); +#endif +PyAPI_FUNC(PyObject *) PyMemoryView_GetContiguous(PyObject *base, + int buffertype, + char order); + + +/* The structs are declared here so that macros can work, but they shouldn't + be considered public. Don't access their fields directly, use the macros + and functions instead! */ +#ifndef Py_LIMITED_API +#define _Py_MANAGED_BUFFER_RELEASED 0x001 /* access to exporter blocked */ +#define _Py_MANAGED_BUFFER_FREE_FORMAT 0x002 /* free format */ +typedef struct { + PyObject_HEAD + int flags; /* state flags */ + Py_ssize_t exports; /* number of direct memoryview exports */ + Py_buffer master; /* snapshot buffer obtained from the original exporter */ +} _PyManagedBufferObject; + + +/* memoryview state flags */ +#define _Py_MEMORYVIEW_RELEASED 0x001 /* access to master buffer blocked */ +#define _Py_MEMORYVIEW_C 0x002 /* C-contiguous layout */ +#define _Py_MEMORYVIEW_FORTRAN 0x004 /* Fortran contiguous layout */ +#define _Py_MEMORYVIEW_SCALAR 0x008 /* scalar: ndim = 0 */ +#define _Py_MEMORYVIEW_PIL 0x010 /* PIL-style layout */ + +typedef struct { + PyObject_VAR_HEAD + _PyManagedBufferObject *mbuf; /* managed buffer */ + Py_hash_t hash; /* hash value for read-only views */ + int flags; /* state flags */ + Py_ssize_t exports; /* number of buffer re-exports */ + Py_buffer view; /* private copy of the exporter's view */ + PyObject *weakreflist; + Py_ssize_t ob_array[1]; /* shape, strides, suboffsets */ +} PyMemoryViewObject; +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_MEMORYOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/methodobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/methodobject.h new file mode 100644 index 0000000000000000000000000000000000000000..c971d78a640a688596bc072f1fd6147998e65973 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/methodobject.h @@ -0,0 +1,132 @@ + +/* Method object interface */ + +#ifndef Py_METHODOBJECT_H +#define Py_METHODOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +/* This is about the type 'builtin_function_or_method', + not Python methods in user-defined classes. See classobject.h + for the latter. */ + +PyAPI_DATA(PyTypeObject) PyCFunction_Type; + +#define PyCFunction_CheckExact(op) Py_IS_TYPE(op, &PyCFunction_Type) +#define PyCFunction_Check(op) PyObject_TypeCheck(op, &PyCFunction_Type) + +typedef PyObject *(*PyCFunction)(PyObject *, PyObject *); +typedef PyObject *(*_PyCFunctionFast) (PyObject *, PyObject *const *, Py_ssize_t); +typedef PyObject *(*PyCFunctionWithKeywords)(PyObject *, PyObject *, + PyObject *); +typedef PyObject *(*_PyCFunctionFastWithKeywords) (PyObject *, + PyObject *const *, Py_ssize_t, + PyObject *); +typedef PyObject *(*PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, + size_t, PyObject *); + +// Cast an function to the PyCFunction type to use it with PyMethodDef. +// +// This macro can be used to prevent compiler warnings if the first parameter +// uses a different pointer type than PyObject* (ex: METH_VARARGS and METH_O +// calling conventions). +// +// The macro can also be used for METH_FASTCALL and METH_VARARGS|METH_KEYWORDS +// calling conventions to avoid compiler warnings because the function has more +// than 2 parameters. The macro first casts the function to the +// "void func(void)" type to prevent compiler warnings. +// +// If a function is declared with the METH_NOARGS calling convention, it must +// have 2 parameters. Since the second parameter is unused, Py_UNUSED() can be +// used to prevent a compiler warning. If the function has a single parameter, +// it triggers an undefined behavior when Python calls it with 2 parameters +// (bpo-33012). +#define _PyCFunction_CAST(func) \ + _Py_CAST(PyCFunction, _Py_CAST(void(*)(void), (func))) + +PyAPI_FUNC(PyCFunction) PyCFunction_GetFunction(PyObject *); +PyAPI_FUNC(PyObject *) PyCFunction_GetSelf(PyObject *); +PyAPI_FUNC(int) PyCFunction_GetFlags(PyObject *); + +Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyCFunction_Call(PyObject *, PyObject *, PyObject *); + +struct PyMethodDef { + const char *ml_name; /* The name of the built-in function/method */ + PyCFunction ml_meth; /* The C function that implements it */ + int ml_flags; /* Combination of METH_xxx flags, which mostly + describe the args expected by the C func */ + const char *ml_doc; /* The __doc__ attribute, or NULL */ +}; + +/* PyCFunction_New is declared as a function for stable ABI (declaration is + * needed for e.g. GCC with -fvisibility=hidden), but redefined as a macro + * that calls PyCFunction_NewEx. */ +PyAPI_FUNC(PyObject *) PyCFunction_New(PyMethodDef *, PyObject *); +#define PyCFunction_New(ML, SELF) PyCFunction_NewEx((ML), (SELF), NULL) + +/* PyCFunction_NewEx is similar: on 3.9+, this calls PyCMethod_New. */ +PyAPI_FUNC(PyObject *) PyCFunction_NewEx(PyMethodDef *, PyObject *, + PyObject *); + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 +#define PyCFunction_NewEx(ML, SELF, MOD) PyCMethod_New((ML), (SELF), (MOD), NULL) +PyAPI_FUNC(PyObject *) PyCMethod_New(PyMethodDef *, PyObject *, + PyObject *, PyTypeObject *); +#endif + + +/* Flag passed to newmethodobject */ +/* #define METH_OLDARGS 0x0000 -- unsupported now */ +#define METH_VARARGS 0x0001 +#define METH_KEYWORDS 0x0002 +/* METH_NOARGS and METH_O must not be combined with the flags above. */ +#define METH_NOARGS 0x0004 +#define METH_O 0x0008 + +/* METH_CLASS and METH_STATIC are a little different; these control + the construction of methods for a class. These cannot be used for + functions in modules. */ +#define METH_CLASS 0x0010 +#define METH_STATIC 0x0020 + +/* METH_COEXIST allows a method to be entered even though a slot has + already filled the entry. When defined, the flag allows a separate + method, "__contains__" for example, to coexist with a defined + slot like sq_contains. */ + +#define METH_COEXIST 0x0040 + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030a0000 +# define METH_FASTCALL 0x0080 +#endif + +/* This bit is preserved for Stackless Python */ +#ifdef STACKLESS +# define METH_STACKLESS 0x0100 +#else +# define METH_STACKLESS 0x0000 +#endif + +/* METH_METHOD means the function stores an + * additional reference to the class that defines it; + * both self and class are passed to it. + * It uses PyCMethodObject instead of PyCFunctionObject. + * May not be combined with METH_NOARGS, METH_O, METH_CLASS or METH_STATIC. + */ + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 +#define METH_METHOD 0x0200 +#endif + + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_METHODOBJECT_H +# include "cpython/methodobject.h" +# undef Py_CPYTHON_METHODOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_METHODOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/modsupport.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/modsupport.h new file mode 100644 index 0000000000000000000000000000000000000000..b3813a7e31935726970442e9e3b310c46b125408 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/modsupport.h @@ -0,0 +1,170 @@ + +#ifndef Py_MODSUPPORT_H +#define Py_MODSUPPORT_H +#ifdef __cplusplus +extern "C" { +#endif + +/* Module support interface */ + +#include // va_list + +/* If PY_SSIZE_T_CLEAN is defined, each functions treats #-specifier + to mean Py_ssize_t */ +#ifdef PY_SSIZE_T_CLEAN +#define PyArg_Parse _PyArg_Parse_SizeT +#define PyArg_ParseTuple _PyArg_ParseTuple_SizeT +#define PyArg_ParseTupleAndKeywords _PyArg_ParseTupleAndKeywords_SizeT +#define PyArg_VaParse _PyArg_VaParse_SizeT +#define PyArg_VaParseTupleAndKeywords _PyArg_VaParseTupleAndKeywords_SizeT +#define Py_BuildValue _Py_BuildValue_SizeT +#define Py_VaBuildValue _Py_VaBuildValue_SizeT +#endif + +/* Due to a glitch in 3.2, the _SizeT versions weren't exported from the DLL. */ +#if !defined(PY_SSIZE_T_CLEAN) || !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 +PyAPI_FUNC(int) PyArg_Parse(PyObject *, const char *, ...); +PyAPI_FUNC(int) PyArg_ParseTuple(PyObject *, const char *, ...); +PyAPI_FUNC(int) PyArg_ParseTupleAndKeywords(PyObject *, PyObject *, + const char *, char **, ...); +PyAPI_FUNC(int) PyArg_VaParse(PyObject *, const char *, va_list); +PyAPI_FUNC(int) PyArg_VaParseTupleAndKeywords(PyObject *, PyObject *, + const char *, char **, va_list); +#endif +PyAPI_FUNC(int) PyArg_ValidateKeywordArguments(PyObject *); +PyAPI_FUNC(int) PyArg_UnpackTuple(PyObject *, const char *, Py_ssize_t, Py_ssize_t, ...); +PyAPI_FUNC(PyObject *) Py_BuildValue(const char *, ...); +PyAPI_FUNC(PyObject *) _Py_BuildValue_SizeT(const char *, ...); + + +#define ANY_VARARGS(n) (n == PY_SSIZE_T_MAX) + +PyAPI_FUNC(PyObject *) Py_VaBuildValue(const char *, va_list); + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030a0000 +// Add an attribute with name 'name' and value 'obj' to the module 'mod. +// On success, return 0 on success. +// On error, raise an exception and return -1. +PyAPI_FUNC(int) PyModule_AddObjectRef(PyObject *mod, const char *name, PyObject *value); +#endif /* Py_LIMITED_API */ + +// Similar to PyModule_AddObjectRef() but steal a reference to 'obj' +// (Py_DECREF(obj)) on success (if it returns 0). +PyAPI_FUNC(int) PyModule_AddObject(PyObject *mod, const char *, PyObject *value); + +PyAPI_FUNC(int) PyModule_AddIntConstant(PyObject *, const char *, long); +PyAPI_FUNC(int) PyModule_AddStringConstant(PyObject *, const char *, const char *); + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 +/* New in 3.9 */ +PyAPI_FUNC(int) PyModule_AddType(PyObject *module, PyTypeObject *type); +#endif /* Py_LIMITED_API */ + +#define PyModule_AddIntMacro(m, c) PyModule_AddIntConstant(m, #c, c) +#define PyModule_AddStringMacro(m, c) PyModule_AddStringConstant(m, #c, c) + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 +/* New in 3.5 */ +PyAPI_FUNC(int) PyModule_SetDocString(PyObject *, const char *); +PyAPI_FUNC(int) PyModule_AddFunctions(PyObject *, PyMethodDef *); +PyAPI_FUNC(int) PyModule_ExecDef(PyObject *module, PyModuleDef *def); +#endif + +#define Py_CLEANUP_SUPPORTED 0x20000 + +#define PYTHON_API_VERSION 1013 +#define PYTHON_API_STRING "1013" +/* The API version is maintained (independently from the Python version) + so we can detect mismatches between the interpreter and dynamically + loaded modules. These are diagnosed by an error message but + the module is still loaded (because the mismatch can only be tested + after loading the module). The error message is intended to + explain the core dump a few seconds later. + + The symbol PYTHON_API_STRING defines the same value as a string + literal. *** PLEASE MAKE SURE THE DEFINITIONS MATCH. *** + + Please add a line or two to the top of this log for each API + version change: + + 22-Feb-2006 MvL 1013 PEP 353 - long indices for sequence lengths + + 19-Aug-2002 GvR 1012 Changes to string object struct for + interning changes, saving 3 bytes. + + 17-Jul-2001 GvR 1011 Descr-branch, just to be on the safe side + + 25-Jan-2001 FLD 1010 Parameters added to PyCode_New() and + PyFrame_New(); Python 2.1a2 + + 14-Mar-2000 GvR 1009 Unicode API added + + 3-Jan-1999 GvR 1007 Decided to change back! (Don't reuse 1008!) + + 3-Dec-1998 GvR 1008 Python 1.5.2b1 + + 18-Jan-1997 GvR 1007 string interning and other speedups + + 11-Oct-1996 GvR renamed Py_Ellipses to Py_Ellipsis :-( + + 30-Jul-1996 GvR Slice and ellipses syntax added + + 23-Jul-1996 GvR For 1.4 -- better safe than sorry this time :-) + + 7-Nov-1995 GvR Keyword arguments (should've been done at 1.3 :-( ) + + 10-Jan-1995 GvR Renamed globals to new naming scheme + + 9-Jan-1995 GvR Initial version (incompatible with older API) +*/ + +/* The PYTHON_ABI_VERSION is introduced in PEP 384. For the lifetime of + Python 3, it will stay at the value of 3; changes to the limited API + must be performed in a strictly backwards-compatible manner. */ +#define PYTHON_ABI_VERSION 3 +#define PYTHON_ABI_STRING "3" + +#ifdef Py_TRACE_REFS + /* When we are tracing reference counts, rename module creation functions so + modules compiled with incompatible settings will generate a + link-time error. */ + #define PyModule_Create2 PyModule_Create2TraceRefs + #define PyModule_FromDefAndSpec2 PyModule_FromDefAndSpec2TraceRefs +#endif + +PyAPI_FUNC(PyObject *) PyModule_Create2(PyModuleDef*, int apiver); + +#ifdef Py_LIMITED_API +#define PyModule_Create(module) \ + PyModule_Create2(module, PYTHON_ABI_VERSION) +#else +#define PyModule_Create(module) \ + PyModule_Create2(module, PYTHON_API_VERSION) +#endif + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 +/* New in 3.5 */ +PyAPI_FUNC(PyObject *) PyModule_FromDefAndSpec2(PyModuleDef *def, + PyObject *spec, + int module_api_version); + +#ifdef Py_LIMITED_API +#define PyModule_FromDefAndSpec(module, spec) \ + PyModule_FromDefAndSpec2(module, spec, PYTHON_ABI_VERSION) +#else +#define PyModule_FromDefAndSpec(module, spec) \ + PyModule_FromDefAndSpec2(module, spec, PYTHON_API_VERSION) +#endif /* Py_LIMITED_API */ + +#endif /* New in 3.5 */ + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_MODSUPPORT_H +# include "cpython/modsupport.h" +# undef Py_CPYTHON_MODSUPPORT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_MODSUPPORT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/moduleobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/moduleobject.h new file mode 100644 index 0000000000000000000000000000000000000000..75abd2cf2b90508433660f97e325460c3de2897f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/moduleobject.h @@ -0,0 +1,95 @@ + +/* Module object interface */ + +#ifndef Py_MODULEOBJECT_H +#define Py_MODULEOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_DATA(PyTypeObject) PyModule_Type; + +#define PyModule_Check(op) PyObject_TypeCheck(op, &PyModule_Type) +#define PyModule_CheckExact(op) Py_IS_TYPE(op, &PyModule_Type) + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 +PyAPI_FUNC(PyObject *) PyModule_NewObject( + PyObject *name + ); +#endif +PyAPI_FUNC(PyObject *) PyModule_New( + const char *name /* UTF-8 encoded string */ + ); +PyAPI_FUNC(PyObject *) PyModule_GetDict(PyObject *); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 +PyAPI_FUNC(PyObject *) PyModule_GetNameObject(PyObject *); +#endif +PyAPI_FUNC(const char *) PyModule_GetName(PyObject *); +Py_DEPRECATED(3.2) PyAPI_FUNC(const char *) PyModule_GetFilename(PyObject *); +PyAPI_FUNC(PyObject *) PyModule_GetFilenameObject(PyObject *); +#ifndef Py_LIMITED_API +PyAPI_FUNC(void) _PyModule_Clear(PyObject *); +PyAPI_FUNC(void) _PyModule_ClearDict(PyObject *); +PyAPI_FUNC(int) _PyModuleSpec_IsInitializing(PyObject *); +#endif +PyAPI_FUNC(PyModuleDef*) PyModule_GetDef(PyObject*); +PyAPI_FUNC(void*) PyModule_GetState(PyObject*); + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 +/* New in 3.5 */ +PyAPI_FUNC(PyObject *) PyModuleDef_Init(PyModuleDef*); +PyAPI_DATA(PyTypeObject) PyModuleDef_Type; +#endif + +typedef struct PyModuleDef_Base { + PyObject_HEAD + PyObject* (*m_init)(void); + Py_ssize_t m_index; + PyObject* m_copy; +} PyModuleDef_Base; + +#define PyModuleDef_HEAD_INIT { \ + PyObject_HEAD_INIT(_Py_NULL) \ + _Py_NULL, /* m_init */ \ + 0, /* m_index */ \ + _Py_NULL, /* m_copy */ \ + } + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 +/* New in 3.5 */ +struct PyModuleDef_Slot { + int slot; + void *value; +}; + +#define Py_mod_create 1 +#define Py_mod_exec 2 + +#ifndef Py_LIMITED_API +#define _Py_mod_LAST_SLOT 2 +#endif + +#endif /* New in 3.5 */ + +struct PyModuleDef { + PyModuleDef_Base m_base; + const char* m_name; + const char* m_doc; + Py_ssize_t m_size; + PyMethodDef *m_methods; + PyModuleDef_Slot *m_slots; + traverseproc m_traverse; + inquiry m_clear; + freefunc m_free; +}; + + +// Internal C API +#ifdef Py_BUILD_CORE +extern int _PyModule_IsExtension(PyObject *obj); +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_MODULEOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/object.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/object.h new file mode 100644 index 0000000000000000000000000000000000000000..f2af428e2bb9730e4dd0e610d21b44c7610d3d2f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/object.h @@ -0,0 +1,797 @@ +#ifndef Py_OBJECT_H +#define Py_OBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + + +/* Object and type object interface */ + +/* +Objects are structures allocated on the heap. Special rules apply to +the use of objects to ensure they are properly garbage-collected. +Objects are never allocated statically or on the stack; they must be +accessed through special macros and functions only. (Type objects are +exceptions to the first rule; the standard types are represented by +statically initialized type objects, although work on type/class unification +for Python 2.2 made it possible to have heap-allocated type objects too). + +An object has a 'reference count' that is increased or decreased when a +pointer to the object is copied or deleted; when the reference count +reaches zero there are no references to the object left and it can be +removed from the heap. + +An object has a 'type' that determines what it represents and what kind +of data it contains. An object's type is fixed when it is created. +Types themselves are represented as objects; an object contains a +pointer to the corresponding type object. The type itself has a type +pointer pointing to the object representing the type 'type', which +contains a pointer to itself!. + +Objects do not float around in memory; once allocated an object keeps +the same size and address. Objects that must hold variable-size data +can contain pointers to variable-size parts of the object. Not all +objects of the same type have the same size; but the size cannot change +after allocation. (These restrictions are made so a reference to an +object can be simply a pointer -- moving an object would require +updating all the pointers, and changing an object's size would require +moving it if there was another object right next to it.) + +Objects are always accessed through pointers of the type 'PyObject *'. +The type 'PyObject' is a structure that only contains the reference count +and the type pointer. The actual memory allocated for an object +contains other data that can only be accessed after casting the pointer +to a pointer to a longer structure type. This longer type must start +with the reference count and type fields; the macro PyObject_HEAD should be +used for this (to accommodate for future changes). The implementation +of a particular object type can cast the object pointer to the proper +type and back. + +A standard interface exists for objects that contain an array of items +whose size is determined when the object is allocated. +*/ + +/* Py_DEBUG implies Py_REF_DEBUG. */ +#if defined(Py_DEBUG) && !defined(Py_REF_DEBUG) +# define Py_REF_DEBUG +#endif + +#if defined(Py_LIMITED_API) && defined(Py_TRACE_REFS) +# error Py_LIMITED_API is incompatible with Py_TRACE_REFS +#endif + +#ifdef Py_TRACE_REFS +/* Define pointers to support a doubly-linked list of all live heap objects. */ +#define _PyObject_HEAD_EXTRA \ + PyObject *_ob_next; \ + PyObject *_ob_prev; + +#define _PyObject_EXTRA_INIT _Py_NULL, _Py_NULL, + +#else +# define _PyObject_HEAD_EXTRA +# define _PyObject_EXTRA_INIT +#endif + +/* PyObject_HEAD defines the initial segment of every PyObject. */ +#define PyObject_HEAD PyObject ob_base; + +#define PyObject_HEAD_INIT(type) \ + { _PyObject_EXTRA_INIT \ + 1, type }, + +#define PyVarObject_HEAD_INIT(type, size) \ + { PyObject_HEAD_INIT(type) size }, + +/* PyObject_VAR_HEAD defines the initial segment of all variable-size + * container objects. These end with a declaration of an array with 1 + * element, but enough space is malloc'ed so that the array actually + * has room for ob_size elements. Note that ob_size is an element count, + * not necessarily a byte count. + */ +#define PyObject_VAR_HEAD PyVarObject ob_base; +#define Py_INVALID_SIZE (Py_ssize_t)-1 + +/* Nothing is actually declared to be a PyObject, but every pointer to + * a Python object can be cast to a PyObject*. This is inheritance built + * by hand. Similarly every pointer to a variable-size Python object can, + * in addition, be cast to PyVarObject*. + */ +struct _object { + _PyObject_HEAD_EXTRA + Py_ssize_t ob_refcnt; + PyTypeObject *ob_type; +}; + +/* Cast argument to PyObject* type. */ +#define _PyObject_CAST(op) _Py_CAST(PyObject*, (op)) + +typedef struct { + PyObject ob_base; + Py_ssize_t ob_size; /* Number of items in variable part */ +} PyVarObject; + +/* Cast argument to PyVarObject* type. */ +#define _PyVarObject_CAST(op) _Py_CAST(PyVarObject*, (op)) + + +// Test if the 'x' object is the 'y' object, the same as "x is y" in Python. +PyAPI_FUNC(int) Py_Is(PyObject *x, PyObject *y); +#define Py_Is(x, y) ((x) == (y)) + + +static inline Py_ssize_t Py_REFCNT(PyObject *ob) { + return ob->ob_refcnt; +} +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000 +# define Py_REFCNT(ob) Py_REFCNT(_PyObject_CAST(ob)) +#endif + + +// bpo-39573: The Py_SET_TYPE() function must be used to set an object type. +static inline PyTypeObject* Py_TYPE(PyObject *ob) { + return ob->ob_type; +} +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000 +# define Py_TYPE(ob) Py_TYPE(_PyObject_CAST(ob)) +#endif + +// bpo-39573: The Py_SET_SIZE() function must be used to set an object size. +static inline Py_ssize_t Py_SIZE(PyObject *ob) { + PyVarObject *var_ob = _PyVarObject_CAST(ob); + return var_ob->ob_size; +} +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000 +# define Py_SIZE(ob) Py_SIZE(_PyObject_CAST(ob)) +#endif + + +static inline int Py_IS_TYPE(PyObject *ob, PyTypeObject *type) { + return Py_TYPE(ob) == type; +} +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000 +# define Py_IS_TYPE(ob, type) Py_IS_TYPE(_PyObject_CAST(ob), type) +#endif + + +static inline void Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt) { + ob->ob_refcnt = refcnt; +} +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000 +# define Py_SET_REFCNT(ob, refcnt) Py_SET_REFCNT(_PyObject_CAST(ob), refcnt) +#endif + + +static inline void Py_SET_TYPE(PyObject *ob, PyTypeObject *type) { + ob->ob_type = type; +} +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000 +# define Py_SET_TYPE(ob, type) Py_SET_TYPE(_PyObject_CAST(ob), type) +#endif + + +static inline void Py_SET_SIZE(PyVarObject *ob, Py_ssize_t size) { + ob->ob_size = size; +} +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000 +# define Py_SET_SIZE(ob, size) Py_SET_SIZE(_PyVarObject_CAST(ob), size) +#endif + + +/* +Type objects contain a string containing the type name (to help somewhat +in debugging), the allocation parameters (see PyObject_New() and +PyObject_NewVar()), +and methods for accessing objects of the type. Methods are optional, a +nil pointer meaning that particular kind of access is not available for +this type. The Py_DECREF() macro uses the tp_dealloc method without +checking for a nil pointer; it should always be implemented except if +the implementation can guarantee that the reference count will never +reach zero (e.g., for statically allocated type objects). + +NB: the methods for certain type groups are now contained in separate +method blocks. +*/ + +typedef PyObject * (*unaryfunc)(PyObject *); +typedef PyObject * (*binaryfunc)(PyObject *, PyObject *); +typedef PyObject * (*ternaryfunc)(PyObject *, PyObject *, PyObject *); +typedef int (*inquiry)(PyObject *); +typedef Py_ssize_t (*lenfunc)(PyObject *); +typedef PyObject *(*ssizeargfunc)(PyObject *, Py_ssize_t); +typedef PyObject *(*ssizessizeargfunc)(PyObject *, Py_ssize_t, Py_ssize_t); +typedef int(*ssizeobjargproc)(PyObject *, Py_ssize_t, PyObject *); +typedef int(*ssizessizeobjargproc)(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *); +typedef int(*objobjargproc)(PyObject *, PyObject *, PyObject *); + +typedef int (*objobjproc)(PyObject *, PyObject *); +typedef int (*visitproc)(PyObject *, void *); +typedef int (*traverseproc)(PyObject *, visitproc, void *); + + +typedef void (*freefunc)(void *); +typedef void (*destructor)(PyObject *); +typedef PyObject *(*getattrfunc)(PyObject *, char *); +typedef PyObject *(*getattrofunc)(PyObject *, PyObject *); +typedef int (*setattrfunc)(PyObject *, char *, PyObject *); +typedef int (*setattrofunc)(PyObject *, PyObject *, PyObject *); +typedef PyObject *(*reprfunc)(PyObject *); +typedef Py_hash_t (*hashfunc)(PyObject *); +typedef PyObject *(*richcmpfunc) (PyObject *, PyObject *, int); +typedef PyObject *(*getiterfunc) (PyObject *); +typedef PyObject *(*iternextfunc) (PyObject *); +typedef PyObject *(*descrgetfunc) (PyObject *, PyObject *, PyObject *); +typedef int (*descrsetfunc) (PyObject *, PyObject *, PyObject *); +typedef int (*initproc)(PyObject *, PyObject *, PyObject *); +typedef PyObject *(*newfunc)(PyTypeObject *, PyObject *, PyObject *); +typedef PyObject *(*allocfunc)(PyTypeObject *, Py_ssize_t); + +typedef struct{ + int slot; /* slot id, see below */ + void *pfunc; /* function pointer */ +} PyType_Slot; + +typedef struct{ + const char* name; + int basicsize; + int itemsize; + unsigned int flags; + PyType_Slot *slots; /* terminated by slot==0. */ +} PyType_Spec; + +PyAPI_FUNC(PyObject*) PyType_FromSpec(PyType_Spec*); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 +PyAPI_FUNC(PyObject*) PyType_FromSpecWithBases(PyType_Spec*, PyObject*); +#endif +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000 +PyAPI_FUNC(void*) PyType_GetSlot(PyTypeObject*, int); +#endif +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 +PyAPI_FUNC(PyObject*) PyType_FromModuleAndSpec(PyObject *, PyType_Spec *, PyObject *); +PyAPI_FUNC(PyObject *) PyType_GetModule(PyTypeObject *); +PyAPI_FUNC(void *) PyType_GetModuleState(PyTypeObject *); +#endif +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030B0000 +PyAPI_FUNC(PyObject *) PyType_GetName(PyTypeObject *); +PyAPI_FUNC(PyObject *) PyType_GetQualName(PyTypeObject *); +#endif + +/* Generic type check */ +PyAPI_FUNC(int) PyType_IsSubtype(PyTypeObject *, PyTypeObject *); + +static inline int PyObject_TypeCheck(PyObject *ob, PyTypeObject *type) { + return Py_IS_TYPE(ob, type) || PyType_IsSubtype(Py_TYPE(ob), type); +} +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000 +# define PyObject_TypeCheck(ob, type) PyObject_TypeCheck(_PyObject_CAST(ob), type) +#endif + +PyAPI_DATA(PyTypeObject) PyType_Type; /* built-in 'type' */ +PyAPI_DATA(PyTypeObject) PyBaseObject_Type; /* built-in 'object' */ +PyAPI_DATA(PyTypeObject) PySuper_Type; /* built-in 'super' */ + +PyAPI_FUNC(unsigned long) PyType_GetFlags(PyTypeObject*); + +PyAPI_FUNC(int) PyType_Ready(PyTypeObject *); +PyAPI_FUNC(PyObject *) PyType_GenericAlloc(PyTypeObject *, Py_ssize_t); +PyAPI_FUNC(PyObject *) PyType_GenericNew(PyTypeObject *, + PyObject *, PyObject *); +PyAPI_FUNC(unsigned int) PyType_ClearCache(void); +PyAPI_FUNC(void) PyType_Modified(PyTypeObject *); + +/* Generic operations on objects */ +PyAPI_FUNC(PyObject *) PyObject_Repr(PyObject *); +PyAPI_FUNC(PyObject *) PyObject_Str(PyObject *); +PyAPI_FUNC(PyObject *) PyObject_ASCII(PyObject *); +PyAPI_FUNC(PyObject *) PyObject_Bytes(PyObject *); +PyAPI_FUNC(PyObject *) PyObject_RichCompare(PyObject *, PyObject *, int); +PyAPI_FUNC(int) PyObject_RichCompareBool(PyObject *, PyObject *, int); +PyAPI_FUNC(PyObject *) PyObject_GetAttrString(PyObject *, const char *); +PyAPI_FUNC(int) PyObject_SetAttrString(PyObject *, const char *, PyObject *); +PyAPI_FUNC(int) PyObject_HasAttrString(PyObject *, const char *); +PyAPI_FUNC(PyObject *) PyObject_GetAttr(PyObject *, PyObject *); +PyAPI_FUNC(int) PyObject_SetAttr(PyObject *, PyObject *, PyObject *); +PyAPI_FUNC(int) PyObject_HasAttr(PyObject *, PyObject *); +PyAPI_FUNC(PyObject *) PyObject_SelfIter(PyObject *); +PyAPI_FUNC(PyObject *) PyObject_GenericGetAttr(PyObject *, PyObject *); +PyAPI_FUNC(int) PyObject_GenericSetAttr(PyObject *, PyObject *, PyObject *); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 +PyAPI_FUNC(int) PyObject_GenericSetDict(PyObject *, PyObject *, void *); +#endif +PyAPI_FUNC(Py_hash_t) PyObject_Hash(PyObject *); +PyAPI_FUNC(Py_hash_t) PyObject_HashNotImplemented(PyObject *); +PyAPI_FUNC(int) PyObject_IsTrue(PyObject *); +PyAPI_FUNC(int) PyObject_Not(PyObject *); +PyAPI_FUNC(int) PyCallable_Check(PyObject *); +PyAPI_FUNC(void) PyObject_ClearWeakRefs(PyObject *); + +/* PyObject_Dir(obj) acts like Python builtins.dir(obj), returning a + list of strings. PyObject_Dir(NULL) is like builtins.dir(), + returning the names of the current locals. In this case, if there are + no current locals, NULL is returned, and PyErr_Occurred() is false. +*/ +PyAPI_FUNC(PyObject *) PyObject_Dir(PyObject *); + +/* Pickle support. */ +#ifndef Py_LIMITED_API +PyAPI_FUNC(PyObject *) _PyObject_GetState(PyObject *); +#endif + + +/* Helpers for printing recursive container types */ +PyAPI_FUNC(int) Py_ReprEnter(PyObject *); +PyAPI_FUNC(void) Py_ReprLeave(PyObject *); + +/* Flag bits for printing: */ +#define Py_PRINT_RAW 1 /* No string quotes etc. */ + +/* +Type flags (tp_flags) + +These flags are used to change expected features and behavior for a +particular type. + +Arbitration of the flag bit positions will need to be coordinated among +all extension writers who publicly release their extensions (this will +be fewer than you might expect!). + +Most flags were removed as of Python 3.0 to make room for new flags. (Some +flags are not for backwards compatibility but to indicate the presence of an +optional feature; these flags remain of course.) + +Type definitions should use Py_TPFLAGS_DEFAULT for their tp_flags value. + +Code can use PyType_HasFeature(type_ob, flag_value) to test whether the +given type object has a specified feature. +*/ + +#ifndef Py_LIMITED_API + +/* Placement of dict (and values) pointers are managed by the VM, not by the type. + * The VM will automatically set tp_dictoffset. Should not be used for variable sized + * classes, such as classes that extend tuple. + */ +#define Py_TPFLAGS_MANAGED_DICT (1 << 4) + +/* Set if instances of the type object are treated as sequences for pattern matching */ +#define Py_TPFLAGS_SEQUENCE (1 << 5) +/* Set if instances of the type object are treated as mappings for pattern matching */ +#define Py_TPFLAGS_MAPPING (1 << 6) +#endif + +/* Disallow creating instances of the type: set tp_new to NULL and don't create + * the "__new__" key in the type dictionary. */ +#define Py_TPFLAGS_DISALLOW_INSTANTIATION (1UL << 7) + +/* Set if the type object is immutable: type attributes cannot be set nor deleted */ +#define Py_TPFLAGS_IMMUTABLETYPE (1UL << 8) + +/* Set if the type object is dynamically allocated */ +#define Py_TPFLAGS_HEAPTYPE (1UL << 9) + +/* Set if the type allows subclassing */ +#define Py_TPFLAGS_BASETYPE (1UL << 10) + +/* Set if the type implements the vectorcall protocol (PEP 590) */ +#ifndef Py_LIMITED_API +#define Py_TPFLAGS_HAVE_VECTORCALL (1UL << 11) +// Backwards compatibility alias for API that was provisional in Python 3.8 +#define _Py_TPFLAGS_HAVE_VECTORCALL Py_TPFLAGS_HAVE_VECTORCALL +#endif + +/* Set if the type is 'ready' -- fully initialized */ +#define Py_TPFLAGS_READY (1UL << 12) + +/* Set while the type is being 'readied', to prevent recursive ready calls */ +#define Py_TPFLAGS_READYING (1UL << 13) + +/* Objects support garbage collection (see objimpl.h) */ +#define Py_TPFLAGS_HAVE_GC (1UL << 14) + +/* These two bits are preserved for Stackless Python, next after this is 17 */ +#ifdef STACKLESS +#define Py_TPFLAGS_HAVE_STACKLESS_EXTENSION (3UL << 15) +#else +#define Py_TPFLAGS_HAVE_STACKLESS_EXTENSION 0 +#endif + +/* Objects behave like an unbound method */ +#define Py_TPFLAGS_METHOD_DESCRIPTOR (1UL << 17) + +/* Object has up-to-date type attribute cache */ +#define Py_TPFLAGS_VALID_VERSION_TAG (1UL << 19) + +/* Type is abstract and cannot be instantiated */ +#define Py_TPFLAGS_IS_ABSTRACT (1UL << 20) + +// This undocumented flag gives certain built-ins their unique pattern-matching +// behavior, which allows a single positional subpattern to match against the +// subject itself (rather than a mapped attribute on it): +#define _Py_TPFLAGS_MATCH_SELF (1UL << 22) + +/* These flags are used to determine if a type is a subclass. */ +#define Py_TPFLAGS_LONG_SUBCLASS (1UL << 24) +#define Py_TPFLAGS_LIST_SUBCLASS (1UL << 25) +#define Py_TPFLAGS_TUPLE_SUBCLASS (1UL << 26) +#define Py_TPFLAGS_BYTES_SUBCLASS (1UL << 27) +#define Py_TPFLAGS_UNICODE_SUBCLASS (1UL << 28) +#define Py_TPFLAGS_DICT_SUBCLASS (1UL << 29) +#define Py_TPFLAGS_BASE_EXC_SUBCLASS (1UL << 30) +#define Py_TPFLAGS_TYPE_SUBCLASS (1UL << 31) + +#define Py_TPFLAGS_DEFAULT ( \ + Py_TPFLAGS_HAVE_STACKLESS_EXTENSION | \ + 0) + +/* NOTE: Some of the following flags reuse lower bits (removed as part of the + * Python 3.0 transition). */ + +/* The following flags are kept for compatibility; in previous + * versions they indicated presence of newer tp_* fields on the + * type struct. + * Starting with 3.8, binary compatibility of C extensions across + * feature releases of Python is not supported anymore (except when + * using the stable ABI, in which all classes are created dynamically, + * using the interpreter's memory layout.) + * Note that older extensions using the stable ABI set these flags, + * so the bits must not be repurposed. + */ +#define Py_TPFLAGS_HAVE_FINALIZE (1UL << 0) +#define Py_TPFLAGS_HAVE_VERSION_TAG (1UL << 18) + + +/* +The macros Py_INCREF(op) and Py_DECREF(op) are used to increment or decrement +reference counts. Py_DECREF calls the object's deallocator function when +the refcount falls to 0; for +objects that don't contain references to other objects or heap memory +this can be the standard function free(). Both macros can be used +wherever a void expression is allowed. The argument must not be a +NULL pointer. If it may be NULL, use Py_XINCREF/Py_XDECREF instead. +The macro _Py_NewReference(op) initialize reference counts to 1, and +in special builds (Py_REF_DEBUG, Py_TRACE_REFS) performs additional +bookkeeping appropriate to the special build. + +We assume that the reference count field can never overflow; this can +be proven when the size of the field is the same as the pointer size, so +we ignore the possibility. Provided a C int is at least 32 bits (which +is implicitly assumed in many parts of this code), that's enough for +about 2**31 references to an object. + +XXX The following became out of date in Python 2.2, but I'm not sure +XXX what the full truth is now. Certainly, heap-allocated type objects +XXX can and should be deallocated. +Type objects should never be deallocated; the type pointer in an object +is not considered to be a reference to the type object, to save +complications in the deallocation function. (This is actually a +decision that's up to the implementer of each new type so if you want, +you can count such references to the type object.) +*/ + +#ifdef Py_REF_DEBUG +PyAPI_DATA(Py_ssize_t) _Py_RefTotal; +PyAPI_FUNC(void) _Py_NegativeRefcount(const char *filename, int lineno, + PyObject *op); +#endif /* Py_REF_DEBUG */ + +PyAPI_FUNC(void) _Py_Dealloc(PyObject *); + +/* +These are provided as conveniences to Python runtime embedders, so that +they can have object code that is not dependent on Python compilation flags. +*/ +PyAPI_FUNC(void) Py_IncRef(PyObject *); +PyAPI_FUNC(void) Py_DecRef(PyObject *); + +// Similar to Py_IncRef() and Py_DecRef() but the argument must be non-NULL. +// Private functions used by Py_INCREF() and Py_DECREF(). +PyAPI_FUNC(void) _Py_IncRef(PyObject *); +PyAPI_FUNC(void) _Py_DecRef(PyObject *); + +static inline void Py_INCREF(PyObject *op) +{ +#if defined(Py_REF_DEBUG) && defined(Py_LIMITED_API) && Py_LIMITED_API+0 >= 0x030A0000 + // Stable ABI for Python 3.10 built in debug mode. + _Py_IncRef(op); +#else + // Non-limited C API and limited C API for Python 3.9 and older access + // directly PyObject.ob_refcnt. +#ifdef Py_REF_DEBUG + _Py_RefTotal++; +#endif + op->ob_refcnt++; +#endif +} +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000 +# define Py_INCREF(op) Py_INCREF(_PyObject_CAST(op)) +#endif + + +#if defined(Py_REF_DEBUG) && defined(Py_LIMITED_API) && Py_LIMITED_API+0 >= 0x030A0000 +// Stable ABI for limited C API version 3.10 of Python debug build +static inline void Py_DECREF(PyObject *op) { + _Py_DecRef(op); +} +#define Py_DECREF(op) Py_DECREF(_PyObject_CAST(op)) + +#elif defined(Py_REF_DEBUG) +static inline void Py_DECREF(const char *filename, int lineno, PyObject *op) +{ + _Py_RefTotal--; + if (--op->ob_refcnt != 0) { + if (op->ob_refcnt < 0) { + _Py_NegativeRefcount(filename, lineno, op); + } + } + else { + _Py_Dealloc(op); + } +} +#define Py_DECREF(op) Py_DECREF(__FILE__, __LINE__, _PyObject_CAST(op)) + +#else +static inline void Py_DECREF(PyObject *op) +{ + // Non-limited C API and limited C API for Python 3.9 and older access + // directly PyObject.ob_refcnt. + if (--op->ob_refcnt == 0) { + _Py_Dealloc(op); + } +} +#define Py_DECREF(op) Py_DECREF(_PyObject_CAST(op)) +#endif + + +/* Safely decref `op` and set `op` to NULL, especially useful in tp_clear + * and tp_dealloc implementations. + * + * Note that "the obvious" code can be deadly: + * + * Py_XDECREF(op); + * op = NULL; + * + * Typically, `op` is something like self->containee, and `self` is done + * using its `containee` member. In the code sequence above, suppose + * `containee` is non-NULL with a refcount of 1. Its refcount falls to + * 0 on the first line, which can trigger an arbitrary amount of code, + * possibly including finalizers (like __del__ methods or weakref callbacks) + * coded in Python, which in turn can release the GIL and allow other threads + * to run, etc. Such code may even invoke methods of `self` again, or cause + * cyclic gc to trigger, but-- oops! --self->containee still points to the + * object being torn down, and it may be in an insane state while being torn + * down. This has in fact been a rich historic source of miserable (rare & + * hard-to-diagnose) segfaulting (and other) bugs. + * + * The safe way is: + * + * Py_CLEAR(op); + * + * That arranges to set `op` to NULL _before_ decref'ing, so that any code + * triggered as a side-effect of `op` getting torn down no longer believes + * `op` points to a valid object. + * + * There are cases where it's safe to use the naive code, but they're brittle. + * For example, if `op` points to a Python integer, you know that destroying + * one of those can't cause problems -- but in part that relies on that + * Python integers aren't currently weakly referencable. Best practice is + * to use Py_CLEAR() even if you can't think of a reason for why you need to. + */ +#define Py_CLEAR(op) \ + do { \ + PyObject *_py_tmp = _PyObject_CAST(op); \ + if (_py_tmp != NULL) { \ + (op) = NULL; \ + Py_DECREF(_py_tmp); \ + } \ + } while (0) + +/* Function to use in case the object pointer can be NULL: */ +static inline void Py_XINCREF(PyObject *op) +{ + if (op != _Py_NULL) { + Py_INCREF(op); + } +} +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000 +# define Py_XINCREF(op) Py_XINCREF(_PyObject_CAST(op)) +#endif + +static inline void Py_XDECREF(PyObject *op) +{ + if (op != _Py_NULL) { + Py_DECREF(op); + } +} +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000 +# define Py_XDECREF(op) Py_XDECREF(_PyObject_CAST(op)) +#endif + +// Create a new strong reference to an object: +// increment the reference count of the object and return the object. +PyAPI_FUNC(PyObject*) Py_NewRef(PyObject *obj); + +// Similar to Py_NewRef(), but the object can be NULL. +PyAPI_FUNC(PyObject*) Py_XNewRef(PyObject *obj); + +static inline PyObject* _Py_NewRef(PyObject *obj) +{ + Py_INCREF(obj); + return obj; +} + +static inline PyObject* _Py_XNewRef(PyObject *obj) +{ + Py_XINCREF(obj); + return obj; +} + +// Py_NewRef() and Py_XNewRef() are exported as functions for the stable ABI. +// Names overridden with macros by static inline functions for best +// performances. +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000 +# define Py_NewRef(obj) _Py_NewRef(_PyObject_CAST(obj)) +# define Py_XNewRef(obj) _Py_XNewRef(_PyObject_CAST(obj)) +#else +# define Py_NewRef(obj) _Py_NewRef(obj) +# define Py_XNewRef(obj) _Py_XNewRef(obj) +#endif + + +/* +_Py_NoneStruct is an object of undefined type which can be used in contexts +where NULL (nil) is not suitable (since NULL often means 'error'). + +Don't forget to apply Py_INCREF() when returning this value!!! +*/ +PyAPI_DATA(PyObject) _Py_NoneStruct; /* Don't use this directly */ +#define Py_None (&_Py_NoneStruct) + +// Test if an object is the None singleton, the same as "x is None" in Python. +PyAPI_FUNC(int) Py_IsNone(PyObject *x); +#define Py_IsNone(x) Py_Is((x), Py_None) + +/* Macro for returning Py_None from a function */ +#define Py_RETURN_NONE return Py_NewRef(Py_None) + +/* +Py_NotImplemented is a singleton used to signal that an operation is +not implemented for a given type combination. +*/ +PyAPI_DATA(PyObject) _Py_NotImplementedStruct; /* Don't use this directly */ +#define Py_NotImplemented (&_Py_NotImplementedStruct) + +/* Macro for returning Py_NotImplemented from a function */ +#define Py_RETURN_NOTIMPLEMENTED return Py_NewRef(Py_NotImplemented) + +/* Rich comparison opcodes */ +#define Py_LT 0 +#define Py_LE 1 +#define Py_EQ 2 +#define Py_NE 3 +#define Py_GT 4 +#define Py_GE 5 + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 +/* Result of calling PyIter_Send */ +typedef enum { + PYGEN_RETURN = 0, + PYGEN_ERROR = -1, + PYGEN_NEXT = 1, +} PySendResult; +#endif + +/* + * Macro for implementing rich comparisons + * + * Needs to be a macro because any C-comparable type can be used. + */ +#define Py_RETURN_RICHCOMPARE(val1, val2, op) \ + do { \ + switch (op) { \ + case Py_EQ: if ((val1) == (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \ + case Py_NE: if ((val1) != (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \ + case Py_LT: if ((val1) < (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \ + case Py_GT: if ((val1) > (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \ + case Py_LE: if ((val1) <= (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \ + case Py_GE: if ((val1) >= (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \ + default: \ + Py_UNREACHABLE(); \ + } \ + } while (0) + + +/* +More conventions +================ + +Argument Checking +----------------- + +Functions that take objects as arguments normally don't check for nil +arguments, but they do check the type of the argument, and return an +error if the function doesn't apply to the type. + +Failure Modes +------------- + +Functions may fail for a variety of reasons, including running out of +memory. This is communicated to the caller in two ways: an error string +is set (see errors.h), and the function result differs: functions that +normally return a pointer return NULL for failure, functions returning +an integer return -1 (which could be a legal return value too!), and +other functions return 0 for success and -1 for failure. +Callers should always check for errors before using the result. If +an error was set, the caller must either explicitly clear it, or pass +the error on to its caller. + +Reference Counts +---------------- + +It takes a while to get used to the proper usage of reference counts. + +Functions that create an object set the reference count to 1; such new +objects must be stored somewhere or destroyed again with Py_DECREF(). +Some functions that 'store' objects, such as PyTuple_SetItem() and +PyList_SetItem(), +don't increment the reference count of the object, since the most +frequent use is to store a fresh object. Functions that 'retrieve' +objects, such as PyTuple_GetItem() and PyDict_GetItemString(), also +don't increment +the reference count, since most frequently the object is only looked at +quickly. Thus, to retrieve an object and store it again, the caller +must call Py_INCREF() explicitly. + +NOTE: functions that 'consume' a reference count, like +PyList_SetItem(), consume the reference even if the object wasn't +successfully stored, to simplify error handling. + +It seems attractive to make other functions that take an object as +argument consume a reference count; however, this may quickly get +confusing (even the current practice is already confusing). Consider +it carefully, it may save lots of calls to Py_INCREF() and Py_DECREF() at +times. +*/ + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_OBJECT_H +# include "cpython/object.h" +# undef Py_CPYTHON_OBJECT_H +#endif + + +static inline int +PyType_HasFeature(PyTypeObject *type, unsigned long feature) +{ + unsigned long flags; +#ifdef Py_LIMITED_API + // PyTypeObject is opaque in the limited C API + flags = PyType_GetFlags(type); +#else + flags = type->tp_flags; +#endif + return ((flags & feature) != 0); +} + +#define PyType_FastSubclass(type, flag) PyType_HasFeature(type, flag) + +static inline int PyType_Check(PyObject *op) { + return PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TYPE_SUBCLASS); +} +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000 +# define PyType_Check(op) PyType_Check(_PyObject_CAST(op)) +#endif + +#define _PyType_CAST(op) \ + (assert(PyType_Check(op)), _Py_CAST(PyTypeObject*, (op))) + +static inline int PyType_CheckExact(PyObject *op) { + return Py_IS_TYPE(op, &PyType_Type); +} +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000 +# define PyType_CheckExact(op) PyType_CheckExact(_PyObject_CAST(op)) +#endif + +#ifdef __cplusplus +} +#endif +#endif // !Py_OBJECT_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/objimpl.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/objimpl.h new file mode 100644 index 0000000000000000000000000000000000000000..4fa670e71ab46f1d9f8641a6d7862b03a76341f7 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/objimpl.h @@ -0,0 +1,215 @@ +/* The PyObject_ memory family: high-level object memory interfaces. + See pymem.h for the low-level PyMem_ family. +*/ + +#ifndef Py_OBJIMPL_H +#define Py_OBJIMPL_H + +#include "pymem.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* BEWARE: + + Each interface exports both functions and macros. Extension modules should + use the functions, to ensure binary compatibility across Python versions. + Because the Python implementation is free to change internal details, and + the macros may (or may not) expose details for speed, if you do use the + macros you must recompile your extensions with each Python release. + + Never mix calls to PyObject_ memory functions with calls to the platform + malloc/realloc/ calloc/free, or with calls to PyMem_. +*/ + +/* +Functions and macros for modules that implement new object types. + + - PyObject_New(type, typeobj) allocates memory for a new object of the given + type, and initializes part of it. 'type' must be the C structure type used + to represent the object, and 'typeobj' the address of the corresponding + type object. Reference count and type pointer are filled in; the rest of + the bytes of the object are *undefined*! The resulting expression type is + 'type *'. The size of the object is determined by the tp_basicsize field + of the type object. + + - PyObject_NewVar(type, typeobj, n) is similar but allocates a variable-size + object with room for n items. In addition to the refcount and type pointer + fields, this also fills in the ob_size field. + + - PyObject_Free(op) releases the memory allocated for an object. It does not + run a destructor -- it only frees the memory. PyObject_Free is identical. + + - PyObject_Init(op, typeobj) and PyObject_InitVar(op, typeobj, n) don't + allocate memory. Instead of a 'type' parameter, they take a pointer to a + new object (allocated by an arbitrary allocator), and initialize its object + header fields. + +Note that objects created with PyObject_{New, NewVar} are allocated using the +specialized Python allocator (implemented in obmalloc.c), if WITH_PYMALLOC is +enabled. In addition, a special debugging allocator is used if Py_DEBUG +macro is also defined. + +In case a specific form of memory management is needed (for example, if you +must use the platform malloc heap(s), or shared memory, or C++ local storage or +operator new), you must first allocate the object with your custom allocator, +then pass its pointer to PyObject_{Init, InitVar} for filling in its Python- +specific fields: reference count, type pointer, possibly others. You should +be aware that Python has no control over these objects because they don't +cooperate with the Python memory manager. Such objects may not be eligible +for automatic garbage collection and you have to make sure that they are +released accordingly whenever their destructor gets called (cf. the specific +form of memory management you're using). + +Unless you have specific memory management requirements, use +PyObject_{New, NewVar, Del}. +*/ + +/* + * Raw object memory interface + * =========================== + */ + +/* Functions to call the same malloc/realloc/free as used by Python's + object allocator. If WITH_PYMALLOC is enabled, these may differ from + the platform malloc/realloc/free. The Python object allocator is + designed for fast, cache-conscious allocation of many "small" objects, + and with low hidden memory overhead. + + PyObject_Malloc(0) returns a unique non-NULL pointer if possible. + + PyObject_Realloc(NULL, n) acts like PyObject_Malloc(n). + PyObject_Realloc(p != NULL, 0) does not return NULL, or free the memory + at p. + + Returned pointers must be checked for NULL explicitly; no action is + performed on failure other than to return NULL (no warning it printed, no + exception is set, etc). + + For allocating objects, use PyObject_{New, NewVar} instead whenever + possible. The PyObject_{Malloc, Realloc, Free} family is exposed + so that you can exploit Python's small-block allocator for non-object + uses. If you must use these routines to allocate object memory, make sure + the object gets initialized via PyObject_{Init, InitVar} after obtaining + the raw memory. +*/ +PyAPI_FUNC(void *) PyObject_Malloc(size_t size); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 +PyAPI_FUNC(void *) PyObject_Calloc(size_t nelem, size_t elsize); +#endif +PyAPI_FUNC(void *) PyObject_Realloc(void *ptr, size_t new_size); +PyAPI_FUNC(void) PyObject_Free(void *ptr); + + +// Deprecated aliases only kept for backward compatibility. +// PyObject_Del and PyObject_DEL are defined with no parameter to be able to +// use them as function pointers (ex: tp_free = PyObject_Del). +#define PyObject_MALLOC PyObject_Malloc +#define PyObject_REALLOC PyObject_Realloc +#define PyObject_FREE PyObject_Free +#define PyObject_Del PyObject_Free +#define PyObject_DEL PyObject_Free + + +/* + * Generic object allocator interface + * ================================== + */ + +/* Functions */ +PyAPI_FUNC(PyObject *) PyObject_Init(PyObject *, PyTypeObject *); +PyAPI_FUNC(PyVarObject *) PyObject_InitVar(PyVarObject *, + PyTypeObject *, Py_ssize_t); + +#define PyObject_INIT(op, typeobj) \ + PyObject_Init(_PyObject_CAST(op), (typeobj)) +#define PyObject_INIT_VAR(op, typeobj, size) \ + PyObject_InitVar(_PyVarObject_CAST(op), (typeobj), (size)) + + +PyAPI_FUNC(PyObject *) _PyObject_New(PyTypeObject *); +PyAPI_FUNC(PyVarObject *) _PyObject_NewVar(PyTypeObject *, Py_ssize_t); + +#define PyObject_New(type, typeobj) ((type *)_PyObject_New(typeobj)) + +// Alias to PyObject_New(). In Python 3.8, PyObject_NEW() called directly +// PyObject_MALLOC() with _PyObject_SIZE(). +#define PyObject_NEW(type, typeobj) PyObject_New(type, typeobj) + +#define PyObject_NewVar(type, typeobj, n) \ + ( (type *) _PyObject_NewVar((typeobj), (n)) ) + +// Alias to PyObject_NewVar(). In Python 3.8, PyObject_NEW_VAR() called +// directly PyObject_MALLOC() with _PyObject_VAR_SIZE(). +#define PyObject_NEW_VAR(type, typeobj, n) PyObject_NewVar(type, typeobj, n) + + +/* + * Garbage Collection Support + * ========================== + */ + +/* C equivalent of gc.collect(). */ +PyAPI_FUNC(Py_ssize_t) PyGC_Collect(void); +/* C API for controlling the state of the garbage collector */ +PyAPI_FUNC(int) PyGC_Enable(void); +PyAPI_FUNC(int) PyGC_Disable(void); +PyAPI_FUNC(int) PyGC_IsEnabled(void); + +/* Test if a type has a GC head */ +#define PyType_IS_GC(t) PyType_HasFeature((t), Py_TPFLAGS_HAVE_GC) + +PyAPI_FUNC(PyVarObject *) _PyObject_GC_Resize(PyVarObject *, Py_ssize_t); +#define PyObject_GC_Resize(type, op, n) \ + ( (type *) _PyObject_GC_Resize(_PyVarObject_CAST(op), (n)) ) + + + +PyAPI_FUNC(PyObject *) _PyObject_GC_New(PyTypeObject *); +PyAPI_FUNC(PyVarObject *) _PyObject_GC_NewVar(PyTypeObject *, Py_ssize_t); + +/* Tell the GC to track this object. + * + * See also private _PyObject_GC_TRACK() macro. */ +PyAPI_FUNC(void) PyObject_GC_Track(void *); + +/* Tell the GC to stop tracking this object. + * + * See also private _PyObject_GC_UNTRACK() macro. */ +PyAPI_FUNC(void) PyObject_GC_UnTrack(void *); + +PyAPI_FUNC(void) PyObject_GC_Del(void *); + +#define PyObject_GC_New(type, typeobj) \ + _Py_CAST(type*, _PyObject_GC_New(typeobj)) +#define PyObject_GC_NewVar(type, typeobj, n) \ + _Py_CAST(type*, _PyObject_GC_NewVar((typeobj), (n))) + +PyAPI_FUNC(int) PyObject_GC_IsTracked(PyObject *); +PyAPI_FUNC(int) PyObject_GC_IsFinalized(PyObject *); + +/* Utility macro to help write tp_traverse functions. + * To use this macro, the tp_traverse function must name its arguments + * "visit" and "arg". This is intended to keep tp_traverse functions + * looking as much alike as possible. + */ +#define Py_VISIT(op) \ + do { \ + if (op) { \ + int vret = visit(_PyObject_CAST(op), arg); \ + if (vret) \ + return vret; \ + } \ + } while (0) + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_OBJIMPL_H +# include "cpython/objimpl.h" +# undef Py_CPYTHON_OBJIMPL_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_OBJIMPL_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/opcode.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/opcode.h new file mode 100644 index 0000000000000000000000000000000000000000..084d34b8c73cd5d91d17beba69792eae6736aeb3 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/opcode.h @@ -0,0 +1,236 @@ +// Auto-generated by Tools/scripts/generate_opcode_h.py from Lib/opcode.py + +#ifndef Py_OPCODE_H +#define Py_OPCODE_H +#ifdef __cplusplus +extern "C" { +#endif + + +/* Instruction opcodes for compiled code */ +#define CACHE 0 +#define POP_TOP 1 +#define PUSH_NULL 2 +#define NOP 9 +#define UNARY_POSITIVE 10 +#define UNARY_NEGATIVE 11 +#define UNARY_NOT 12 +#define UNARY_INVERT 15 +#define BINARY_SUBSCR 25 +#define GET_LEN 30 +#define MATCH_MAPPING 31 +#define MATCH_SEQUENCE 32 +#define MATCH_KEYS 33 +#define PUSH_EXC_INFO 35 +#define CHECK_EXC_MATCH 36 +#define CHECK_EG_MATCH 37 +#define WITH_EXCEPT_START 49 +#define GET_AITER 50 +#define GET_ANEXT 51 +#define BEFORE_ASYNC_WITH 52 +#define BEFORE_WITH 53 +#define END_ASYNC_FOR 54 +#define STORE_SUBSCR 60 +#define DELETE_SUBSCR 61 +#define GET_ITER 68 +#define GET_YIELD_FROM_ITER 69 +#define PRINT_EXPR 70 +#define LOAD_BUILD_CLASS 71 +#define LOAD_ASSERTION_ERROR 74 +#define RETURN_GENERATOR 75 +#define LIST_TO_TUPLE 82 +#define RETURN_VALUE 83 +#define IMPORT_STAR 84 +#define SETUP_ANNOTATIONS 85 +#define YIELD_VALUE 86 +#define ASYNC_GEN_WRAP 87 +#define PREP_RERAISE_STAR 88 +#define POP_EXCEPT 89 +#define HAVE_ARGUMENT 90 +#define STORE_NAME 90 +#define DELETE_NAME 91 +#define UNPACK_SEQUENCE 92 +#define FOR_ITER 93 +#define UNPACK_EX 94 +#define STORE_ATTR 95 +#define DELETE_ATTR 96 +#define STORE_GLOBAL 97 +#define DELETE_GLOBAL 98 +#define SWAP 99 +#define LOAD_CONST 100 +#define LOAD_NAME 101 +#define BUILD_TUPLE 102 +#define BUILD_LIST 103 +#define BUILD_SET 104 +#define BUILD_MAP 105 +#define LOAD_ATTR 106 +#define COMPARE_OP 107 +#define IMPORT_NAME 108 +#define IMPORT_FROM 109 +#define JUMP_FORWARD 110 +#define JUMP_IF_FALSE_OR_POP 111 +#define JUMP_IF_TRUE_OR_POP 112 +#define POP_JUMP_FORWARD_IF_FALSE 114 +#define POP_JUMP_FORWARD_IF_TRUE 115 +#define LOAD_GLOBAL 116 +#define IS_OP 117 +#define CONTAINS_OP 118 +#define RERAISE 119 +#define COPY 120 +#define BINARY_OP 122 +#define SEND 123 +#define LOAD_FAST 124 +#define STORE_FAST 125 +#define DELETE_FAST 126 +#define POP_JUMP_FORWARD_IF_NOT_NONE 128 +#define POP_JUMP_FORWARD_IF_NONE 129 +#define RAISE_VARARGS 130 +#define GET_AWAITABLE 131 +#define MAKE_FUNCTION 132 +#define BUILD_SLICE 133 +#define JUMP_BACKWARD_NO_INTERRUPT 134 +#define MAKE_CELL 135 +#define LOAD_CLOSURE 136 +#define LOAD_DEREF 137 +#define STORE_DEREF 138 +#define DELETE_DEREF 139 +#define JUMP_BACKWARD 140 +#define CALL_FUNCTION_EX 142 +#define EXTENDED_ARG 144 +#define LIST_APPEND 145 +#define SET_ADD 146 +#define MAP_ADD 147 +#define LOAD_CLASSDEREF 148 +#define COPY_FREE_VARS 149 +#define RESUME 151 +#define MATCH_CLASS 152 +#define FORMAT_VALUE 155 +#define BUILD_CONST_KEY_MAP 156 +#define BUILD_STRING 157 +#define LOAD_METHOD 160 +#define LIST_EXTEND 162 +#define SET_UPDATE 163 +#define DICT_MERGE 164 +#define DICT_UPDATE 165 +#define PRECALL 166 +#define CALL 171 +#define KW_NAMES 172 +#define POP_JUMP_BACKWARD_IF_NOT_NONE 173 +#define POP_JUMP_BACKWARD_IF_NONE 174 +#define POP_JUMP_BACKWARD_IF_FALSE 175 +#define POP_JUMP_BACKWARD_IF_TRUE 176 +#define BINARY_OP_ADAPTIVE 3 +#define BINARY_OP_ADD_FLOAT 4 +#define BINARY_OP_ADD_INT 5 +#define BINARY_OP_ADD_UNICODE 6 +#define BINARY_OP_INPLACE_ADD_UNICODE 7 +#define BINARY_OP_MULTIPLY_FLOAT 8 +#define BINARY_OP_MULTIPLY_INT 13 +#define BINARY_OP_SUBTRACT_FLOAT 14 +#define BINARY_OP_SUBTRACT_INT 16 +#define BINARY_SUBSCR_ADAPTIVE 17 +#define BINARY_SUBSCR_DICT 18 +#define BINARY_SUBSCR_GETITEM 19 +#define BINARY_SUBSCR_LIST_INT 20 +#define BINARY_SUBSCR_TUPLE_INT 21 +#define CALL_ADAPTIVE 22 +#define CALL_PY_EXACT_ARGS 23 +#define CALL_PY_WITH_DEFAULTS 24 +#define COMPARE_OP_ADAPTIVE 26 +#define COMPARE_OP_FLOAT_JUMP 27 +#define COMPARE_OP_INT_JUMP 28 +#define COMPARE_OP_STR_JUMP 29 +#define EXTENDED_ARG_QUICK 34 +#define JUMP_BACKWARD_QUICK 38 +#define LOAD_ATTR_ADAPTIVE 39 +#define LOAD_ATTR_INSTANCE_VALUE 40 +#define LOAD_ATTR_MODULE 41 +#define LOAD_ATTR_SLOT 42 +#define LOAD_ATTR_WITH_HINT 43 +#define LOAD_CONST__LOAD_FAST 44 +#define LOAD_FAST__LOAD_CONST 45 +#define LOAD_FAST__LOAD_FAST 46 +#define LOAD_GLOBAL_ADAPTIVE 47 +#define LOAD_GLOBAL_BUILTIN 48 +#define LOAD_GLOBAL_MODULE 55 +#define LOAD_METHOD_ADAPTIVE 56 +#define LOAD_METHOD_CLASS 57 +#define LOAD_METHOD_MODULE 58 +#define LOAD_METHOD_NO_DICT 59 +#define LOAD_METHOD_WITH_DICT 62 +#define LOAD_METHOD_WITH_VALUES 63 +#define PRECALL_ADAPTIVE 64 +#define PRECALL_BOUND_METHOD 65 +#define PRECALL_BUILTIN_CLASS 66 +#define PRECALL_BUILTIN_FAST_WITH_KEYWORDS 67 +#define PRECALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS 72 +#define PRECALL_NO_KW_BUILTIN_FAST 73 +#define PRECALL_NO_KW_BUILTIN_O 76 +#define PRECALL_NO_KW_ISINSTANCE 77 +#define PRECALL_NO_KW_LEN 78 +#define PRECALL_NO_KW_LIST_APPEND 79 +#define PRECALL_NO_KW_METHOD_DESCRIPTOR_FAST 80 +#define PRECALL_NO_KW_METHOD_DESCRIPTOR_NOARGS 81 +#define PRECALL_NO_KW_METHOD_DESCRIPTOR_O 113 +#define PRECALL_NO_KW_STR_1 121 +#define PRECALL_NO_KW_TUPLE_1 127 +#define PRECALL_NO_KW_TYPE_1 141 +#define PRECALL_PYFUNC 143 +#define RESUME_QUICK 150 +#define STORE_ATTR_ADAPTIVE 153 +#define STORE_ATTR_INSTANCE_VALUE 154 +#define STORE_ATTR_SLOT 158 +#define STORE_ATTR_WITH_HINT 159 +#define STORE_FAST__LOAD_FAST 161 +#define STORE_FAST__STORE_FAST 167 +#define STORE_SUBSCR_ADAPTIVE 168 +#define STORE_SUBSCR_DICT 169 +#define STORE_SUBSCR_LIST_INT 170 +#define UNPACK_SEQUENCE_ADAPTIVE 177 +#define UNPACK_SEQUENCE_LIST 178 +#define UNPACK_SEQUENCE_TUPLE 179 +#define UNPACK_SEQUENCE_TWO_TUPLE 180 +#define DO_TRACING 255 + +#define HAS_CONST(op) (false\ + || ((op) == 100) \ + || ((op) == 172) \ + ) + +#define NB_ADD 0 +#define NB_AND 1 +#define NB_FLOOR_DIVIDE 2 +#define NB_LSHIFT 3 +#define NB_MATRIX_MULTIPLY 4 +#define NB_MULTIPLY 5 +#define NB_REMAINDER 6 +#define NB_OR 7 +#define NB_POWER 8 +#define NB_RSHIFT 9 +#define NB_SUBTRACT 10 +#define NB_TRUE_DIVIDE 11 +#define NB_XOR 12 +#define NB_INPLACE_ADD 13 +#define NB_INPLACE_AND 14 +#define NB_INPLACE_FLOOR_DIVIDE 15 +#define NB_INPLACE_LSHIFT 16 +#define NB_INPLACE_MATRIX_MULTIPLY 17 +#define NB_INPLACE_MULTIPLY 18 +#define NB_INPLACE_REMAINDER 19 +#define NB_INPLACE_OR 20 +#define NB_INPLACE_POWER 21 +#define NB_INPLACE_RSHIFT 22 +#define NB_INPLACE_SUBTRACT 23 +#define NB_INPLACE_TRUE_DIVIDE 24 +#define NB_INPLACE_XOR 25 + +#define HAS_ARG(op) ((op) >= HAVE_ARGUMENT) + +/* Reserve some bytecodes for internal use in the compiler. + * The value of 240 is arbitrary. */ +#define IS_ARTIFICIAL(op) ((op) > 240) + +#ifdef __cplusplus +} +#endif +#endif /* !Py_OPCODE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/osdefs.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/osdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..3243944a1483e95904b4d7d75d0e152ac00824e5 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/osdefs.h @@ -0,0 +1,51 @@ +#ifndef Py_OSDEFS_H +#define Py_OSDEFS_H +#ifdef __cplusplus +extern "C" { +#endif + + +/* Operating system dependencies */ + +#ifdef MS_WINDOWS +#define SEP L'\\' +#define ALTSEP L'/' +#define MAXPATHLEN 256 +#define DELIM L';' +#endif + +#ifdef __VXWORKS__ +#define DELIM L';' +#endif + +/* Filename separator */ +#ifndef SEP +#define SEP L'/' +#endif + +/* Max pathname length */ +#ifdef __hpux +#include +#include +#ifndef PATH_MAX +#define PATH_MAX MAXPATHLEN +#endif +#endif + +#ifndef MAXPATHLEN +#if defined(PATH_MAX) && PATH_MAX > 1024 +#define MAXPATHLEN PATH_MAX +#else +#define MAXPATHLEN 1024 +#endif +#endif + +/* Search path entry delimiter */ +#ifndef DELIM +#define DELIM L':' +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_OSDEFS_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/osmodule.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/osmodule.h new file mode 100644 index 0000000000000000000000000000000000000000..9095c2fdd3d638140db129937d29830286941819 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/osmodule.h @@ -0,0 +1,17 @@ + +/* os module interface */ + +#ifndef Py_OSMODULE_H +#define Py_OSMODULE_H +#ifdef __cplusplus +extern "C" { +#endif + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000 +PyAPI_FUNC(PyObject *) PyOS_FSPath(PyObject *path); +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_OSMODULE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/patchlevel.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/patchlevel.h new file mode 100644 index 0000000000000000000000000000000000000000..1347b7bbd2714375c5a7611a10db0916e6878e5a --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/patchlevel.h @@ -0,0 +1,35 @@ + +/* Python version identification scheme. + + When the major or minor version changes, the VERSION variable in + configure.ac must also be changed. + + There is also (independent) API version information in modsupport.h. +*/ + +/* Values for PY_RELEASE_LEVEL */ +#define PY_RELEASE_LEVEL_ALPHA 0xA +#define PY_RELEASE_LEVEL_BETA 0xB +#define PY_RELEASE_LEVEL_GAMMA 0xC /* For release candidates */ +#define PY_RELEASE_LEVEL_FINAL 0xF /* Serial should be 0 here */ + /* Higher for patch releases */ + +/* Version parsed out into numeric values */ +/*--start constants--*/ +#define PY_MAJOR_VERSION 3 +#define PY_MINOR_VERSION 11 +#define PY_MICRO_VERSION 15 +#define PY_RELEASE_LEVEL PY_RELEASE_LEVEL_FINAL +#define PY_RELEASE_SERIAL 0 + +/* Version as a string */ +#define PY_VERSION "3.11.15" +/*--end constants--*/ + +/* Version as a single 4-byte hex number, e.g. 0x010502B2 == 1.5.2b2. + Use this for numeric comparisons, e.g. #if PY_VERSION_HEX >= ... */ +#define PY_VERSION_HEX ((PY_MAJOR_VERSION << 24) | \ + (PY_MINOR_VERSION << 16) | \ + (PY_MICRO_VERSION << 8) | \ + (PY_RELEASE_LEVEL << 4) | \ + (PY_RELEASE_SERIAL << 0)) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/py_curses.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/py_curses.h new file mode 100644 index 0000000000000000000000000000000000000000..b2c7f1bb4309c6a8020d34f9ad3ded6f03844f01 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/py_curses.h @@ -0,0 +1,99 @@ + +#ifndef Py_CURSES_H +#define Py_CURSES_H + +#ifdef __APPLE__ +/* +** On Mac OS X 10.2 [n]curses.h and stdlib.h use different guards +** against multiple definition of wchar_t. +*/ +#ifdef _BSD_WCHAR_T_DEFINED_ +#define _WCHAR_T +#endif +#endif /* __APPLE__ */ + +/* On FreeBSD, [n]curses.h and stdlib.h/wchar.h use different guards + against multiple definition of wchar_t and wint_t. */ +#if defined(__FreeBSD__) && defined(_XOPEN_SOURCE_EXTENDED) +# ifndef __wchar_t +# define __wchar_t +# endif +# ifndef __wint_t +# define __wint_t +# endif +#endif + +#if !defined(HAVE_CURSES_IS_PAD) && defined(WINDOW_HAS_FLAGS) +/* The following definition is necessary for ncurses 5.7; without it, + some of [n]curses.h set NCURSES_OPAQUE to 1, and then Python + can't get at the WINDOW flags field. */ +#define NCURSES_OPAQUE 0 +#endif + +#ifdef HAVE_NCURSES_H +#include +#else +#include +#endif + +#ifdef HAVE_NCURSES_H +/* configure was checking , but we will + use , which has some or all these features. */ +#if !defined(WINDOW_HAS_FLAGS) && !(NCURSES_OPAQUE+0) +#define WINDOW_HAS_FLAGS 1 +#endif +#if !defined(HAVE_CURSES_IS_PAD) && NCURSES_VERSION_PATCH+0 >= 20090906 +#define HAVE_CURSES_IS_PAD 1 +#endif +#ifndef MVWDELCH_IS_EXPRESSION +#define MVWDELCH_IS_EXPRESSION 1 +#endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#define PyCurses_API_pointers 4 + +/* Type declarations */ + +typedef struct { + PyObject_HEAD + WINDOW *win; + char *encoding; +} PyCursesWindowObject; + +#define PyCursesWindow_Check(v) Py_IS_TYPE(v, &PyCursesWindow_Type) + +#define PyCurses_CAPSULE_NAME "_curses._C_API" + + +#ifdef CURSES_MODULE +/* This section is used when compiling _cursesmodule.c */ + +#else +/* This section is used in modules that use the _cursesmodule API */ + +static void **PyCurses_API; + +#define PyCursesWindow_Type (*_PyType_CAST(PyCurses_API[0])) +#define PyCursesSetupTermCalled {if (! ((int (*)(void))PyCurses_API[1]) () ) return NULL;} +#define PyCursesInitialised {if (! ((int (*)(void))PyCurses_API[2]) () ) return NULL;} +#define PyCursesInitialisedColor {if (! ((int (*)(void))PyCurses_API[3]) () ) return NULL;} + +#define import_curses() \ + PyCurses_API = (void **)PyCapsule_Import(PyCurses_CAPSULE_NAME, 1); + +#endif + +/* general error messages */ +static const char catchall_ERR[] = "curses function returned ERR"; +static const char catchall_NULL[] = "curses function returned NULL"; + +#ifdef __cplusplus +} +#endif + +#endif /* !defined(Py_CURSES_H) */ + diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pybuffer.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pybuffer.h new file mode 100644 index 0000000000000000000000000000000000000000..6893505e66e3e812448d651451cca5e194e0f88f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pybuffer.h @@ -0,0 +1,142 @@ +/* Public Py_buffer API */ + +#ifndef Py_BUFFER_H +#define Py_BUFFER_H +#ifdef __cplusplus +extern "C" { +#endif + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030b0000 + +/* === New Buffer API ============================================ + * Limited API and stable ABI since Python 3.11 + * + * Py_buffer struct layout and size is now part of the stable abi3. The + * struct layout and size must not be changed in any way, as it would + * break the ABI. + * + */ + +typedef struct { + void *buf; + PyObject *obj; /* owned reference */ + Py_ssize_t len; + Py_ssize_t itemsize; /* This is Py_ssize_t so it can be + pointed to by strides in simple case.*/ + int readonly; + int ndim; + char *format; + Py_ssize_t *shape; + Py_ssize_t *strides; + Py_ssize_t *suboffsets; + void *internal; +} Py_buffer; + +/* Return 1 if the getbuffer function is available, otherwise return 0. */ +PyAPI_FUNC(int) PyObject_CheckBuffer(PyObject *obj); + +/* This is a C-API version of the getbuffer function call. It checks + to make sure object has the required function pointer and issues the + call. + + Returns -1 and raises an error on failure and returns 0 on success. */ +PyAPI_FUNC(int) PyObject_GetBuffer(PyObject *obj, Py_buffer *view, + int flags); + +/* Get the memory area pointed to by the indices for the buffer given. + Note that view->ndim is the assumed size of indices. */ +PyAPI_FUNC(void *) PyBuffer_GetPointer(const Py_buffer *view, const Py_ssize_t *indices); + +/* Return the implied itemsize of the data-format area from a + struct-style description. */ +PyAPI_FUNC(Py_ssize_t) PyBuffer_SizeFromFormat(const char *format); + +/* Implementation in memoryobject.c */ +PyAPI_FUNC(int) PyBuffer_ToContiguous(void *buf, const Py_buffer *view, + Py_ssize_t len, char order); + +PyAPI_FUNC(int) PyBuffer_FromContiguous(const Py_buffer *view, const void *buf, + Py_ssize_t len, char order); + +/* Copy len bytes of data from the contiguous chunk of memory + pointed to by buf into the buffer exported by obj. Return + 0 on success and return -1 and raise a PyBuffer_Error on + error (i.e. the object does not have a buffer interface or + it is not working). + + If fort is 'F', then if the object is multi-dimensional, + then the data will be copied into the array in + Fortran-style (first dimension varies the fastest). If + fort is 'C', then the data will be copied into the array + in C-style (last dimension varies the fastest). If fort + is 'A', then it does not matter and the copy will be made + in whatever way is more efficient. */ +PyAPI_FUNC(int) PyObject_CopyData(PyObject *dest, PyObject *src); + +/* Copy the data from the src buffer to the buffer of destination. */ +PyAPI_FUNC(int) PyBuffer_IsContiguous(const Py_buffer *view, char fort); + +/*Fill the strides array with byte-strides of a contiguous + (Fortran-style if fort is 'F' or C-style otherwise) + array of the given shape with the given number of bytes + per element. */ +PyAPI_FUNC(void) PyBuffer_FillContiguousStrides(int ndims, + Py_ssize_t *shape, + Py_ssize_t *strides, + int itemsize, + char fort); + +/* Fills in a buffer-info structure correctly for an exporter + that can only share a contiguous chunk of memory of + "unsigned bytes" of the given length. + + Returns 0 on success and -1 (with raising an error) on error. */ +PyAPI_FUNC(int) PyBuffer_FillInfo(Py_buffer *view, PyObject *o, void *buf, + Py_ssize_t len, int readonly, + int flags); + +/* Releases a Py_buffer obtained from getbuffer ParseTuple's "s*". */ +PyAPI_FUNC(void) PyBuffer_Release(Py_buffer *view); + +/* Maximum number of dimensions */ +#define PyBUF_MAX_NDIM 64 + +/* Flags for getting buffers */ +#define PyBUF_SIMPLE 0 +#define PyBUF_WRITABLE 0x0001 + +#ifndef Py_LIMITED_API +/* we used to include an E, backwards compatible alias */ +#define PyBUF_WRITEABLE PyBUF_WRITABLE +#endif + +#define PyBUF_FORMAT 0x0004 +#define PyBUF_ND 0x0008 +#define PyBUF_STRIDES (0x0010 | PyBUF_ND) +#define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES) +#define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES) +#define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES) +#define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES) + +#define PyBUF_CONTIG (PyBUF_ND | PyBUF_WRITABLE) +#define PyBUF_CONTIG_RO (PyBUF_ND) + +#define PyBUF_STRIDED (PyBUF_STRIDES | PyBUF_WRITABLE) +#define PyBUF_STRIDED_RO (PyBUF_STRIDES) + +#define PyBUF_RECORDS (PyBUF_STRIDES | PyBUF_WRITABLE | PyBUF_FORMAT) +#define PyBUF_RECORDS_RO (PyBUF_STRIDES | PyBUF_FORMAT) + +#define PyBUF_FULL (PyBUF_INDIRECT | PyBUF_WRITABLE | PyBUF_FORMAT) +#define PyBUF_FULL_RO (PyBUF_INDIRECT | PyBUF_FORMAT) + + +#define PyBUF_READ 0x100 +#define PyBUF_WRITE 0x200 + +#endif /* !Py_LIMITED_API || Py_LIMITED_API >= 3.11 */ + +#ifdef __cplusplus +} +#endif +#endif /* Py_BUFFER_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pycapsule.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pycapsule.h new file mode 100644 index 0000000000000000000000000000000000000000..fb5d503fea73f13a254dc51b003e703b511250dd --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pycapsule.h @@ -0,0 +1,59 @@ + +/* Capsule objects let you wrap a C "void *" pointer in a Python + object. They're a way of passing data through the Python interpreter + without creating your own custom type. + + Capsules are used for communication between extension modules. + They provide a way for an extension module to export a C interface + to other extension modules, so that extension modules can use the + Python import mechanism to link to one another. + + For more information, please see "c-api/capsule.html" in the + documentation. +*/ + +#ifndef Py_CAPSULE_H +#define Py_CAPSULE_H +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_DATA(PyTypeObject) PyCapsule_Type; + +typedef void (*PyCapsule_Destructor)(PyObject *); + +#define PyCapsule_CheckExact(op) Py_IS_TYPE(op, &PyCapsule_Type) + + +PyAPI_FUNC(PyObject *) PyCapsule_New( + void *pointer, + const char *name, + PyCapsule_Destructor destructor); + +PyAPI_FUNC(void *) PyCapsule_GetPointer(PyObject *capsule, const char *name); + +PyAPI_FUNC(PyCapsule_Destructor) PyCapsule_GetDestructor(PyObject *capsule); + +PyAPI_FUNC(const char *) PyCapsule_GetName(PyObject *capsule); + +PyAPI_FUNC(void *) PyCapsule_GetContext(PyObject *capsule); + +PyAPI_FUNC(int) PyCapsule_IsValid(PyObject *capsule, const char *name); + +PyAPI_FUNC(int) PyCapsule_SetPointer(PyObject *capsule, void *pointer); + +PyAPI_FUNC(int) PyCapsule_SetDestructor(PyObject *capsule, PyCapsule_Destructor destructor); + +PyAPI_FUNC(int) PyCapsule_SetName(PyObject *capsule, const char *name); + +PyAPI_FUNC(int) PyCapsule_SetContext(PyObject *capsule, void *context); + +PyAPI_FUNC(void *) PyCapsule_Import( + const char *name, /* UTF-8 encoded string */ + int no_block); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_CAPSULE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pyconfig.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pyconfig.h new file mode 100644 index 0000000000000000000000000000000000000000..8dc0b88b86ced63ebe09911368c36fcf1c726b4b --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pyconfig.h @@ -0,0 +1,708 @@ +#ifndef Py_CONFIG_H +#define Py_CONFIG_H + +/* pyconfig.h. NOT Generated automatically by configure. + +This is a manually maintained version used for the Watcom, +Borland and Microsoft Visual C++ compilers. It is a +standard part of the Python distribution. + +WINDOWS DEFINES: +The code specific to Windows should be wrapped around one of +the following #defines + +MS_WIN64 - Code specific to the MS Win64 API +MS_WIN32 - Code specific to the MS Win32 (and Win64) API (obsolete, this covers all supported APIs) +MS_WINDOWS - Code specific to Windows, but all versions. +Py_ENABLE_SHARED - Code if the Python core is built as a DLL. + +Also note that neither "_M_IX86" or "_MSC_VER" should be used for +any purpose other than "Windows Intel x86 specific" and "Microsoft +compiler specific". Therefore, these should be very rare. + + +NOTE: The following symbols are deprecated: +NT, USE_DL_EXPORT, USE_DL_IMPORT, DL_EXPORT, DL_IMPORT +MS_CORE_DLL. + +WIN32 is still required for the locale module. + +*/ + +/* Deprecated USE_DL_EXPORT macro - please use Py_BUILD_CORE */ +#ifdef USE_DL_EXPORT +# define Py_BUILD_CORE +#endif /* USE_DL_EXPORT */ + +/* Visual Studio 2005 introduces deprecation warnings for + "insecure" and POSIX functions. The insecure functions should + be replaced by *_s versions (according to Microsoft); the + POSIX functions by _* versions (which, according to Microsoft, + would be ISO C conforming). Neither renaming is feasible, so + we just silence the warnings. */ + +#ifndef _CRT_SECURE_NO_DEPRECATE +#define _CRT_SECURE_NO_DEPRECATE 1 +#endif +#ifndef _CRT_NONSTDC_NO_DEPRECATE +#define _CRT_NONSTDC_NO_DEPRECATE 1 +#endif + +#define HAVE_IO_H +#define HAVE_SYS_UTIME_H +#define HAVE_TEMPNAM +#define HAVE_TMPFILE +#define HAVE_TMPNAM +#define HAVE_CLOCK +#define HAVE_STRERROR + +#include + +#define HAVE_STRFTIME +#define DONT_HAVE_SIG_ALARM +#define DONT_HAVE_SIG_PAUSE +#define LONG_BIT 32 +#define WORD_BIT 32 + +#define MS_WIN32 /* only support win32 and greater. */ +#define MS_WINDOWS +#define NT_THREADS +#define WITH_THREAD +#ifndef NETSCAPE_PI +#define USE_SOCKET +#endif + + +/* Compiler specific defines */ + +/* ------------------------------------------------------------------------*/ +/* Microsoft C defines _MSC_VER */ +#ifdef _MSC_VER + +/* We want COMPILER to expand to a string containing _MSC_VER's *value*. + * This is horridly tricky, because the stringization operator only works + * on macro arguments, and doesn't evaluate macros passed *as* arguments. + * Attempts simpler than the following appear doomed to produce "_MSC_VER" + * literally in the string. + */ +#define _Py_PASTE_VERSION(SUFFIX) \ + ("[MSC v." _Py_STRINGIZE(_MSC_VER) " " SUFFIX "]") +/* e.g., this produces, after compile-time string catenation, + * ("[MSC v.1200 32 bit (Intel)]") + * + * _Py_STRINGIZE(_MSC_VER) expands to + * _Py_STRINGIZE1((_MSC_VER)) expands to + * _Py_STRINGIZE2(_MSC_VER) but as this call is the result of token-pasting + * it's scanned again for macros and so further expands to (under MSVC 6) + * _Py_STRINGIZE2(1200) which then expands to + * "1200" + */ +#define _Py_STRINGIZE(X) _Py_STRINGIZE1((X)) +#define _Py_STRINGIZE1(X) _Py_STRINGIZE2 ## X +#define _Py_STRINGIZE2(X) #X + +/* MSVC defines _WINxx to differentiate the windows platform types + + Note that for compatibility reasons _WIN32 is defined on Win32 + *and* on Win64. For the same reasons, in Python, MS_WIN32 is + defined on Win32 *and* Win64. Win32 only code must therefore be + guarded as follows: + #if defined(MS_WIN32) && !defined(MS_WIN64) +*/ +#ifdef _WIN64 +#define MS_WIN64 +#endif + +/* set the COMPILER and support tier + * + * win_amd64 MSVC (x86_64-pc-windows-msvc): 1 + * win32 MSVC (i686-pc-windows-msvc): 1 + * win_arm64 MSVC (aarch64-pc-windows-msvc): 3 + * other archs and ICC: 0 + */ +#ifdef MS_WIN64 +#if defined(_M_X64) || defined(_M_AMD64) +#if defined(__INTEL_COMPILER) +#define COMPILER ("[ICC v." _Py_STRINGIZE(__INTEL_COMPILER) " 64 bit (amd64) with MSC v." _Py_STRINGIZE(_MSC_VER) " CRT]") +#define PY_SUPPORT_TIER 0 +#else +#define COMPILER _Py_PASTE_VERSION("64 bit (AMD64)") +#define PY_SUPPORT_TIER 1 +#endif /* __INTEL_COMPILER */ +#define PYD_PLATFORM_TAG "win_amd64" +#elif defined(_M_ARM64) +#define COMPILER _Py_PASTE_VERSION("64 bit (ARM64)") +#define PY_SUPPORT_TIER 3 +#define PYD_PLATFORM_TAG "win_arm64" +#else +#define COMPILER _Py_PASTE_VERSION("64 bit (Unknown)") +#define PY_SUPPORT_TIER 0 +#endif +#endif /* MS_WIN64 */ + +/* set the version macros for the windows headers */ +/* Python 3.9+ requires Windows 8 or greater */ +#define Py_WINVER 0x0602 /* _WIN32_WINNT_WIN8 */ +#define Py_NTDDI NTDDI_WIN8 + +/* We only set these values when building Python - we don't want to force + these values on extensions, as that will affect the prototypes and + structures exposed in the Windows headers. Even when building Python, we + allow a single source file to override this - they may need access to + structures etc so it can optionally use new Windows features if it + determines at runtime they are available. +*/ +#if defined(Py_BUILD_CORE) || defined(Py_BUILD_CORE_BUILTIN) || defined(Py_BUILD_CORE_MODULE) +#ifndef NTDDI_VERSION +#define NTDDI_VERSION Py_NTDDI +#endif +#ifndef WINVER +#define WINVER Py_WINVER +#endif +#ifndef _WIN32_WINNT +#define _WIN32_WINNT Py_WINVER +#endif +#endif + +/* _W64 is not defined for VC6 or eVC4 */ +#ifndef _W64 +#define _W64 +#endif + +/* Define like size_t, omitting the "unsigned" */ +#ifdef MS_WIN64 +typedef __int64 Py_ssize_t; +# define PY_SSIZE_T_MAX LLONG_MAX +#else +typedef _W64 int Py_ssize_t; +# define PY_SSIZE_T_MAX INT_MAX +#endif +#define HAVE_PY_SSIZE_T 1 + +#if defined(MS_WIN32) && !defined(MS_WIN64) +#if defined(_M_IX86) +#if defined(__INTEL_COMPILER) +#define COMPILER ("[ICC v." _Py_STRINGIZE(__INTEL_COMPILER) " 32 bit (Intel) with MSC v." _Py_STRINGIZE(_MSC_VER) " CRT]") +#define PY_SUPPORT_TIER 0 +#else +#define COMPILER _Py_PASTE_VERSION("32 bit (Intel)") +#define PY_SUPPORT_TIER 1 +#endif /* __INTEL_COMPILER */ +#define PYD_PLATFORM_TAG "win32" +#elif defined(_M_ARM) +#define COMPILER _Py_PASTE_VERSION("32 bit (ARM)") +#define PYD_PLATFORM_TAG "win_arm32" +#define PY_SUPPORT_TIER 0 +#else +#define COMPILER _Py_PASTE_VERSION("32 bit (Unknown)") +#define PY_SUPPORT_TIER 0 +#endif +#endif /* MS_WIN32 && !MS_WIN64 */ + +/* define some ANSI types that are not defined in earlier Win headers */ +#if _MSC_VER >= 1200 +/* This file only exists in VC 6.0 or higher */ +#include +#endif + +#endif /* _MSC_VER */ + +/* ------------------------------------------------------------------------*/ +/* egcs/gnu-win32 defines __GNUC__ and _WIN32 */ +#if defined(__GNUC__) && defined(_WIN32) +/* XXX These defines are likely incomplete, but should be easy to fix. + They should be complete enough to build extension modules. */ +/* Suggested by Rene Liebscher to avoid a GCC 2.91.* + bug that requires structure imports. More recent versions of the + compiler don't exhibit this bug. +*/ +#if (__GNUC__==2) && (__GNUC_MINOR__<=91) +#warning "Please use an up-to-date version of gcc! (>2.91 recommended)" +#endif + +#define COMPILER "[gcc]" +#define PY_LONG_LONG long long +#define PY_LLONG_MIN LLONG_MIN +#define PY_LLONG_MAX LLONG_MAX +#define PY_ULLONG_MAX ULLONG_MAX +#endif /* GNUC */ + +/* ------------------------------------------------------------------------*/ +/* lcc-win32 defines __LCC__ */ +#if defined(__LCC__) +/* XXX These defines are likely incomplete, but should be easy to fix. + They should be complete enough to build extension modules. */ + +#define COMPILER "[lcc-win32]" +typedef int pid_t; +/* __declspec() is supported here too - do nothing to get the defaults */ + +#endif /* LCC */ + +/* ------------------------------------------------------------------------*/ +/* End of compilers - finish up */ + +#ifndef NO_STDIO_H +# include +#endif + +/* 64 bit ints are usually spelt __int64 unless compiler has overridden */ +#ifndef PY_LONG_LONG +# define PY_LONG_LONG __int64 +# define PY_LLONG_MAX _I64_MAX +# define PY_LLONG_MIN _I64_MIN +# define PY_ULLONG_MAX _UI64_MAX +#endif + +/* For Windows the Python core is in a DLL by default. Test +Py_NO_ENABLE_SHARED to find out. Also support MS_NO_COREDLL for b/w compat */ +#if !defined(MS_NO_COREDLL) && !defined(Py_NO_ENABLE_SHARED) +# define Py_ENABLE_SHARED 1 /* standard symbol for shared library */ +# define MS_COREDLL /* deprecated old symbol */ +#endif /* !MS_NO_COREDLL && ... */ + +/* All windows compilers that use this header support __declspec */ +#define HAVE_DECLSPEC_DLL + +/* For an MSVC DLL, we can nominate the .lib files used by extensions */ +#ifdef MS_COREDLL +# if !defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_BUILTIN) + /* not building the core - must be an ext */ +# if defined(_MSC_VER) + /* So MSVC users need not specify the .lib + file in their Makefile (other compilers are + generally taken care of by distutils.) */ +# if defined(_DEBUG) +# pragma comment(lib,"python311_d.lib") +# elif defined(Py_LIMITED_API) +# pragma comment(lib,"python3.lib") +# else +# pragma comment(lib,"python311.lib") +# endif /* _DEBUG */ +# endif /* _MSC_VER */ +# endif /* Py_BUILD_CORE */ +#endif /* MS_COREDLL */ + +#if defined(MS_WIN64) +/* maintain "win32" sys.platform for backward compatibility of Python code, + the Win64 API should be close enough to the Win32 API to make this + preferable */ +# define PLATFORM "win32" +# define SIZEOF_VOID_P 8 +# define SIZEOF_TIME_T 8 +# define SIZEOF_OFF_T 4 +# define SIZEOF_FPOS_T 8 +# define SIZEOF_HKEY 8 +# define SIZEOF_SIZE_T 8 +# define ALIGNOF_SIZE_T 8 +/* configure.ac defines HAVE_LARGEFILE_SUPPORT iff + sizeof(off_t) > sizeof(long), and sizeof(long long) >= sizeof(off_t). + On Win64 the second condition is not true, but if fpos_t replaces off_t + then this is true. The uses of HAVE_LARGEFILE_SUPPORT imply that Win64 + should define this. */ +# define HAVE_LARGEFILE_SUPPORT +#elif defined(MS_WIN32) +# define PLATFORM "win32" +# define HAVE_LARGEFILE_SUPPORT +# define SIZEOF_VOID_P 4 +# define SIZEOF_OFF_T 4 +# define SIZEOF_FPOS_T 8 +# define SIZEOF_HKEY 4 +# define SIZEOF_SIZE_T 4 +# define ALIGNOF_SIZE_T 4 + /* MS VS2005 changes time_t to a 64-bit type on all platforms */ +# if defined(_MSC_VER) && _MSC_VER >= 1400 +# define SIZEOF_TIME_T 8 +# else +# define SIZEOF_TIME_T 4 +# endif +#endif + +#ifdef _DEBUG +# define Py_DEBUG +#endif + + +#ifdef MS_WIN32 + +#define SIZEOF_SHORT 2 +#define SIZEOF_INT 4 +#define SIZEOF_LONG 4 +#define ALIGNOF_LONG 4 +#define SIZEOF_LONG_LONG 8 +#define SIZEOF_DOUBLE 8 +#define SIZEOF_FLOAT 4 + +/* VC 7.1 has them and VC 6.0 does not. VC 6.0 has a version number of 1200. + Microsoft eMbedded Visual C++ 4.0 has a version number of 1201 and doesn't + define these. + If some compiler does not provide them, modify the #if appropriately. */ +#if defined(_MSC_VER) +#if _MSC_VER > 1300 +#define HAVE_UINTPTR_T 1 +#define HAVE_INTPTR_T 1 +#else +/* VC6, VS 2002 and eVC4 don't support the C99 LL suffix for 64-bit integer literals */ +#define Py_LL(x) x##I64 +#endif /* _MSC_VER > 1300 */ +#endif /* _MSC_VER */ + +#endif + +/* define signed and unsigned exact-width 32-bit and 64-bit types, used in the + implementation of Python integers. */ +#define PY_UINT32_T uint32_t +#define PY_UINT64_T uint64_t +#define PY_INT32_T int32_t +#define PY_INT64_T int64_t + +/* Fairly standard from here! */ + +/* Define if on AIX 3. + System headers sometimes define this. + We just want to avoid a redefinition error message. */ +#ifndef _ALL_SOURCE +/* #undef _ALL_SOURCE */ +#endif + +/* Define to empty if the keyword does not work. */ +/* #define const */ + +/* Define to 1 if you have the header file. */ +#define HAVE_CONIO_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_DIRECT_H 1 + +/* Define to 1 if you have the declaration of `tzname', and to 0 if you don't. + */ +#define HAVE_DECL_TZNAME 1 + +/* Define if you have dirent.h. */ +/* #define DIRENT 1 */ + +/* Define to the type of elements in the array set by `getgroups'. + Usually this is either `int' or `gid_t'. */ +/* #undef GETGROUPS_T */ + +/* Define to `int' if doesn't define. */ +/* #undef gid_t */ + +/* Define if your struct tm has tm_zone. */ +/* #undef HAVE_TM_ZONE */ + +/* Define if you don't have tm_zone but do have the external array + tzname. */ +#define HAVE_TZNAME + +/* Define to `int' if doesn't define. */ +/* #undef mode_t */ + +/* Define if you don't have dirent.h, but have ndir.h. */ +/* #undef NDIR */ + +/* Define to `long' if doesn't define. */ +/* #undef off_t */ + +/* Define to `int' if doesn't define. */ +/* #undef pid_t */ + +/* Define if the system does not provide POSIX.1 features except + with this defined. */ +/* #undef _POSIX_1_SOURCE */ + +/* Define if you need to in order for stat and other things to work. */ +/* #undef _POSIX_SOURCE */ + +/* Define as the return type of signal handlers (int or void). */ +#define RETSIGTYPE void + +/* Define to `unsigned' if doesn't define. */ +/* #undef size_t */ + +/* Define if you have the ANSI C header files. */ +#define STDC_HEADERS 1 + +/* Define if you don't have dirent.h, but have sys/dir.h. */ +/* #undef SYSDIR */ + +/* Define if you don't have dirent.h, but have sys/ndir.h. */ +/* #undef SYSNDIR */ + +/* Define if you can safely include both and . */ +/* #undef TIME_WITH_SYS_TIME */ + +/* Define if your declares struct tm. */ +/* #define TM_IN_SYS_TIME 1 */ + +/* Define to `int' if doesn't define. */ +/* #undef uid_t */ + +/* Define if the closedir function returns void instead of int. */ +/* #undef VOID_CLOSEDIR */ + +/* Define if getpgrp() must be called as getpgrp(0) + and (consequently) setpgrp() as setpgrp(0, 0). */ +/* #undef GETPGRP_HAVE_ARGS */ + +/* Define this if your time.h defines altzone */ +/* #define HAVE_ALTZONE */ + +/* Define if you have the putenv function. */ +#define HAVE_PUTENV + +/* Define if your compiler supports function prototypes */ +#define HAVE_PROTOTYPES + +/* Define if you can safely include both and + (which you can't on SCO ODT 3.0). */ +/* #undef SYS_SELECT_WITH_SYS_TIME */ + +/* Define if you want build the _decimal module using a coroutine-local rather + than a thread-local context */ +#define WITH_DECIMAL_CONTEXTVAR 1 + +/* Define if you want documentation strings in extension modules */ +#define WITH_DOC_STRINGS 1 + +/* Define if you want to compile in rudimentary thread support */ +/* #undef WITH_THREAD */ + +/* Define if you want to use the GNU readline library */ +/* #define WITH_READLINE 1 */ + +/* Use Python's own small-block memory-allocator. */ +#define WITH_PYMALLOC 1 + +/* Define if you want to compile in object freelists optimization */ +#define WITH_FREELISTS 1 + +/* Define if you have clock. */ +/* #define HAVE_CLOCK */ + +/* Define when any dynamic module loading is enabled */ +#define HAVE_DYNAMIC_LOADING + +/* Define if you have ftime. */ +#define HAVE_FTIME + +/* Define if you have getpeername. */ +#define HAVE_GETPEERNAME + +/* Define if you have getpgrp. */ +/* #undef HAVE_GETPGRP */ + +/* Define if you have getpid. */ +#define HAVE_GETPID + +/* Define if you have gettimeofday. */ +/* #undef HAVE_GETTIMEOFDAY */ + +/* Define if you have getwd. */ +/* #undef HAVE_GETWD */ + +/* Define if you have lstat. */ +/* #undef HAVE_LSTAT */ + +/* Define if you have the mktime function. */ +#define HAVE_MKTIME + +/* Define if you have nice. */ +/* #undef HAVE_NICE */ + +/* Define if you have readlink. */ +/* #undef HAVE_READLINK */ + +/* Define if you have setpgid. */ +/* #undef HAVE_SETPGID */ + +/* Define if you have setpgrp. */ +/* #undef HAVE_SETPGRP */ + +/* Define if you have setsid. */ +/* #undef HAVE_SETSID */ + +/* Define if you have setvbuf. */ +#define HAVE_SETVBUF + +/* Define if you have siginterrupt. */ +/* #undef HAVE_SIGINTERRUPT */ + +/* Define to 1 if you have the `shutdown' function. */ +#define HAVE_SHUTDOWN 1 + +/* Define if you have symlink. */ +/* #undef HAVE_SYMLINK */ + +/* Define if you have tcgetpgrp. */ +/* #undef HAVE_TCGETPGRP */ + +/* Define if you have tcsetpgrp. */ +/* #undef HAVE_TCSETPGRP */ + +/* Define if you have times. */ +/* #undef HAVE_TIMES */ + +/* Define to 1 if you have the `umask' function. */ +#define HAVE_UMASK 1 + +/* Define if you have uname. */ +/* #undef HAVE_UNAME */ + +/* Define if you have waitpid. */ +/* #undef HAVE_WAITPID */ + +/* Define to 1 if you have the `wcsftime' function. */ +#if defined(_MSC_VER) && _MSC_VER >= 1310 +#define HAVE_WCSFTIME 1 +#endif + +/* Define to 1 if you have the `wcscoll' function. */ +#define HAVE_WCSCOLL 1 + +/* Define to 1 if you have the `wcsxfrm' function. */ +#define HAVE_WCSXFRM 1 + +/* Define if the zlib library has inflateCopy */ +#define HAVE_ZLIB_COPY 1 + +/* Define if you have the header file. */ +/* #undef HAVE_DLFCN_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_ERRNO_H 1 + +/* Define if you have the header file. */ +#define HAVE_FCNTL_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_PROCESS_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_SIGNAL_H 1 + +/* Define if you have the prototypes. */ +#define HAVE_STDARG_PROTOTYPES + +/* Define if you have the header file. */ +#define HAVE_STDDEF_H 1 + +/* Define if you have the header file. */ +/* #undef HAVE_SYS_AUDIOIO_H */ + +/* Define if you have the header file. */ +/* #define HAVE_SYS_PARAM_H 1 */ + +/* Define if you have the header file. */ +/* #define HAVE_SYS_SELECT_H 1 */ + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_STAT_H 1 + +/* Define if you have the header file. */ +/* #define HAVE_SYS_TIME_H 1 */ + +/* Define if you have the header file. */ +/* #define HAVE_SYS_TIMES_H 1 */ + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_TYPES_H 1 + +/* Define if you have the header file. */ +/* #define HAVE_SYS_UN_H 1 */ + +/* Define if you have the header file. */ +/* #define HAVE_SYS_UTIME_H 1 */ + +/* Define if you have the header file. */ +/* #define HAVE_SYS_UTSNAME_H 1 */ + +/* Define if you have the header file. */ +/* #define HAVE_UNISTD_H 1 */ + +/* Define if you have the header file. */ +/* #define HAVE_UTIME_H 1 */ + +/* Define if the compiler provides a wchar.h header file. */ +#define HAVE_WCHAR_H 1 + +/* The size of `wchar_t', as computed by sizeof. */ +#define SIZEOF_WCHAR_T 2 + +/* The size of `_Bool', as computed by sizeof. */ +#define SIZEOF__BOOL 1 + +/* The size of `pid_t', as computed by sizeof. */ +#define SIZEOF_PID_T SIZEOF_INT + +/* Define if you have the dl library (-ldl). */ +/* #undef HAVE_LIBDL */ + +/* Define if you have the mpc library (-lmpc). */ +/* #undef HAVE_LIBMPC */ + +/* Define if you have the nsl library (-lnsl). */ +#define HAVE_LIBNSL 1 + +/* Define if you have the seq library (-lseq). */ +/* #undef HAVE_LIBSEQ */ + +/* Define if you have the socket library (-lsocket). */ +#define HAVE_LIBSOCKET 1 + +/* Define if you have the sun library (-lsun). */ +/* #undef HAVE_LIBSUN */ + +/* Define if you have the termcap library (-ltermcap). */ +/* #undef HAVE_LIBTERMCAP */ + +/* Define if you have the termlib library (-ltermlib). */ +/* #undef HAVE_LIBTERMLIB */ + +/* Define if you have the thread library (-lthread). */ +/* #undef HAVE_LIBTHREAD */ + +/* WinSock does not use a bitmask in select, and uses + socket handles greater than FD_SETSIZE */ +#define Py_SOCKET_FD_CAN_BE_GE_FD_SETSIZE + +/* Define if C doubles are 64-bit IEEE 754 binary format, stored with the + least significant byte first */ +#define DOUBLE_IS_LITTLE_ENDIAN_IEEE754 1 + +/* Define to 1 if you have the `erf' function. */ +#define HAVE_ERF 1 + +/* Define to 1 if you have the `erfc' function. */ +#define HAVE_ERFC 1 + +// netdb.h functions (provided by winsock.h) +#define HAVE_GETHOSTNAME 1 +#define HAVE_GETHOSTBYADDR 1 +#define HAVE_GETHOSTBYNAME 1 +#define HAVE_GETPROTOBYNAME 1 +#define HAVE_GETSERVBYNAME 1 +#define HAVE_GETSERVBYPORT 1 +// sys/socket.h functions (provided by winsock.h) +#define HAVE_INET_PTON 1 +#define HAVE_INET_NTOA 1 +#define HAVE_ACCEPT 1 +#define HAVE_BIND 1 +#define HAVE_CONNECT 1 +#define HAVE_GETSOCKNAME 1 +#define HAVE_LISTEN 1 +#define HAVE_RECVFROM 1 +#define HAVE_SENDTO 1 +#define HAVE_SETSOCKOPT 1 +#define HAVE_SOCKET 1 + +/* Define to 1 if you have the `dup' function. */ +#define HAVE_DUP 1 + +/* framework name */ +#define _PYTHONFRAMEWORK "" + +/* Define if libssl has X509_VERIFY_PARAM_set1_host and related function */ +#define HAVE_X509_VERIFY_PARAM_SET1_HOST 1 + +#endif /* !Py_CONFIG_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pydtrace.d b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pydtrace.d new file mode 100644 index 0000000000000000000000000000000000000000..5e6a626b01b82f669d685668d4c5ffa3ff474111 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pydtrace.d @@ -0,0 +1,22 @@ +/* Python DTrace provider */ + +provider python { + probe function__entry(const char *, const char *, int); + probe function__return(const char *, const char *, int); + probe instance__new__start(const char *, const char *); + probe instance__new__done(const char *, const char *); + probe instance__delete__start(const char *, const char *); + probe instance__delete__done(const char *, const char *); + probe line(const char *, const char *, int); + probe gc__start(int); + probe gc__done(long); + probe import__find__load__start(const char *); + probe import__find__load__done(const char *, int); + probe audit(const char *, void *); +}; + +#pragma D attributes Evolving/Evolving/Common provider python provider +#pragma D attributes Evolving/Evolving/Common provider python module +#pragma D attributes Evolving/Evolving/Common provider python function +#pragma D attributes Evolving/Evolving/Common provider python name +#pragma D attributes Evolving/Evolving/Common provider python args diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pydtrace.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pydtrace.h new file mode 100644 index 0000000000000000000000000000000000000000..75f8e7f70979c5266635dcf476605421b6a0fad9 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pydtrace.h @@ -0,0 +1,59 @@ +/* Static DTrace probes interface */ + +#ifndef Py_DTRACE_H +#define Py_DTRACE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef WITH_DTRACE + +#include "pydtrace_probes.h" + +/* pydtrace_probes.h, on systems with DTrace, is auto-generated to include + `PyDTrace_{PROBE}` and `PyDTrace_{PROBE}_ENABLED()` macros for every probe + defined in pydtrace_provider.d. + + Calling these functions must be guarded by a `PyDTrace_{PROBE}_ENABLED()` + check to minimize performance impact when probing is off. For example: + + if (PyDTrace_FUNCTION_ENTRY_ENABLED()) + PyDTrace_FUNCTION_ENTRY(f); +*/ + +#else + +/* Without DTrace, compile to nothing. */ + +static inline void PyDTrace_LINE(const char *arg0, const char *arg1, int arg2) {} +static inline void PyDTrace_FUNCTION_ENTRY(const char *arg0, const char *arg1, int arg2) {} +static inline void PyDTrace_FUNCTION_RETURN(const char *arg0, const char *arg1, int arg2) {} +static inline void PyDTrace_GC_START(int arg0) {} +static inline void PyDTrace_GC_DONE(Py_ssize_t arg0) {} +static inline void PyDTrace_INSTANCE_NEW_START(int arg0) {} +static inline void PyDTrace_INSTANCE_NEW_DONE(int arg0) {} +static inline void PyDTrace_INSTANCE_DELETE_START(int arg0) {} +static inline void PyDTrace_INSTANCE_DELETE_DONE(int arg0) {} +static inline void PyDTrace_IMPORT_FIND_LOAD_START(const char *arg0) {} +static inline void PyDTrace_IMPORT_FIND_LOAD_DONE(const char *arg0, int arg1) {} +static inline void PyDTrace_AUDIT(const char *arg0, void *arg1) {} + +static inline int PyDTrace_LINE_ENABLED(void) { return 0; } +static inline int PyDTrace_FUNCTION_ENTRY_ENABLED(void) { return 0; } +static inline int PyDTrace_FUNCTION_RETURN_ENABLED(void) { return 0; } +static inline int PyDTrace_GC_START_ENABLED(void) { return 0; } +static inline int PyDTrace_GC_DONE_ENABLED(void) { return 0; } +static inline int PyDTrace_INSTANCE_NEW_START_ENABLED(void) { return 0; } +static inline int PyDTrace_INSTANCE_NEW_DONE_ENABLED(void) { return 0; } +static inline int PyDTrace_INSTANCE_DELETE_START_ENABLED(void) { return 0; } +static inline int PyDTrace_INSTANCE_DELETE_DONE_ENABLED(void) { return 0; } +static inline int PyDTrace_IMPORT_FIND_LOAD_START_ENABLED(void) { return 0; } +static inline int PyDTrace_IMPORT_FIND_LOAD_DONE_ENABLED(void) { return 0; } +static inline int PyDTrace_AUDIT_ENABLED(void) { return 0; } + +#endif /* !WITH_DTRACE */ + +#ifdef __cplusplus +} +#endif +#endif /* !Py_DTRACE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pyerrors.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pyerrors.h new file mode 100644 index 0000000000000000000000000000000000000000..34e3de3328f4108a387cf4f6b006e93cbf31577b --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pyerrors.h @@ -0,0 +1,331 @@ +#ifndef Py_ERRORS_H +#define Py_ERRORS_H +#ifdef __cplusplus +extern "C" { +#endif + +#include // va_list + +/* Error handling definitions */ + +PyAPI_FUNC(void) PyErr_SetNone(PyObject *); +PyAPI_FUNC(void) PyErr_SetObject(PyObject *, PyObject *); +PyAPI_FUNC(void) PyErr_SetString( + PyObject *exception, + const char *string /* decoded from utf-8 */ + ); +PyAPI_FUNC(PyObject *) PyErr_Occurred(void); +PyAPI_FUNC(void) PyErr_Clear(void); +PyAPI_FUNC(void) PyErr_Fetch(PyObject **, PyObject **, PyObject **); +PyAPI_FUNC(void) PyErr_Restore(PyObject *, PyObject *, PyObject *); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030b0000 +PyAPI_FUNC(PyObject*) PyErr_GetHandledException(void); +PyAPI_FUNC(void) PyErr_SetHandledException(PyObject *); +#endif +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 +PyAPI_FUNC(void) PyErr_GetExcInfo(PyObject **, PyObject **, PyObject **); +PyAPI_FUNC(void) PyErr_SetExcInfo(PyObject *, PyObject *, PyObject *); +#endif + +/* Defined in Python/pylifecycle.c + + The Py_FatalError() function is replaced with a macro which logs + automatically the name of the current function, unless the Py_LIMITED_API + macro is defined. */ +PyAPI_FUNC(void) _Py_NO_RETURN Py_FatalError(const char *message); + +/* Error testing and normalization */ +PyAPI_FUNC(int) PyErr_GivenExceptionMatches(PyObject *, PyObject *); +PyAPI_FUNC(int) PyErr_ExceptionMatches(PyObject *); +PyAPI_FUNC(void) PyErr_NormalizeException(PyObject**, PyObject**, PyObject**); + +/* Traceback manipulation (PEP 3134) */ +PyAPI_FUNC(int) PyException_SetTraceback(PyObject *, PyObject *); +PyAPI_FUNC(PyObject *) PyException_GetTraceback(PyObject *); + +/* Cause manipulation (PEP 3134) */ +PyAPI_FUNC(PyObject *) PyException_GetCause(PyObject *); +PyAPI_FUNC(void) PyException_SetCause(PyObject *, PyObject *); + +/* Context manipulation (PEP 3134) */ +PyAPI_FUNC(PyObject *) PyException_GetContext(PyObject *); +PyAPI_FUNC(void) PyException_SetContext(PyObject *, PyObject *); + +/* */ + +#define PyExceptionClass_Check(x) \ + (PyType_Check((x)) && \ + PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS)) + +#define PyExceptionInstance_Check(x) \ + PyType_FastSubclass(Py_TYPE(x), Py_TPFLAGS_BASE_EXC_SUBCLASS) + +PyAPI_FUNC(const char *) PyExceptionClass_Name(PyObject *); + +#define PyExceptionInstance_Class(x) ((PyObject*)Py_TYPE(x)) + +#define _PyBaseExceptionGroup_Check(x) \ + PyObject_TypeCheck(x, (PyTypeObject *)PyExc_BaseExceptionGroup) + +/* Predefined exceptions */ + +PyAPI_DATA(PyObject *) PyExc_BaseException; +PyAPI_DATA(PyObject *) PyExc_Exception; +PyAPI_DATA(PyObject *) PyExc_BaseExceptionGroup; +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 +PyAPI_DATA(PyObject *) PyExc_StopAsyncIteration; +#endif +PyAPI_DATA(PyObject *) PyExc_StopIteration; +PyAPI_DATA(PyObject *) PyExc_GeneratorExit; +PyAPI_DATA(PyObject *) PyExc_ArithmeticError; +PyAPI_DATA(PyObject *) PyExc_LookupError; + +PyAPI_DATA(PyObject *) PyExc_AssertionError; +PyAPI_DATA(PyObject *) PyExc_AttributeError; +PyAPI_DATA(PyObject *) PyExc_BufferError; +PyAPI_DATA(PyObject *) PyExc_EOFError; +PyAPI_DATA(PyObject *) PyExc_FloatingPointError; +PyAPI_DATA(PyObject *) PyExc_OSError; +PyAPI_DATA(PyObject *) PyExc_ImportError; +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000 +PyAPI_DATA(PyObject *) PyExc_ModuleNotFoundError; +#endif +PyAPI_DATA(PyObject *) PyExc_IndexError; +PyAPI_DATA(PyObject *) PyExc_KeyError; +PyAPI_DATA(PyObject *) PyExc_KeyboardInterrupt; +PyAPI_DATA(PyObject *) PyExc_MemoryError; +PyAPI_DATA(PyObject *) PyExc_NameError; +PyAPI_DATA(PyObject *) PyExc_OverflowError; +PyAPI_DATA(PyObject *) PyExc_RuntimeError; +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 +PyAPI_DATA(PyObject *) PyExc_RecursionError; +#endif +PyAPI_DATA(PyObject *) PyExc_NotImplementedError; +PyAPI_DATA(PyObject *) PyExc_SyntaxError; +PyAPI_DATA(PyObject *) PyExc_IndentationError; +PyAPI_DATA(PyObject *) PyExc_TabError; +PyAPI_DATA(PyObject *) PyExc_ReferenceError; +PyAPI_DATA(PyObject *) PyExc_SystemError; +PyAPI_DATA(PyObject *) PyExc_SystemExit; +PyAPI_DATA(PyObject *) PyExc_TypeError; +PyAPI_DATA(PyObject *) PyExc_UnboundLocalError; +PyAPI_DATA(PyObject *) PyExc_UnicodeError; +PyAPI_DATA(PyObject *) PyExc_UnicodeEncodeError; +PyAPI_DATA(PyObject *) PyExc_UnicodeDecodeError; +PyAPI_DATA(PyObject *) PyExc_UnicodeTranslateError; +PyAPI_DATA(PyObject *) PyExc_ValueError; +PyAPI_DATA(PyObject *) PyExc_ZeroDivisionError; + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 +PyAPI_DATA(PyObject *) PyExc_BlockingIOError; +PyAPI_DATA(PyObject *) PyExc_BrokenPipeError; +PyAPI_DATA(PyObject *) PyExc_ChildProcessError; +PyAPI_DATA(PyObject *) PyExc_ConnectionError; +PyAPI_DATA(PyObject *) PyExc_ConnectionAbortedError; +PyAPI_DATA(PyObject *) PyExc_ConnectionRefusedError; +PyAPI_DATA(PyObject *) PyExc_ConnectionResetError; +PyAPI_DATA(PyObject *) PyExc_FileExistsError; +PyAPI_DATA(PyObject *) PyExc_FileNotFoundError; +PyAPI_DATA(PyObject *) PyExc_InterruptedError; +PyAPI_DATA(PyObject *) PyExc_IsADirectoryError; +PyAPI_DATA(PyObject *) PyExc_NotADirectoryError; +PyAPI_DATA(PyObject *) PyExc_PermissionError; +PyAPI_DATA(PyObject *) PyExc_ProcessLookupError; +PyAPI_DATA(PyObject *) PyExc_TimeoutError; +#endif + + +/* Compatibility aliases */ +PyAPI_DATA(PyObject *) PyExc_EnvironmentError; +PyAPI_DATA(PyObject *) PyExc_IOError; +#ifdef MS_WINDOWS +PyAPI_DATA(PyObject *) PyExc_WindowsError; +#endif + +/* Predefined warning categories */ +PyAPI_DATA(PyObject *) PyExc_Warning; +PyAPI_DATA(PyObject *) PyExc_UserWarning; +PyAPI_DATA(PyObject *) PyExc_DeprecationWarning; +PyAPI_DATA(PyObject *) PyExc_PendingDeprecationWarning; +PyAPI_DATA(PyObject *) PyExc_SyntaxWarning; +PyAPI_DATA(PyObject *) PyExc_RuntimeWarning; +PyAPI_DATA(PyObject *) PyExc_FutureWarning; +PyAPI_DATA(PyObject *) PyExc_ImportWarning; +PyAPI_DATA(PyObject *) PyExc_UnicodeWarning; +PyAPI_DATA(PyObject *) PyExc_BytesWarning; +PyAPI_DATA(PyObject *) PyExc_EncodingWarning; +PyAPI_DATA(PyObject *) PyExc_ResourceWarning; + + +/* Convenience functions */ + +PyAPI_FUNC(int) PyErr_BadArgument(void); +PyAPI_FUNC(PyObject *) PyErr_NoMemory(void); +PyAPI_FUNC(PyObject *) PyErr_SetFromErrno(PyObject *); +PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilenameObject( + PyObject *, PyObject *); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000 +PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilenameObjects( + PyObject *, PyObject *, PyObject *); +#endif +PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilename( + PyObject *exc, + const char *filename /* decoded from the filesystem encoding */ + ); + +PyAPI_FUNC(PyObject *) PyErr_Format( + PyObject *exception, + const char *format, /* ASCII-encoded string */ + ... + ); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 +PyAPI_FUNC(PyObject *) PyErr_FormatV( + PyObject *exception, + const char *format, + va_list vargs); +#endif + +#ifdef MS_WINDOWS +PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithFilename( + int ierr, + const char *filename /* decoded from the filesystem encoding */ + ); +PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErr(int); +PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilenameObject( + PyObject *,int, PyObject *); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000 +PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilenameObjects( + PyObject *,int, PyObject *, PyObject *); +#endif +PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilename( + PyObject *exc, + int ierr, + const char *filename /* decoded from the filesystem encoding */ + ); +PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErr(PyObject *, int); +#endif /* MS_WINDOWS */ + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000 +PyAPI_FUNC(PyObject *) PyErr_SetImportErrorSubclass(PyObject *, PyObject *, + PyObject *, PyObject *); +#endif +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 +PyAPI_FUNC(PyObject *) PyErr_SetImportError(PyObject *, PyObject *, + PyObject *); +#endif + +/* Export the old function so that the existing API remains available: */ +PyAPI_FUNC(void) PyErr_BadInternalCall(void); +PyAPI_FUNC(void) _PyErr_BadInternalCall(const char *filename, int lineno); +/* Mask the old API with a call to the new API for code compiled under + Python 2.0: */ +#define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__) + +/* Function to create a new exception */ +PyAPI_FUNC(PyObject *) PyErr_NewException( + const char *name, PyObject *base, PyObject *dict); +PyAPI_FUNC(PyObject *) PyErr_NewExceptionWithDoc( + const char *name, const char *doc, PyObject *base, PyObject *dict); +PyAPI_FUNC(void) PyErr_WriteUnraisable(PyObject *); + + +/* In signalmodule.c */ +PyAPI_FUNC(int) PyErr_CheckSignals(void); +PyAPI_FUNC(void) PyErr_SetInterrupt(void); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 +PyAPI_FUNC(int) PyErr_SetInterruptEx(int signum); +#endif + +/* Support for adding program text to SyntaxErrors */ +PyAPI_FUNC(void) PyErr_SyntaxLocation( + const char *filename, /* decoded from the filesystem encoding */ + int lineno); +PyAPI_FUNC(void) PyErr_SyntaxLocationEx( + const char *filename, /* decoded from the filesystem encoding */ + int lineno, + int col_offset); +PyAPI_FUNC(PyObject *) PyErr_ProgramText( + const char *filename, /* decoded from the filesystem encoding */ + int lineno); + +/* The following functions are used to create and modify unicode + exceptions from C */ + +/* create a UnicodeDecodeError object */ +PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_Create( + const char *encoding, /* UTF-8 encoded string */ + const char *object, + Py_ssize_t length, + Py_ssize_t start, + Py_ssize_t end, + const char *reason /* UTF-8 encoded string */ + ); + +/* get the encoding attribute */ +PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetEncoding(PyObject *); +PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetEncoding(PyObject *); + +/* get the object attribute */ +PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetObject(PyObject *); +PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetObject(PyObject *); +PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_GetObject(PyObject *); + +/* get the value of the start attribute (the int * may not be NULL) + return 0 on success, -1 on failure */ +PyAPI_FUNC(int) PyUnicodeEncodeError_GetStart(PyObject *, Py_ssize_t *); +PyAPI_FUNC(int) PyUnicodeDecodeError_GetStart(PyObject *, Py_ssize_t *); +PyAPI_FUNC(int) PyUnicodeTranslateError_GetStart(PyObject *, Py_ssize_t *); + +/* assign a new value to the start attribute + return 0 on success, -1 on failure */ +PyAPI_FUNC(int) PyUnicodeEncodeError_SetStart(PyObject *, Py_ssize_t); +PyAPI_FUNC(int) PyUnicodeDecodeError_SetStart(PyObject *, Py_ssize_t); +PyAPI_FUNC(int) PyUnicodeTranslateError_SetStart(PyObject *, Py_ssize_t); + +/* get the value of the end attribute (the int *may not be NULL) + return 0 on success, -1 on failure */ +PyAPI_FUNC(int) PyUnicodeEncodeError_GetEnd(PyObject *, Py_ssize_t *); +PyAPI_FUNC(int) PyUnicodeDecodeError_GetEnd(PyObject *, Py_ssize_t *); +PyAPI_FUNC(int) PyUnicodeTranslateError_GetEnd(PyObject *, Py_ssize_t *); + +/* assign a new value to the end attribute + return 0 on success, -1 on failure */ +PyAPI_FUNC(int) PyUnicodeEncodeError_SetEnd(PyObject *, Py_ssize_t); +PyAPI_FUNC(int) PyUnicodeDecodeError_SetEnd(PyObject *, Py_ssize_t); +PyAPI_FUNC(int) PyUnicodeTranslateError_SetEnd(PyObject *, Py_ssize_t); + +/* get the value of the reason attribute */ +PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetReason(PyObject *); +PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetReason(PyObject *); +PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_GetReason(PyObject *); + +/* assign a new value to the reason attribute + return 0 on success, -1 on failure */ +PyAPI_FUNC(int) PyUnicodeEncodeError_SetReason( + PyObject *exc, + const char *reason /* UTF-8 encoded string */ + ); +PyAPI_FUNC(int) PyUnicodeDecodeError_SetReason( + PyObject *exc, + const char *reason /* UTF-8 encoded string */ + ); +PyAPI_FUNC(int) PyUnicodeTranslateError_SetReason( + PyObject *exc, + const char *reason /* UTF-8 encoded string */ + ); + +PyAPI_FUNC(int) PyOS_snprintf(char *str, size_t size, const char *format, ...) + Py_GCC_ATTRIBUTE((format(printf, 3, 4))); +PyAPI_FUNC(int) PyOS_vsnprintf(char *str, size_t size, const char *format, va_list va) + Py_GCC_ATTRIBUTE((format(printf, 3, 0))); + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_ERRORS_H +# include "cpython/pyerrors.h" +# undef Py_CPYTHON_ERRORS_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_ERRORS_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pyexpat.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pyexpat.h new file mode 100644 index 0000000000000000000000000000000000000000..04548b7684a2fda5ff17203943133f1d73a3cd9a --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pyexpat.h @@ -0,0 +1,62 @@ +/* Stuff to export relevant 'expat' entry points from pyexpat to other + * parser modules, such as cElementTree. */ + +/* note: you must import expat.h before importing this module! */ + +#define PyExpat_CAPI_MAGIC "pyexpat.expat_CAPI 1.1" +#define PyExpat_CAPSULE_NAME "pyexpat.expat_CAPI" + +struct PyExpat_CAPI +{ + char* magic; /* set to PyExpat_CAPI_MAGIC */ + int size; /* set to sizeof(struct PyExpat_CAPI) */ + int MAJOR_VERSION; + int MINOR_VERSION; + int MICRO_VERSION; + /* pointers to selected expat functions. add new functions at + the end, if needed */ + const XML_LChar * (*ErrorString)(enum XML_Error code); + enum XML_Error (*GetErrorCode)(XML_Parser parser); + XML_Size (*GetErrorColumnNumber)(XML_Parser parser); + XML_Size (*GetErrorLineNumber)(XML_Parser parser); + enum XML_Status (*Parse)( + XML_Parser parser, const char *s, int len, int isFinal); + XML_Parser (*ParserCreate_MM)( + const XML_Char *encoding, const XML_Memory_Handling_Suite *memsuite, + const XML_Char *namespaceSeparator); + void (*ParserFree)(XML_Parser parser); + void (*SetCharacterDataHandler)( + XML_Parser parser, XML_CharacterDataHandler handler); + void (*SetCommentHandler)( + XML_Parser parser, XML_CommentHandler handler); + void (*SetDefaultHandlerExpand)( + XML_Parser parser, XML_DefaultHandler handler); + void (*SetElementHandler)( + XML_Parser parser, XML_StartElementHandler start, + XML_EndElementHandler end); + void (*SetNamespaceDeclHandler)( + XML_Parser parser, XML_StartNamespaceDeclHandler start, + XML_EndNamespaceDeclHandler end); + void (*SetProcessingInstructionHandler)( + XML_Parser parser, XML_ProcessingInstructionHandler handler); + void (*SetUnknownEncodingHandler)( + XML_Parser parser, XML_UnknownEncodingHandler handler, + void *encodingHandlerData); + void (*SetUserData)(XML_Parser parser, void *userData); + void (*SetStartDoctypeDeclHandler)(XML_Parser parser, + XML_StartDoctypeDeclHandler start); + enum XML_Status (*SetEncoding)(XML_Parser parser, const XML_Char *encoding); + int (*DefaultUnknownEncodingHandler)( + void *encodingHandlerData, const XML_Char *name, XML_Encoding *info); + /* might be NULL for expat < 2.1.0 */ + int (*SetHashSalt)(XML_Parser parser, unsigned long hash_salt); + /* might be NULL for expat < 2.6.0 */ + XML_Bool (*SetReparseDeferralEnabled)(XML_Parser parser, XML_Bool enabled); + /* might be NULL for expat < 2.7.2 */ + XML_Bool (*SetAllocTrackerActivationThreshold)( + XML_Parser parser, unsigned long long activationThresholdBytes); + XML_Bool (*SetAllocTrackerMaximumAmplification)( + XML_Parser parser, float maxAmplificationFactor); + /* always add new stuff to the end! */ +}; + diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pyframe.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pyframe.h new file mode 100644 index 0000000000000000000000000000000000000000..13d52312ea966e43322950405d06440e0c988fd9 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pyframe.h @@ -0,0 +1,26 @@ +/* Limited C API of PyFrame API + * + * Include "frameobject.h" to get the PyFrameObject structure. + */ + +#ifndef Py_PYFRAME_H +#define Py_PYFRAME_H +#ifdef __cplusplus +extern "C" { +#endif + +/* Return the line of code the frame is currently executing. */ +PyAPI_FUNC(int) PyFrame_GetLineNumber(PyFrameObject *); + +PyAPI_FUNC(PyCodeObject *) PyFrame_GetCode(PyFrameObject *frame); + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_PYFRAME_H +# include "cpython/pyframe.h" +# undef Py_CPYTHON_PYFRAME_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_PYFRAME_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pyhash.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pyhash.h new file mode 100644 index 0000000000000000000000000000000000000000..182d223fab1cac4ec4049292aef6ff7a7d64196b --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pyhash.h @@ -0,0 +1,144 @@ +#ifndef Py_HASH_H + +#define Py_HASH_H +#ifdef __cplusplus +extern "C" { +#endif + +/* Helpers for hash functions */ +#ifndef Py_LIMITED_API +PyAPI_FUNC(Py_hash_t) _Py_HashDouble(PyObject *, double); +PyAPI_FUNC(Py_hash_t) _Py_HashPointer(const void*); +// Similar to _Py_HashPointer(), but don't replace -1 with -2 +PyAPI_FUNC(Py_hash_t) _Py_HashPointerRaw(const void*); +PyAPI_FUNC(Py_hash_t) _Py_HashBytes(const void*, Py_ssize_t); +#endif + +/* Prime multiplier used in string and various other hashes. */ +#define _PyHASH_MULTIPLIER 1000003UL /* 0xf4243 */ + +/* Parameters used for the numeric hash implementation. See notes for + _Py_HashDouble in Python/pyhash.c. Numeric hashes are based on + reduction modulo the prime 2**_PyHASH_BITS - 1. */ + +#if SIZEOF_VOID_P >= 8 +# define _PyHASH_BITS 61 +#else +# define _PyHASH_BITS 31 +#endif + +#define _PyHASH_MODULUS (((size_t)1 << _PyHASH_BITS) - 1) +#define _PyHASH_INF 314159 +#define _PyHASH_IMAG _PyHASH_MULTIPLIER + + +/* hash secret + * + * memory layout on 64 bit systems + * cccccccc cccccccc cccccccc uc -- unsigned char[24] + * pppppppp ssssssss ........ fnv -- two Py_hash_t + * k0k0k0k0 k1k1k1k1 ........ siphash -- two uint64_t + * ........ ........ ssssssss djbx33a -- 16 bytes padding + one Py_hash_t + * ........ ........ eeeeeeee pyexpat XML hash salt + * + * memory layout on 32 bit systems + * cccccccc cccccccc cccccccc uc + * ppppssss ........ ........ fnv -- two Py_hash_t + * k0k0k0k0 k1k1k1k1 ........ siphash -- two uint64_t (*) + * ........ ........ ssss.... djbx33a -- 16 bytes padding + one Py_hash_t + * ........ ........ eeee.... pyexpat XML hash salt + * + * (*) The siphash member may not be available on 32 bit platforms without + * an unsigned int64 data type. + */ +#ifndef Py_LIMITED_API +typedef union { + /* ensure 24 bytes */ + unsigned char uc[24]; + /* two Py_hash_t for FNV */ + struct { + Py_hash_t prefix; + Py_hash_t suffix; + } fnv; + /* two uint64 for SipHash24 */ + struct { + uint64_t k0; + uint64_t k1; + } siphash; + /* a different (!) Py_hash_t for small string optimization */ + struct { + unsigned char padding[16]; + Py_hash_t suffix; + } djbx33a; + struct { + unsigned char padding[16]; + Py_hash_t hashsalt; + } expat; +} _Py_HashSecret_t; +PyAPI_DATA(_Py_HashSecret_t) _Py_HashSecret; + +#ifdef Py_DEBUG +PyAPI_DATA(int) _Py_HashSecret_Initialized; +#endif + + +/* hash function definition */ +typedef struct { + Py_hash_t (*const hash)(const void *, Py_ssize_t); + const char *name; + const int hash_bits; + const int seed_bits; +} PyHash_FuncDef; + +PyAPI_FUNC(PyHash_FuncDef*) PyHash_GetFuncDef(void); +#endif + + +/* cutoff for small string DJBX33A optimization in range [1, cutoff). + * + * About 50% of the strings in a typical Python application are smaller than + * 6 to 7 chars. However DJBX33A is vulnerable to hash collision attacks. + * NEVER use DJBX33A for long strings! + * + * A Py_HASH_CUTOFF of 0 disables small string optimization. 32 bit platforms + * should use a smaller cutoff because it is easier to create colliding + * strings. A cutoff of 7 on 64bit platforms and 5 on 32bit platforms should + * provide a decent safety margin. + */ +#ifndef Py_HASH_CUTOFF +# define Py_HASH_CUTOFF 0 +#elif (Py_HASH_CUTOFF > 7 || Py_HASH_CUTOFF < 0) +# error Py_HASH_CUTOFF must in range 0...7. +#endif /* Py_HASH_CUTOFF */ + + +/* hash algorithm selection + * + * The values for Py_HASH_* are hard-coded in the + * configure script. + * + * - FNV and SIPHASH* are available on all platforms and architectures. + * - With EXTERNAL embedders can provide an alternative implementation with:: + * + * PyHash_FuncDef PyHash_Func = {...}; + * + * XXX: Figure out __declspec() for extern PyHash_FuncDef. + */ +#define Py_HASH_EXTERNAL 0 +#define Py_HASH_SIPHASH24 1 +#define Py_HASH_FNV 2 +#define Py_HASH_SIPHASH13 3 + +#ifndef Py_HASH_ALGORITHM +# ifndef HAVE_ALIGNED_REQUIRED +# define Py_HASH_ALGORITHM Py_HASH_SIPHASH13 +# else +# define Py_HASH_ALGORITHM Py_HASH_FNV +# endif /* uint64_t && uint32_t && aligned */ +#endif /* Py_HASH_ALGORITHM */ + +#ifdef __cplusplus +} +#endif + +#endif /* !Py_HASH_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pylifecycle.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pylifecycle.h new file mode 100644 index 0000000000000000000000000000000000000000..e4c3b09c963fe8ae115247ad64d770ef81d072ee --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pylifecycle.h @@ -0,0 +1,78 @@ + +/* Interfaces to configure, query, create & destroy the Python runtime */ + +#ifndef Py_PYLIFECYCLE_H +#define Py_PYLIFECYCLE_H +#ifdef __cplusplus +extern "C" { +#endif + + +/* Initialization and finalization */ +PyAPI_FUNC(void) Py_Initialize(void); +PyAPI_FUNC(void) Py_InitializeEx(int); +PyAPI_FUNC(void) Py_Finalize(void); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000 +PyAPI_FUNC(int) Py_FinalizeEx(void); +#endif +PyAPI_FUNC(int) Py_IsInitialized(void); + +/* Subinterpreter support */ +PyAPI_FUNC(PyThreadState *) Py_NewInterpreter(void); +PyAPI_FUNC(void) Py_EndInterpreter(PyThreadState *); + + +/* Py_PyAtExit is for the atexit module, Py_AtExit is for low-level + * exit functions. + */ +PyAPI_FUNC(int) Py_AtExit(void (*func)(void)); + +PyAPI_FUNC(void) _Py_NO_RETURN Py_Exit(int); + +/* Bootstrap __main__ (defined in Modules/main.c) */ +PyAPI_FUNC(int) Py_Main(int argc, wchar_t **argv); +PyAPI_FUNC(int) Py_BytesMain(int argc, char **argv); + +/* In pathconfig.c */ +Py_DEPRECATED(3.11) PyAPI_FUNC(void) Py_SetProgramName(const wchar_t *); +PyAPI_FUNC(wchar_t *) Py_GetProgramName(void); + +Py_DEPRECATED(3.11) PyAPI_FUNC(void) Py_SetPythonHome(const wchar_t *); +PyAPI_FUNC(wchar_t *) Py_GetPythonHome(void); + +PyAPI_FUNC(wchar_t *) Py_GetProgramFullPath(void); + +PyAPI_FUNC(wchar_t *) Py_GetPrefix(void); +PyAPI_FUNC(wchar_t *) Py_GetExecPrefix(void); +PyAPI_FUNC(wchar_t *) Py_GetPath(void); +Py_DEPRECATED(3.11) PyAPI_FUNC(void) Py_SetPath(const wchar_t *); +#ifdef MS_WINDOWS +int _Py_CheckPython3(void); +#endif + +/* In their own files */ +PyAPI_FUNC(const char *) Py_GetVersion(void); +PyAPI_FUNC(const char *) Py_GetPlatform(void); +PyAPI_FUNC(const char *) Py_GetCopyright(void); +PyAPI_FUNC(const char *) Py_GetCompiler(void); +PyAPI_FUNC(const char *) Py_GetBuildInfo(void); + +/* Signals */ +typedef void (*PyOS_sighandler_t)(int); +PyAPI_FUNC(PyOS_sighandler_t) PyOS_getsig(int); +PyAPI_FUNC(PyOS_sighandler_t) PyOS_setsig(int, PyOS_sighandler_t); + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030B0000 +PyAPI_DATA(const unsigned long) Py_Version; +#endif + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_PYLIFECYCLE_H +# include "cpython/pylifecycle.h" +# undef Py_CPYTHON_PYLIFECYCLE_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_PYLIFECYCLE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pymacconfig.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pymacconfig.h new file mode 100644 index 0000000000000000000000000000000000000000..9dde11bd58e2171be78ecf4d3423b1b231ac17ec --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pymacconfig.h @@ -0,0 +1,102 @@ +#ifndef PYMACCONFIG_H +#define PYMACCONFIG_H + /* + * This file moves some of the autoconf magic to compile-time + * when building on MacOSX. This is needed for building 4-way + * universal binaries and for 64-bit universal binaries because + * the values redefined below aren't configure-time constant but + * only compile-time constant in these scenarios. + */ + +#if defined(__APPLE__) + +# undef SIZEOF_LONG +# undef SIZEOF_PTHREAD_T +# undef SIZEOF_SIZE_T +# undef SIZEOF_TIME_T +# undef SIZEOF_VOID_P +# undef SIZEOF__BOOL +# undef SIZEOF_UINTPTR_T +# undef SIZEOF_PTHREAD_T +# undef WORDS_BIGENDIAN +# undef DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754 +# undef DOUBLE_IS_BIG_ENDIAN_IEEE754 +# undef DOUBLE_IS_LITTLE_ENDIAN_IEEE754 +# undef HAVE_GCC_ASM_FOR_X87 + +# undef VA_LIST_IS_ARRAY +# if defined(__LP64__) && defined(__x86_64__) +# define VA_LIST_IS_ARRAY 1 +# endif + +# undef HAVE_LARGEFILE_SUPPORT +# ifndef __LP64__ +# define HAVE_LARGEFILE_SUPPORT 1 +# endif + +# undef SIZEOF_LONG +# ifdef __LP64__ +# define SIZEOF__BOOL 1 +# define SIZEOF__BOOL 1 +# define SIZEOF_LONG 8 +# define SIZEOF_PTHREAD_T 8 +# define SIZEOF_SIZE_T 8 +# define SIZEOF_TIME_T 8 +# define SIZEOF_VOID_P 8 +# define SIZEOF_UINTPTR_T 8 +# define SIZEOF_PTHREAD_T 8 +# else +# ifdef __ppc__ +# define SIZEOF__BOOL 4 +# else +# define SIZEOF__BOOL 1 +# endif +# define SIZEOF_LONG 4 +# define SIZEOF_PTHREAD_T 4 +# define SIZEOF_SIZE_T 4 +# define SIZEOF_TIME_T 4 +# define SIZEOF_VOID_P 4 +# define SIZEOF_UINTPTR_T 4 +# define SIZEOF_PTHREAD_T 4 +# endif + +# if defined(__LP64__) + /* MacOSX 10.4 (the first release to support 64-bit code + * at all) only supports 64-bit in the UNIX layer. + * Therefore suppress the toolbox-glue in 64-bit mode. + */ + + /* In 64-bit mode setpgrp always has no arguments, in 32-bit + * mode that depends on the compilation environment + */ +# undef SETPGRP_HAVE_ARG + +# endif + +#ifdef __BIG_ENDIAN__ +#define WORDS_BIGENDIAN 1 +#define DOUBLE_IS_BIG_ENDIAN_IEEE754 +#else +#define DOUBLE_IS_LITTLE_ENDIAN_IEEE754 +#endif /* __BIG_ENDIAN */ + +#ifdef __i386__ +# define HAVE_GCC_ASM_FOR_X87 +#endif + + /* + * The definition in pyconfig.h is only valid on the OS release + * where configure ran on and not necessarily for all systems where + * the executable can be used on. + * + * Specifically: OSX 10.4 has limited supported for '%zd', while + * 10.5 has full support for '%zd'. A binary built on 10.5 won't + * work properly on 10.4 unless we suppress the definition + * of PY_FORMAT_SIZE_T + */ +#undef PY_FORMAT_SIZE_T + + +#endif /* defined(_APPLE__) */ + +#endif /* PYMACCONFIG_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pymacro.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pymacro.h new file mode 100644 index 0000000000000000000000000000000000000000..5840966b5f8dc93019876f05777804c872053878 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pymacro.h @@ -0,0 +1,158 @@ +#ifndef Py_PYMACRO_H +#define Py_PYMACRO_H + +// gh-91782: On FreeBSD 12, if the _POSIX_C_SOURCE and _XOPEN_SOURCE macros are +// defined, disables C11 support and does not define +// the static_assert() macro. +// https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=255290 +// +// macOS <= 10.10 doesn't define static_assert in assert.h at all despite +// having C11 compiler support. +// +// static_assert is defined in glibc from version 2.16. Compiler support for +// the C11 _Static_assert keyword is in gcc >= 4.6. +// +// MSVC makes static_assert a keyword in C11-17, contrary to the standards. +// +// In C++11 and C2x, static_assert is a keyword, redefining is undefined +// behaviour. So only define if building as C (if __STDC_VERSION__ is defined), +// not C++, and only for C11-17. +#if !defined(static_assert) && (defined(__GNUC__) || defined(__clang__)) \ + && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L \ + && __STDC_VERSION__ <= 201710L +# define static_assert _Static_assert +#endif + +/* Minimum value between x and y */ +#define Py_MIN(x, y) (((x) > (y)) ? (y) : (x)) + +/* Maximum value between x and y */ +#define Py_MAX(x, y) (((x) > (y)) ? (x) : (y)) + +/* Absolute value of the number x */ +#define Py_ABS(x) ((x) < 0 ? -(x) : (x)) + +#define _Py_XSTRINGIFY(x) #x + +/* Convert the argument to a string. For example, Py_STRINGIFY(123) is replaced + with "123" by the preprocessor. Defines are also replaced by their value. + For example Py_STRINGIFY(__LINE__) is replaced by the line number, not + by "__LINE__". */ +#define Py_STRINGIFY(x) _Py_XSTRINGIFY(x) + +/* Get the size of a structure member in bytes */ +#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) + +/* Argument must be a char or an int in [-128, 127] or [0, 255]. */ +#define Py_CHARMASK(c) ((unsigned char)((c) & 0xff)) + +/* Assert a build-time dependency, as an expression. + + Your compile will fail if the condition isn't true, or can't be evaluated + by the compiler. This can be used in an expression: its value is 0. + + Example: + + #define foo_to_char(foo) \ + ((char *)(foo) \ + + Py_BUILD_ASSERT_EXPR(offsetof(struct foo, string) == 0)) + + Written by Rusty Russell, public domain, http://ccodearchive.net/ */ +#define Py_BUILD_ASSERT_EXPR(cond) \ + (sizeof(char [1 - 2*!(cond)]) - 1) + +#define Py_BUILD_ASSERT(cond) do { \ + (void)Py_BUILD_ASSERT_EXPR(cond); \ + } while(0) + +/* Get the number of elements in a visible array + + This does not work on pointers, or arrays declared as [], or function + parameters. With correct compiler support, such usage will cause a build + error (see Py_BUILD_ASSERT_EXPR). + + Written by Rusty Russell, public domain, http://ccodearchive.net/ + + Requires at GCC 3.1+ */ +#if (defined(__GNUC__) && !defined(__STRICT_ANSI__) && \ + (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1)) || (__GNUC__ >= 4))) +/* Two gcc extensions. + &a[0] degrades to a pointer: a different type from an array */ +#define Py_ARRAY_LENGTH(array) \ + (sizeof(array) / sizeof((array)[0]) \ + + Py_BUILD_ASSERT_EXPR(!__builtin_types_compatible_p(typeof(array), \ + typeof(&(array)[0])))) +#else +#define Py_ARRAY_LENGTH(array) \ + (sizeof(array) / sizeof((array)[0])) +#endif + + +/* Define macros for inline documentation. */ +#define PyDoc_VAR(name) static const char name[] +#define PyDoc_STRVAR(name,str) PyDoc_VAR(name) = PyDoc_STR(str) +#ifdef WITH_DOC_STRINGS +#define PyDoc_STR(str) str +#else +#define PyDoc_STR(str) "" +#endif + +/* Below "a" is a power of 2. */ +/* Round down size "n" to be a multiple of "a". */ +#define _Py_SIZE_ROUND_DOWN(n, a) ((size_t)(n) & ~(size_t)((a) - 1)) +/* Round up size "n" to be a multiple of "a". */ +#define _Py_SIZE_ROUND_UP(n, a) (((size_t)(n) + \ + (size_t)((a) - 1)) & ~(size_t)((a) - 1)) +/* Round pointer "p" down to the closest "a"-aligned address <= "p". */ +#define _Py_ALIGN_DOWN(p, a) ((void *)((uintptr_t)(p) & ~(uintptr_t)((a) - 1))) +/* Round pointer "p" up to the closest "a"-aligned address >= "p". */ +#define _Py_ALIGN_UP(p, a) ((void *)(((uintptr_t)(p) + \ + (uintptr_t)((a) - 1)) & ~(uintptr_t)((a) - 1))) +/* Check if pointer "p" is aligned to "a"-bytes boundary. */ +#define _Py_IS_ALIGNED(p, a) (!((uintptr_t)(p) & (uintptr_t)((a) - 1))) + +/* Use this for unused arguments in a function definition to silence compiler + * warnings. Example: + * + * int func(int a, int Py_UNUSED(b)) { return a; } + */ +#if defined(__GNUC__) || defined(__clang__) +# define Py_UNUSED(name) _unused_ ## name __attribute__((unused)) +#else +# define Py_UNUSED(name) _unused_ ## name +#endif + +#if defined(RANDALL_WAS_HERE) +# define Py_UNREACHABLE() \ + Py_FatalError( \ + "If you're seeing this, the code is in what I thought was\n" \ + "an unreachable state.\n\n" \ + "I could give you advice for what to do, but honestly, why\n" \ + "should you trust me? I clearly screwed this up. I'm writing\n" \ + "a message that should never appear, yet I know it will\n" \ + "probably appear someday.\n\n" \ + "On a deep level, I know I'm not up to this task.\n" \ + "I'm so sorry.\n" \ + "https://xkcd.com/2200") +#elif defined(Py_DEBUG) +# define Py_UNREACHABLE() \ + Py_FatalError( \ + "We've reached an unreachable state. Anything is possible.\n" \ + "The limits were in our heads all along. Follow your dreams.\n" \ + "https://xkcd.com/2200") +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)) +# define Py_UNREACHABLE() __builtin_unreachable() +#elif defined(__clang__) || defined(__INTEL_COMPILER) +# define Py_UNREACHABLE() __builtin_unreachable() +#elif defined(_MSC_VER) +# define Py_UNREACHABLE() __assume(0) +#else +# define Py_UNREACHABLE() \ + Py_FatalError("Unreachable C code path reached") +#endif + +// Prevent using an expression as a l-value. +// For example, "int x; _Py_RVALUE(x) = 1;" fails with a compiler error. +#define _Py_RVALUE(EXPR) ((void)0, (EXPR)) + +#endif /* Py_PYMACRO_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pymath.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pymath.h new file mode 100644 index 0000000000000000000000000000000000000000..772b67e4977563e6539af86e66ebd5456431843b --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pymath.h @@ -0,0 +1,65 @@ +// Symbols and macros to supply platform-independent interfaces to mathematical +// functions and constants. + +#ifndef Py_PYMATH_H +#define Py_PYMATH_H + +/* High precision definition of pi and e (Euler) + * The values are taken from libc6's math.h. + */ +#ifndef Py_MATH_PIl +#define Py_MATH_PIl 3.1415926535897932384626433832795029L +#endif +#ifndef Py_MATH_PI +#define Py_MATH_PI 3.14159265358979323846 +#endif + +#ifndef Py_MATH_El +#define Py_MATH_El 2.7182818284590452353602874713526625L +#endif + +#ifndef Py_MATH_E +#define Py_MATH_E 2.7182818284590452354 +#endif + +/* Tau (2pi) to 40 digits, taken from tauday.com/tau-digits. */ +#ifndef Py_MATH_TAU +#define Py_MATH_TAU 6.2831853071795864769252867665590057683943L +#endif + +// Py_IS_NAN(X) +// Return 1 if float or double arg is a NaN, else 0. +#define Py_IS_NAN(X) isnan(X) + +// Py_IS_INFINITY(X) +// Return 1 if float or double arg is an infinity, else 0. +#define Py_IS_INFINITY(X) isinf(X) + +// Py_IS_FINITE(X) +// Return 1 if float or double arg is neither infinite nor NAN, else 0. +#define Py_IS_FINITE(X) isfinite(X) + +/* HUGE_VAL is supposed to expand to a positive double infinity. Python + * uses Py_HUGE_VAL instead because some platforms are broken in this + * respect. We used to embed code in pyport.h to try to worm around that, + * but different platforms are broken in conflicting ways. If you're on + * a platform where HUGE_VAL is defined incorrectly, fiddle your Python + * config to #define Py_HUGE_VAL to something that works on your platform. + */ +#ifndef Py_HUGE_VAL +# define Py_HUGE_VAL HUGE_VAL +#endif + +// Py_NAN: Value that evaluates to a quiet Not-a-Number (NaN). +#if !defined(Py_NAN) +# if _Py__has_builtin(__builtin_nan) + // Built-in implementation of the ISO C99 function nan(): quiet NaN. +# define Py_NAN (__builtin_nan("")) +#else + // Use C99 NAN constant: quiet Not-A-Number. + // NAN is a float, Py_NAN is a double: cast to double. +# define Py_NAN ((double)NAN) +# endif +#endif + +#endif /* Py_PYMATH_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pymem.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pymem.h new file mode 100644 index 0000000000000000000000000000000000000000..c15ad10dfcf831acc4f1b7a54c7cae683dceafde --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pymem.h @@ -0,0 +1,104 @@ +/* The PyMem_ family: low-level memory allocation interfaces. + See objimpl.h for the PyObject_ memory family. +*/ + +#ifndef Py_PYMEM_H +#define Py_PYMEM_H + +#include "pyport.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* BEWARE: + + Each interface exports both functions and macros. Extension modules should + use the functions, to ensure binary compatibility across Python versions. + Because the Python implementation is free to change internal details, and + the macros may (or may not) expose details for speed, if you do use the + macros you must recompile your extensions with each Python release. + + Never mix calls to PyMem_ with calls to the platform malloc/realloc/ + calloc/free. For example, on Windows different DLLs may end up using + different heaps, and if you use PyMem_Malloc you'll get the memory from the + heap used by the Python DLL; it could be a disaster if you free()'ed that + directly in your own extension. Using PyMem_Free instead ensures Python + can return the memory to the proper heap. As another example, in + a debug build (Py_DEBUG macro), Python wraps all calls to all PyMem_ and + PyObject_ memory functions in special debugging wrappers that add additional + debugging info to dynamic memory blocks. The system routines have no idea + what to do with that stuff, and the Python wrappers have no idea what to do + with raw blocks obtained directly by the system routines then. + + The GIL must be held when using these APIs. +*/ + +/* + * Raw memory interface + * ==================== + */ + +/* Functions + + Functions supplying platform-independent semantics for malloc/realloc/ + free. These functions make sure that allocating 0 bytes returns a distinct + non-NULL pointer (whenever possible -- if we're flat out of memory, NULL + may be returned), even if the platform malloc and realloc don't. + Returned pointers must be checked for NULL explicitly. No action is + performed on failure (no exception is set, no warning is printed, etc). +*/ + +PyAPI_FUNC(void *) PyMem_Malloc(size_t size); +PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize); +PyAPI_FUNC(void *) PyMem_Realloc(void *ptr, size_t new_size); +PyAPI_FUNC(void) PyMem_Free(void *ptr); + +/* + * Type-oriented memory interface + * ============================== + * + * Allocate memory for n objects of the given type. Returns a new pointer + * or NULL if the request was too large or memory allocation failed. Use + * these macros rather than doing the multiplication yourself so that proper + * overflow checking is always done. + */ + +#define PyMem_New(type, n) \ + ( ((size_t)(n) > PY_SSIZE_T_MAX / sizeof(type)) ? NULL : \ + ( (type *) PyMem_Malloc((n) * sizeof(type)) ) ) + +/* + * The value of (p) is always clobbered by this macro regardless of success. + * The caller MUST check if (p) is NULL afterwards and deal with the memory + * error if so. This means the original value of (p) MUST be saved for the + * caller's memory error handler to not lose track of it. + */ +#define PyMem_Resize(p, type, n) \ + ( (p) = ((size_t)(n) > PY_SSIZE_T_MAX / sizeof(type)) ? NULL : \ + (type *) PyMem_Realloc((p), (n) * sizeof(type)) ) + + +// Deprecated aliases only kept for backward compatibility. +// PyMem_Del and PyMem_DEL are defined with no parameter to be able to use +// them as function pointers (ex: dealloc = PyMem_Del). +#define PyMem_MALLOC(n) PyMem_Malloc(n) +#define PyMem_NEW(type, n) PyMem_New(type, n) +#define PyMem_REALLOC(p, n) PyMem_Realloc(p, n) +#define PyMem_RESIZE(p, type, n) PyMem_Resize(p, type, n) +#define PyMem_FREE(p) PyMem_Free(p) +#define PyMem_Del PyMem_Free +#define PyMem_DEL PyMem_Free + + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_PYMEM_H +# include "cpython/pymem.h" +# undef Py_CPYTHON_PYMEM_H +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* !Py_PYMEM_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pyport.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pyport.h new file mode 100644 index 0000000000000000000000000000000000000000..b3b8b6f09af3f0b235580b94f361964fa08e41d1 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pyport.h @@ -0,0 +1,737 @@ +#ifndef Py_PYPORT_H +#define Py_PYPORT_H + +#include "pyconfig.h" /* include for defines */ + +#include + +#include +#ifndef UCHAR_MAX +# error "limits.h must define UCHAR_MAX" +#endif +#if UCHAR_MAX != 255 +# error "Python's source code assumes C's unsigned char is an 8-bit type" +#endif + + +// Macro to use C++ static_cast<> in the Python C API. +#ifdef __cplusplus +# define _Py_STATIC_CAST(type, expr) static_cast(expr) +#else +# define _Py_STATIC_CAST(type, expr) ((type)(expr)) +#endif +// Macro to use the more powerful/dangerous C-style cast even in C++. +#define _Py_CAST(type, expr) ((type)(expr)) + +// Static inline functions should use _Py_NULL rather than using directly NULL +// to prevent C++ compiler warnings. On C++11 and newer, _Py_NULL is defined as +// nullptr. +#if defined(__cplusplus) && __cplusplus >= 201103 +# define _Py_NULL nullptr +#else +# define _Py_NULL NULL +#endif + + +/* Defines to build Python and its standard library: + * + * - Py_BUILD_CORE: Build Python core. Give access to Python internals, but + * should not be used by third-party modules. + * - Py_BUILD_CORE_BUILTIN: Build a Python stdlib module as a built-in module. + * - Py_BUILD_CORE_MODULE: Build a Python stdlib module as a dynamic library. + * + * Py_BUILD_CORE_BUILTIN and Py_BUILD_CORE_MODULE imply Py_BUILD_CORE. + * + * On Windows, Py_BUILD_CORE_MODULE exports "PyInit_xxx" symbol, whereas + * Py_BUILD_CORE_BUILTIN does not. + */ +#if defined(Py_BUILD_CORE_BUILTIN) && !defined(Py_BUILD_CORE) +# define Py_BUILD_CORE +#endif +#if defined(Py_BUILD_CORE_MODULE) && !defined(Py_BUILD_CORE) +# define Py_BUILD_CORE +#endif + + +/************************************************************************** +Symbols and macros to supply platform-independent interfaces to basic +C language & library operations whose spellings vary across platforms. + +Please try to make documentation here as clear as possible: by definition, +the stuff here is trying to illuminate C's darkest corners. + +Config #defines referenced here: + +SIGNED_RIGHT_SHIFT_ZERO_FILLS +Meaning: To be defined iff i>>j does not extend the sign bit when i is a + signed integral type and i < 0. +Used in: Py_ARITHMETIC_RIGHT_SHIFT + +Py_DEBUG +Meaning: Extra checks compiled in for debug mode. +Used in: Py_SAFE_DOWNCAST + +**************************************************************************/ + +/* typedefs for some C9X-defined synonyms for integral types. + * + * The names in Python are exactly the same as the C9X names, except with a + * Py_ prefix. Until C9X is universally implemented, this is the only way + * to ensure that Python gets reliable names that don't conflict with names + * in non-Python code that are playing their own tricks to define the C9X + * names. + * + * NOTE: don't go nuts here! Python has no use for *most* of the C9X + * integral synonyms. Only define the ones we actually need. + */ + +/* long long is required. Ensure HAVE_LONG_LONG is defined for compatibility. */ +#ifndef HAVE_LONG_LONG +#define HAVE_LONG_LONG 1 +#endif +#ifndef PY_LONG_LONG +#define PY_LONG_LONG long long +/* If LLONG_MAX is defined in limits.h, use that. */ +#define PY_LLONG_MIN LLONG_MIN +#define PY_LLONG_MAX LLONG_MAX +#define PY_ULLONG_MAX ULLONG_MAX +#endif + +#define PY_UINT32_T uint32_t +#define PY_UINT64_T uint64_t + +/* Signed variants of the above */ +#define PY_INT32_T int32_t +#define PY_INT64_T int64_t + +/* PYLONG_BITS_IN_DIGIT describes the number of bits per "digit" (limb) in the + * PyLongObject implementation (longintrepr.h). It's currently either 30 or 15, + * defaulting to 30. The 15-bit digit option may be removed in the future. + */ +#ifndef PYLONG_BITS_IN_DIGIT +#define PYLONG_BITS_IN_DIGIT 30 +#endif + +/* uintptr_t is the C9X name for an unsigned integral type such that a + * legitimate void* can be cast to uintptr_t and then back to void* again + * without loss of information. Similarly for intptr_t, wrt a signed + * integral type. + */ +typedef uintptr_t Py_uintptr_t; +typedef intptr_t Py_intptr_t; + +/* Py_ssize_t is a signed integral type such that sizeof(Py_ssize_t) == + * sizeof(size_t). C99 doesn't define such a thing directly (size_t is an + * unsigned integral type). See PEP 353 for details. + * PY_SSIZE_T_MAX is the largest positive value of type Py_ssize_t. + */ +#ifdef HAVE_PY_SSIZE_T + +#elif HAVE_SSIZE_T +typedef ssize_t Py_ssize_t; +# define PY_SSIZE_T_MAX SSIZE_MAX +#elif SIZEOF_VOID_P == SIZEOF_SIZE_T +typedef Py_intptr_t Py_ssize_t; +# define PY_SSIZE_T_MAX INTPTR_MAX +#else +# error "Python needs a typedef for Py_ssize_t in pyport.h." +#endif + +/* Smallest negative value of type Py_ssize_t. */ +#define PY_SSIZE_T_MIN (-PY_SSIZE_T_MAX-1) + +/* Py_hash_t is the same size as a pointer. */ +#define SIZEOF_PY_HASH_T SIZEOF_SIZE_T +typedef Py_ssize_t Py_hash_t; +/* Py_uhash_t is the unsigned equivalent needed to calculate numeric hash. */ +#define SIZEOF_PY_UHASH_T SIZEOF_SIZE_T +typedef size_t Py_uhash_t; + +/* Now PY_SSIZE_T_CLEAN is mandatory. This is just for backward compatibility. */ +typedef Py_ssize_t Py_ssize_clean_t; + +/* Largest possible value of size_t. */ +#define PY_SIZE_MAX SIZE_MAX + +/* Macro kept for backward compatibility: use "z" in new code. + * + * PY_FORMAT_SIZE_T is a platform-specific modifier for use in a printf + * format to convert an argument with the width of a size_t or Py_ssize_t. + * C99 introduced "z" for this purpose, but old MSVCs had not supported it. + * Since MSVC supports "z" since (at least) 2015, we can just use "z" + * for new code. + * + * These "high level" Python format functions interpret "z" correctly on + * all platforms (Python interprets the format string itself, and does whatever + * the platform C requires to convert a size_t/Py_ssize_t argument): + * + * PyBytes_FromFormat + * PyErr_Format + * PyBytes_FromFormatV + * PyUnicode_FromFormatV + * + * Lower-level uses require that you interpolate the correct format modifier + * yourself (e.g., calling printf, fprintf, sprintf, PyOS_snprintf); for + * example, + * + * Py_ssize_t index; + * fprintf(stderr, "index %" PY_FORMAT_SIZE_T "d sucks\n", index); + * + * That will expand to %zd or to something else correct for a Py_ssize_t on + * the platform. + */ +#ifndef PY_FORMAT_SIZE_T +# define PY_FORMAT_SIZE_T "z" +#endif + +/* Py_LOCAL can be used instead of static to get the fastest possible calling + * convention for functions that are local to a given module. + * + * Py_LOCAL_INLINE does the same thing, and also explicitly requests inlining, + * for platforms that support that. + * + * NOTE: You can only use this for functions that are entirely local to a + * module; functions that are exported via method tables, callbacks, etc, + * should keep using static. + */ + +#if defined(_MSC_VER) + /* ignore warnings if the compiler decides not to inline a function */ +# pragma warning(disable: 4710) + /* fastest possible local call under MSVC */ +# define Py_LOCAL(type) static type __fastcall +# define Py_LOCAL_INLINE(type) static __inline type __fastcall +#else +# define Py_LOCAL(type) static type +# define Py_LOCAL_INLINE(type) static inline type +#endif + +// bpo-28126: Py_MEMCPY is kept for backwards compatibility, +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000 +# define Py_MEMCPY memcpy +#endif + +#ifdef HAVE_IEEEFP_H +#include /* needed for 'finite' declaration on some platforms */ +#endif + +#include /* Moved here from the math section, before extern "C" */ + +/******************************************** + * WRAPPER FOR and/or * + ********************************************/ + +#ifdef HAVE_SYS_TIME_H +#include +#endif +#include + +/****************************** + * WRAPPER FOR * + ******************************/ + +/* NB caller must include */ + +#ifdef HAVE_SYS_SELECT_H +#include +#endif /* !HAVE_SYS_SELECT_H */ + +/******************************* + * stat() and fstat() fiddling * + *******************************/ + +#ifdef HAVE_SYS_STAT_H +#include +#elif defined(HAVE_STAT_H) +#include +#endif + +#ifndef S_IFMT +/* VisualAge C/C++ Failed to Define MountType Field in sys/stat.h */ +#define S_IFMT 0170000 +#endif + +#ifndef S_IFLNK +/* Windows doesn't define S_IFLNK but posixmodule.c maps + * IO_REPARSE_TAG_SYMLINK to S_IFLNK */ +# define S_IFLNK 0120000 +#endif + +#ifndef S_ISREG +#define S_ISREG(x) (((x) & S_IFMT) == S_IFREG) +#endif + +#ifndef S_ISDIR +#define S_ISDIR(x) (((x) & S_IFMT) == S_IFDIR) +#endif + +#ifndef S_ISCHR +#define S_ISCHR(x) (((x) & S_IFMT) == S_IFCHR) +#endif + +#ifdef __cplusplus +/* Move this down here since some C++ #include's don't like to be included + inside an extern "C" */ +extern "C" { +#endif + + +/* Py_ARITHMETIC_RIGHT_SHIFT + * C doesn't define whether a right-shift of a signed integer sign-extends + * or zero-fills. Here a macro to force sign extension: + * Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) + * Return I >> J, forcing sign extension. Arithmetically, return the + * floor of I/2**J. + * Requirements: + * I should have signed integer type. In the terminology of C99, this can + * be either one of the five standard signed integer types (signed char, + * short, int, long, long long) or an extended signed integer type. + * J is an integer >= 0 and strictly less than the number of bits in the + * type of I (because C doesn't define what happens for J outside that + * range either). + * TYPE used to specify the type of I, but is now ignored. It's been left + * in for backwards compatibility with versions <= 2.6 or 3.0. + * Caution: + * I may be evaluated more than once. + */ +#ifdef SIGNED_RIGHT_SHIFT_ZERO_FILLS +#define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) \ + ((I) < 0 ? -1-((-1-(I)) >> (J)) : (I) >> (J)) +#else +#define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) ((I) >> (J)) +#endif + +/* Py_FORCE_EXPANSION(X) + * "Simply" returns its argument. However, macro expansions within the + * argument are evaluated. This unfortunate trickery is needed to get + * token-pasting to work as desired in some cases. + */ +#define Py_FORCE_EXPANSION(X) X + +/* Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) + * Cast VALUE to type NARROW from type WIDE. In Py_DEBUG mode, this + * assert-fails if any information is lost. + * Caution: + * VALUE may be evaluated more than once. + */ +#ifdef Py_DEBUG +# define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) \ + (assert(_Py_STATIC_CAST(WIDE, _Py_STATIC_CAST(NARROW, (VALUE))) == (VALUE)), \ + _Py_STATIC_CAST(NARROW, (VALUE))) +#else +# define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) _Py_STATIC_CAST(NARROW, (VALUE)) +#endif + + +/* Py_DEPRECATED(version) + * Declare a variable, type, or function deprecated. + * The macro must be placed before the declaration. + * Usage: + * Py_DEPRECATED(3.3) extern int old_var; + * Py_DEPRECATED(3.4) typedef int T1; + * Py_DEPRECATED(3.8) PyAPI_FUNC(int) Py_OldFunction(void); + */ +#if defined(__GNUC__) \ + && ((__GNUC__ >= 4) || (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1)) +#define Py_DEPRECATED(VERSION_UNUSED) __attribute__((__deprecated__)) +#elif defined(_MSC_VER) +#define Py_DEPRECATED(VERSION) __declspec(deprecated( \ + "deprecated in " #VERSION)) +#else +#define Py_DEPRECATED(VERSION_UNUSED) +#endif + +#if defined(__clang__) +#define _Py_COMP_DIAG_PUSH _Pragma("clang diagnostic push") +#define _Py_COMP_DIAG_IGNORE_DEPR_DECLS \ + _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") +#define _Py_COMP_DIAG_POP _Pragma("clang diagnostic pop") +#elif defined(__GNUC__) \ + && ((__GNUC__ >= 5) || (__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) +#define _Py_COMP_DIAG_PUSH _Pragma("GCC diagnostic push") +#define _Py_COMP_DIAG_IGNORE_DEPR_DECLS \ + _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#define _Py_COMP_DIAG_POP _Pragma("GCC diagnostic pop") +#elif defined(_MSC_VER) +#define _Py_COMP_DIAG_PUSH __pragma(warning(push)) +#define _Py_COMP_DIAG_IGNORE_DEPR_DECLS __pragma(warning(disable: 4996)) +#define _Py_COMP_DIAG_POP __pragma(warning(pop)) +#else +#define _Py_COMP_DIAG_PUSH +#define _Py_COMP_DIAG_IGNORE_DEPR_DECLS +#define _Py_COMP_DIAG_POP +#endif + +/* _Py_HOT_FUNCTION + * The hot attribute on a function is used to inform the compiler that the + * function is a hot spot of the compiled program. The function is optimized + * more aggressively and on many target it is placed into special subsection of + * the text section so all hot functions appears close together improving + * locality. + * + * Usage: + * int _Py_HOT_FUNCTION x(void) { return 3; } + * + * Issue #28618: This attribute must not be abused, otherwise it can have a + * negative effect on performance. Only the functions were Python spend most of + * its time must use it. Use a profiler when running performance benchmark + * suite to find these functions. + */ +#if defined(__GNUC__) \ + && ((__GNUC__ >= 5) || (__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) +#define _Py_HOT_FUNCTION __attribute__((hot)) +#else +#define _Py_HOT_FUNCTION +#endif + +// Ask the compiler to always inline a static inline function. The compiler can +// ignore it and decides to not inline the function. +// +// It can be used to inline performance critical static inline functions when +// building Python in debug mode with function inlining disabled. For example, +// MSC disables function inlining when building in debug mode. +// +// Marking blindly a static inline function with Py_ALWAYS_INLINE can result in +// worse performances (due to increased code size for example). The compiler is +// usually smarter than the developer for the cost/benefit analysis. +// +// If Python is built in debug mode (if the Py_DEBUG macro is defined), the +// Py_ALWAYS_INLINE macro does nothing. +// +// It must be specified before the function return type. Usage: +// +// static inline Py_ALWAYS_INLINE int random(void) { return 4; } +#if defined(Py_DEBUG) + // If Python is built in debug mode, usually compiler optimizations are + // disabled. In this case, Py_ALWAYS_INLINE can increase a lot the stack + // memory usage. For example, forcing inlining using gcc -O0 increases the + // stack usage from 6 KB to 15 KB per Python function call. +# define Py_ALWAYS_INLINE +#elif defined(__GNUC__) || defined(__clang__) || defined(__INTEL_COMPILER) +# define Py_ALWAYS_INLINE __attribute__((always_inline)) +#elif defined(_MSC_VER) +# define Py_ALWAYS_INLINE __forceinline +#else +# define Py_ALWAYS_INLINE +#endif + +// Py_NO_INLINE +// Disable inlining on a function. For example, it reduces the C stack +// consumption: useful on LTO+PGO builds which heavily inline code (see +// bpo-33720). +// +// Usage: +// +// Py_NO_INLINE static int random(void) { return 4; } +#if defined(__GNUC__) || defined(__clang__) || defined(__INTEL_COMPILER) +# define Py_NO_INLINE __attribute__ ((noinline)) +#elif defined(_MSC_VER) +# define Py_NO_INLINE __declspec(noinline) +#else +# define Py_NO_INLINE +#endif + +/************************************************************************** +Prototypes that are missing from the standard include files on some systems +(and possibly only some versions of such systems.) + +Please be conservative with adding new ones, document them and enclose them +in platform-specific #ifdefs. +**************************************************************************/ + +#ifdef HAVE__GETPTY +#include /* we need to import mode_t */ +extern char * _getpty(int *, int, mode_t, int); +#endif + +/* On QNX 6, struct termio must be declared by including sys/termio.h + if TCGETA, TCSETA, TCSETAW, or TCSETAF are used. sys/termio.h must + be included before termios.h or it will generate an error. */ +#if defined(HAVE_SYS_TERMIO_H) && !defined(__hpux) +#include +#endif + + +/* On 4.4BSD-descendants, ctype functions serves the whole range of + * wchar_t character set rather than single byte code points only. + * This characteristic can break some operations of string object + * including str.upper() and str.split() on UTF-8 locales. This + * workaround was provided by Tim Robbins of FreeBSD project. + */ + +#if defined(__APPLE__) +# define _PY_PORT_CTYPE_UTF8_ISSUE +#endif + +#ifdef _PY_PORT_CTYPE_UTF8_ISSUE +#ifndef __cplusplus + /* The workaround below is unsafe in C++ because + * the defines these symbols as real functions, + * with a slightly different signature. + * See issue #10910 + */ +#include +#include +#undef isalnum +#define isalnum(c) iswalnum(btowc(c)) +#undef isalpha +#define isalpha(c) iswalpha(btowc(c)) +#undef islower +#define islower(c) iswlower(btowc(c)) +#undef isspace +#define isspace(c) iswspace(btowc(c)) +#undef isupper +#define isupper(c) iswupper(btowc(c)) +#undef tolower +#define tolower(c) towlower(btowc(c)) +#undef toupper +#define toupper(c) towupper(btowc(c)) +#endif +#endif + + +/* Declarations for symbol visibility. + + PyAPI_FUNC(type): Declares a public Python API function and return type + PyAPI_DATA(type): Declares public Python data and its type + PyMODINIT_FUNC: A Python module init function. If these functions are + inside the Python core, they are private to the core. + If in an extension module, it may be declared with + external linkage depending on the platform. + + As a number of platforms support/require "__declspec(dllimport/dllexport)", + we support a HAVE_DECLSPEC_DLL macro to save duplication. +*/ + +/* + All windows ports, except cygwin, are handled in PC/pyconfig.h. + + Cygwin is the only other autoconf platform requiring special + linkage handling and it uses __declspec(). +*/ +#if defined(__CYGWIN__) +# define HAVE_DECLSPEC_DLL +#endif + +#include "exports.h" + +/* only get special linkage if built as shared or platform is Cygwin */ +#if defined(Py_ENABLE_SHARED) || defined(__CYGWIN__) +# if defined(HAVE_DECLSPEC_DLL) +# if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE) +# define PyAPI_FUNC(RTYPE) Py_EXPORTED_SYMBOL RTYPE +# define PyAPI_DATA(RTYPE) extern Py_EXPORTED_SYMBOL RTYPE + /* module init functions inside the core need no external linkage */ + /* except for Cygwin to handle embedding */ +# if defined(__CYGWIN__) +# define PyMODINIT_FUNC Py_EXPORTED_SYMBOL PyObject* +# else /* __CYGWIN__ */ +# define PyMODINIT_FUNC PyObject* +# endif /* __CYGWIN__ */ +# else /* Py_BUILD_CORE */ + /* Building an extension module, or an embedded situation */ + /* public Python functions and data are imported */ + /* Under Cygwin, auto-import functions to prevent compilation */ + /* failures similar to those described at the bottom of 4.1: */ + /* http://docs.python.org/extending/windows.html#a-cookbook-approach */ +# if !defined(__CYGWIN__) +# define PyAPI_FUNC(RTYPE) Py_IMPORTED_SYMBOL RTYPE +# endif /* !__CYGWIN__ */ +# define PyAPI_DATA(RTYPE) extern Py_IMPORTED_SYMBOL RTYPE + /* module init functions outside the core must be exported */ +# if defined(__cplusplus) +# define PyMODINIT_FUNC extern "C" Py_EXPORTED_SYMBOL PyObject* +# else /* __cplusplus */ +# define PyMODINIT_FUNC Py_EXPORTED_SYMBOL PyObject* +# endif /* __cplusplus */ +# endif /* Py_BUILD_CORE */ +# endif /* HAVE_DECLSPEC_DLL */ +#endif /* Py_ENABLE_SHARED */ + +/* If no external linkage macros defined by now, create defaults */ +#ifndef PyAPI_FUNC +# define PyAPI_FUNC(RTYPE) Py_EXPORTED_SYMBOL RTYPE +#endif +#ifndef PyAPI_DATA +# define PyAPI_DATA(RTYPE) extern Py_EXPORTED_SYMBOL RTYPE +#endif +#ifndef PyMODINIT_FUNC +# if defined(__cplusplus) +# define PyMODINIT_FUNC extern "C" Py_EXPORTED_SYMBOL PyObject* +# else /* __cplusplus */ +# define PyMODINIT_FUNC Py_EXPORTED_SYMBOL PyObject* +# endif /* __cplusplus */ +#endif + +/* limits.h constants that may be missing */ + +#ifndef INT_MAX +#define INT_MAX 2147483647 +#endif + +#ifndef LONG_MAX +#if SIZEOF_LONG == 4 +#define LONG_MAX 0X7FFFFFFFL +#elif SIZEOF_LONG == 8 +#define LONG_MAX 0X7FFFFFFFFFFFFFFFL +#else +#error "could not set LONG_MAX in pyport.h" +#endif +#endif + +#ifndef LONG_MIN +#define LONG_MIN (-LONG_MAX-1) +#endif + +#ifndef LONG_BIT +#define LONG_BIT (8 * SIZEOF_LONG) +#endif + +#if LONG_BIT != 8 * SIZEOF_LONG +/* 04-Oct-2000 LONG_BIT is apparently (mis)defined as 64 on some recent + * 32-bit platforms using gcc. We try to catch that here at compile-time + * rather than waiting for integer multiplication to trigger bogus + * overflows. + */ +#error "LONG_BIT definition appears wrong for platform (bad gcc/glibc config?)." +#endif + +#ifdef __cplusplus +} +#endif + +/* + * Hide GCC attributes from compilers that don't support them. + */ +#if (!defined(__GNUC__) || __GNUC__ < 2 || \ + (__GNUC__ == 2 && __GNUC_MINOR__ < 7) ) +#define Py_GCC_ATTRIBUTE(x) +#else +#define Py_GCC_ATTRIBUTE(x) __attribute__(x) +#endif + +/* + * Specify alignment on compilers that support it. + */ +#if defined(__GNUC__) && __GNUC__ >= 3 +#define Py_ALIGNED(x) __attribute__((aligned(x))) +#else +#define Py_ALIGNED(x) +#endif + +/* Eliminate end-of-loop code not reached warnings from SunPro C + * when using do{...}while(0) macros + */ +#ifdef __SUNPRO_C +#pragma error_messages (off,E_END_OF_LOOP_CODE_NOT_REACHED) +#endif + +#ifndef Py_LL +#define Py_LL(x) x##LL +#endif + +#ifndef Py_ULL +#define Py_ULL(x) Py_LL(x##U) +#endif + +#define Py_VA_COPY va_copy + +/* + * Convenient macros to deal with endianness of the platform. WORDS_BIGENDIAN is + * detected by configure and defined in pyconfig.h. The code in pyconfig.h + * also takes care of Apple's universal builds. + */ + +#ifdef WORDS_BIGENDIAN +# define PY_BIG_ENDIAN 1 +# define PY_LITTLE_ENDIAN 0 +#else +# define PY_BIG_ENDIAN 0 +# define PY_LITTLE_ENDIAN 1 +#endif + +#ifdef __ANDROID__ + /* The Android langinfo.h header is not used. */ +# undef HAVE_LANGINFO_H +# undef CODESET +#endif + +/* Maximum value of the Windows DWORD type */ +#define PY_DWORD_MAX 4294967295U + +/* This macro used to tell whether Python was built with multithreading + * enabled. Now multithreading is always enabled, but keep the macro + * for compatibility. + */ +#ifndef WITH_THREAD +# define WITH_THREAD +#endif + +/* Check that ALT_SOABI is consistent with Py_TRACE_REFS: + ./configure --with-trace-refs should must be used to define Py_TRACE_REFS */ +#if defined(ALT_SOABI) && defined(Py_TRACE_REFS) +# error "Py_TRACE_REFS ABI is not compatible with release and debug ABI" +#endif + +#if defined(__ANDROID__) || defined(__VXWORKS__) + // Use UTF-8 as the locale encoding, ignore the LC_CTYPE locale. + // See _Py_GetLocaleEncoding(), PyUnicode_DecodeLocale() + // and PyUnicode_EncodeLocale(). +# define _Py_FORCE_UTF8_LOCALE +#endif + +#if defined(_Py_FORCE_UTF8_LOCALE) || defined(__APPLE__) + // Use UTF-8 as the filesystem encoding. + // See PyUnicode_DecodeFSDefaultAndSize(), PyUnicode_EncodeFSDefault(), + // Py_DecodeLocale() and Py_EncodeLocale(). +# define _Py_FORCE_UTF8_FS_ENCODING +#endif + +/* Mark a function which cannot return. Example: + PyAPI_FUNC(void) _Py_NO_RETURN PyThread_exit_thread(void); + + XLC support is intentionally omitted due to bpo-40244 */ +#ifndef _Py_NO_RETURN +#if defined(__clang__) || \ + (defined(__GNUC__) && \ + ((__GNUC__ >= 3) || \ + (__GNUC__ == 2) && (__GNUC_MINOR__ >= 5))) +# define _Py_NO_RETURN __attribute__((__noreturn__)) +#elif defined(_MSC_VER) +# define _Py_NO_RETURN __declspec(noreturn) +#else +# define _Py_NO_RETURN +#endif +#endif + + +// Preprocessor check for a builtin preprocessor function. Always return 0 +// if __has_builtin() macro is not defined. +// +// __has_builtin() is available on clang and GCC 10. +#ifdef __has_builtin +# define _Py__has_builtin(x) __has_builtin(x) +#else +# define _Py__has_builtin(x) 0 +#endif + + +/* A convenient way for code to know if sanitizers are enabled. */ +#if defined(__has_feature) +# if __has_feature(memory_sanitizer) +# if !defined(_Py_MEMORY_SANITIZER) +# define _Py_MEMORY_SANITIZER +# endif +# endif +# if __has_feature(address_sanitizer) +# if !defined(_Py_ADDRESS_SANITIZER) +# define _Py_ADDRESS_SANITIZER +# endif +# endif +#elif defined(__GNUC__) +# if defined(__SANITIZE_ADDRESS__) +# define _Py_ADDRESS_SANITIZER +# endif +#endif + +#endif /* Py_PYPORT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pystate.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pystate.h new file mode 100644 index 0000000000000000000000000000000000000000..e6b4de979c87b885cb6f1f33186d03e726a518b4 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pystate.h @@ -0,0 +1,132 @@ +/* Thread and interpreter state structures and their interfaces */ + + +#ifndef Py_PYSTATE_H +#define Py_PYSTATE_H +#ifdef __cplusplus +extern "C" { +#endif + +/* This limitation is for performance and simplicity. If needed it can be +removed (with effort). */ +#define MAX_CO_EXTRA_USERS 255 + +PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_New(void); +PyAPI_FUNC(void) PyInterpreterState_Clear(PyInterpreterState *); +PyAPI_FUNC(void) PyInterpreterState_Delete(PyInterpreterState *); + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 +/* New in 3.9 */ +/* Get the current interpreter state. + + Issue a fatal error if there no current Python thread state or no current + interpreter. It cannot return NULL. + + The caller must hold the GIL. */ +PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Get(void); +#endif + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03080000 +/* New in 3.8 */ +PyAPI_FUNC(PyObject *) PyInterpreterState_GetDict(PyInterpreterState *); +#endif + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000 +/* New in 3.7 */ +PyAPI_FUNC(int64_t) PyInterpreterState_GetID(PyInterpreterState *); +#endif +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 + +/* State unique per thread */ + +/* New in 3.3 */ +PyAPI_FUNC(int) PyState_AddModule(PyObject*, PyModuleDef*); +PyAPI_FUNC(int) PyState_RemoveModule(PyModuleDef*); +#endif +PyAPI_FUNC(PyObject*) PyState_FindModule(PyModuleDef*); + +PyAPI_FUNC(PyThreadState *) PyThreadState_New(PyInterpreterState *); +PyAPI_FUNC(void) PyThreadState_Clear(PyThreadState *); +PyAPI_FUNC(void) PyThreadState_Delete(PyThreadState *); + +/* Get the current thread state. + + When the current thread state is NULL, this issues a fatal error (so that + the caller needn't check for NULL). + + The caller must hold the GIL. + + See also _PyThreadState_UncheckedGet() and _PyThreadState_GET(). */ +PyAPI_FUNC(PyThreadState *) PyThreadState_Get(void); + +// Alias to PyThreadState_Get() +#define PyThreadState_GET() PyThreadState_Get() + +PyAPI_FUNC(PyThreadState *) PyThreadState_Swap(PyThreadState *); +PyAPI_FUNC(PyObject *) PyThreadState_GetDict(void); +PyAPI_FUNC(int) PyThreadState_SetAsyncExc(unsigned long, PyObject *); + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 +/* New in 3.9 */ +PyAPI_FUNC(PyInterpreterState*) PyThreadState_GetInterpreter(PyThreadState *tstate); +PyAPI_FUNC(PyFrameObject*) PyThreadState_GetFrame(PyThreadState *tstate); +PyAPI_FUNC(uint64_t) PyThreadState_GetID(PyThreadState *tstate); +#endif + +typedef + enum {PyGILState_LOCKED, PyGILState_UNLOCKED} + PyGILState_STATE; + + +/* Ensure that the current thread is ready to call the Python + C API, regardless of the current state of Python, or of its + thread lock. This may be called as many times as desired + by a thread so long as each call is matched with a call to + PyGILState_Release(). In general, other thread-state APIs may + be used between _Ensure() and _Release() calls, so long as the + thread-state is restored to its previous state before the Release(). + For example, normal use of the Py_BEGIN_ALLOW_THREADS/ + Py_END_ALLOW_THREADS macros are acceptable. + + The return value is an opaque "handle" to the thread state when + PyGILState_Ensure() was called, and must be passed to + PyGILState_Release() to ensure Python is left in the same state. Even + though recursive calls are allowed, these handles can *not* be shared - + each unique call to PyGILState_Ensure must save the handle for its + call to PyGILState_Release. + + When the function returns, the current thread will hold the GIL. + + Failure is a fatal error. +*/ +PyAPI_FUNC(PyGILState_STATE) PyGILState_Ensure(void); + +/* Release any resources previously acquired. After this call, Python's + state will be the same as it was prior to the corresponding + PyGILState_Ensure() call (but generally this state will be unknown to + the caller, hence the use of the GILState API.) + + Every call to PyGILState_Ensure must be matched by a call to + PyGILState_Release on the same thread. +*/ +PyAPI_FUNC(void) PyGILState_Release(PyGILState_STATE); + +/* Helper/diagnostic function - get the current thread state for + this thread. May return NULL if no GILState API has been used + on the current thread. Note that the main thread always has such a + thread-state, even if no auto-thread-state call has been made + on the main thread. +*/ +PyAPI_FUNC(PyThreadState *) PyGILState_GetThisThreadState(void); + + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_PYSTATE_H +# include "cpython/pystate.h" +# undef Py_CPYTHON_PYSTATE_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_PYSTATE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pystrcmp.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pystrcmp.h new file mode 100644 index 0000000000000000000000000000000000000000..edb12397e3cbcc761a5ba28221215a62193a48ba --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pystrcmp.h @@ -0,0 +1,23 @@ +#ifndef Py_STRCMP_H +#define Py_STRCMP_H + +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_FUNC(int) PyOS_mystrnicmp(const char *, const char *, Py_ssize_t); +PyAPI_FUNC(int) PyOS_mystricmp(const char *, const char *); + +#ifdef MS_WINDOWS +#define PyOS_strnicmp strnicmp +#define PyOS_stricmp stricmp +#else +#define PyOS_strnicmp PyOS_mystrnicmp +#define PyOS_stricmp PyOS_mystricmp +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* !Py_STRCMP_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pystrtod.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pystrtod.h new file mode 100644 index 0000000000000000000000000000000000000000..fa056d17b6395fc3d7cdb435ea4c44d089432b99 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pystrtod.h @@ -0,0 +1,46 @@ +#ifndef Py_STRTOD_H +#define Py_STRTOD_H + +#ifdef __cplusplus +extern "C" { +#endif + + +PyAPI_FUNC(double) PyOS_string_to_double(const char *str, + char **endptr, + PyObject *overflow_exception); + +/* The caller is responsible for calling PyMem_Free to free the buffer + that's is returned. */ +PyAPI_FUNC(char *) PyOS_double_to_string(double val, + char format_code, + int precision, + int flags, + int *type); + +#ifndef Py_LIMITED_API +PyAPI_FUNC(PyObject *) _Py_string_to_number_with_underscores( + const char *str, Py_ssize_t len, const char *what, PyObject *obj, void *arg, + PyObject *(*innerfunc)(const char *, Py_ssize_t, void *)); + +PyAPI_FUNC(double) _Py_parse_inf_or_nan(const char *p, char **endptr); +#endif + + +/* PyOS_double_to_string's "flags" parameter can be set to 0 or more of: */ +#define Py_DTSF_SIGN 0x01 /* always add the sign */ +#define Py_DTSF_ADD_DOT_0 0x02 /* if the result is an integer add ".0" */ +#define Py_DTSF_ALT 0x04 /* "alternate" formatting. it's format_code + specific */ +#define Py_DTSF_NO_NEG_0 0x08 /* negative zero result is coerced to 0 */ + +/* PyOS_double_to_string's "type", if non-NULL, will be set to one of: */ +#define Py_DTST_FINITE 0 +#define Py_DTST_INFINITE 1 +#define Py_DTST_NAN 2 + +#ifdef __cplusplus +} +#endif + +#endif /* !Py_STRTOD_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pythonrun.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pythonrun.h new file mode 100644 index 0000000000000000000000000000000000000000..1b208b734ab1bfe4dd42f916a04de5a38441443f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pythonrun.h @@ -0,0 +1,45 @@ + +/* Interfaces to parse and execute pieces of python code */ + +#ifndef Py_PYTHONRUN_H +#define Py_PYTHONRUN_H +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_FUNC(PyObject *) Py_CompileString(const char *, const char *, int); + +PyAPI_FUNC(void) PyErr_Print(void); +PyAPI_FUNC(void) PyErr_PrintEx(int); +PyAPI_FUNC(void) PyErr_Display(PyObject *, PyObject *, PyObject *); + + +/* Stuff with no proper home (yet) */ +PyAPI_DATA(int) (*PyOS_InputHook)(void); + +/* Stack size, in "pointers" (so we get extra safety margins + on 64-bit platforms). On a 32-bit platform, this translates + to an 8k margin. */ +#define PYOS_STACK_MARGIN 2048 + +#if defined(WIN32) && !defined(MS_WIN64) && !defined(_M_ARM) && defined(_MSC_VER) && _MSC_VER >= 1300 +/* Enable stack checking under Microsoft C */ +// When changing the platforms, ensure PyOS_CheckStack() docs are still correct +#define USE_STACKCHECK +#endif + +#ifdef USE_STACKCHECK +/* Check that we aren't overflowing our stack */ +PyAPI_FUNC(int) PyOS_CheckStack(void); +#endif + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_PYTHONRUN_H +# include "cpython/pythonrun.h" +# undef Py_CPYTHON_PYTHONRUN_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_PYTHONRUN_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pythread.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pythread.h new file mode 100644 index 0000000000000000000000000000000000000000..a48329085fac513f38c29f2e356fd8aa81ae03ea --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pythread.h @@ -0,0 +1,133 @@ +#ifndef Py_PYTHREAD_H +#define Py_PYTHREAD_H + +typedef void *PyThread_type_lock; + +#ifdef __cplusplus +extern "C" { +#endif + +/* Return status codes for Python lock acquisition. Chosen for maximum + * backwards compatibility, ie failure -> 0, success -> 1. */ +typedef enum PyLockStatus { + PY_LOCK_FAILURE = 0, + PY_LOCK_ACQUIRED = 1, + PY_LOCK_INTR +} PyLockStatus; + +PyAPI_FUNC(void) PyThread_init_thread(void); +PyAPI_FUNC(unsigned long) PyThread_start_new_thread(void (*)(void *), void *); +PyAPI_FUNC(void) _Py_NO_RETURN PyThread_exit_thread(void); +PyAPI_FUNC(unsigned long) PyThread_get_thread_ident(void); + +#if defined(__APPLE__) || defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(_WIN32) || defined(_AIX) +#define PY_HAVE_THREAD_NATIVE_ID +PyAPI_FUNC(unsigned long) PyThread_get_thread_native_id(void); +#endif + +PyAPI_FUNC(PyThread_type_lock) PyThread_allocate_lock(void); +PyAPI_FUNC(void) PyThread_free_lock(PyThread_type_lock); +PyAPI_FUNC(int) PyThread_acquire_lock(PyThread_type_lock, int); +#define WAIT_LOCK 1 +#define NOWAIT_LOCK 0 + +/* PY_TIMEOUT_T is the integral type used to specify timeouts when waiting + on a lock (see PyThread_acquire_lock_timed() below). + PY_TIMEOUT_MAX is the highest usable value (in microseconds) of that + type, and depends on the system threading API. + + NOTE: this isn't the same value as `_thread.TIMEOUT_MAX`. The _thread + module exposes a higher-level API, with timeouts expressed in seconds + and floating-point numbers allowed. +*/ +#define PY_TIMEOUT_T long long + +#if defined(_POSIX_THREADS) + /* PyThread_acquire_lock_timed() uses _PyTime_FromNanoseconds(us * 1000), + convert microseconds to nanoseconds. */ +# define PY_TIMEOUT_MAX (LLONG_MAX / 1000) +#elif defined (NT_THREADS) + // WaitForSingleObject() accepts timeout in milliseconds in the range + // [0; 0xFFFFFFFE] (DWORD type). INFINITE value (0xFFFFFFFF) means no + // timeout. 0xFFFFFFFE milliseconds is around 49.7 days. +# if 0xFFFFFFFELL * 1000 < LLONG_MAX +# define PY_TIMEOUT_MAX (0xFFFFFFFELL * 1000) +# else +# define PY_TIMEOUT_MAX LLONG_MAX +# endif +#else +# define PY_TIMEOUT_MAX LLONG_MAX +#endif + + +/* If microseconds == 0, the call is non-blocking: it returns immediately + even when the lock can't be acquired. + If microseconds > 0, the call waits up to the specified duration. + If microseconds < 0, the call waits until success (or abnormal failure) + + microseconds must be less than PY_TIMEOUT_MAX. Behaviour otherwise is + undefined. + + If intr_flag is true and the acquire is interrupted by a signal, then the + call will return PY_LOCK_INTR. The caller may reattempt to acquire the + lock. +*/ +PyAPI_FUNC(PyLockStatus) PyThread_acquire_lock_timed(PyThread_type_lock, + PY_TIMEOUT_T microseconds, + int intr_flag); + +PyAPI_FUNC(void) PyThread_release_lock(PyThread_type_lock); + +PyAPI_FUNC(size_t) PyThread_get_stacksize(void); +PyAPI_FUNC(int) PyThread_set_stacksize(size_t); + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 +PyAPI_FUNC(PyObject*) PyThread_GetInfo(void); +#endif + + +/* Thread Local Storage (TLS) API + TLS API is DEPRECATED. Use Thread Specific Storage (TSS) API. + + The existing TLS API has used int to represent TLS keys across all + platforms, but it is not POSIX-compliant. Therefore, the new TSS API uses + opaque data type to represent TSS keys to be compatible (see PEP 539). +*/ +Py_DEPRECATED(3.7) PyAPI_FUNC(int) PyThread_create_key(void); +Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyThread_delete_key(int key); +Py_DEPRECATED(3.7) PyAPI_FUNC(int) PyThread_set_key_value(int key, + void *value); +Py_DEPRECATED(3.7) PyAPI_FUNC(void *) PyThread_get_key_value(int key); +Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyThread_delete_key_value(int key); + +/* Cleanup after a fork */ +Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyThread_ReInitTLS(void); + + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000 +/* New in 3.7 */ +/* Thread Specific Storage (TSS) API */ + +typedef struct _Py_tss_t Py_tss_t; /* opaque */ + +PyAPI_FUNC(Py_tss_t *) PyThread_tss_alloc(void); +PyAPI_FUNC(void) PyThread_tss_free(Py_tss_t *key); + +/* The parameter key must not be NULL. */ +PyAPI_FUNC(int) PyThread_tss_is_created(Py_tss_t *key); +PyAPI_FUNC(int) PyThread_tss_create(Py_tss_t *key); +PyAPI_FUNC(void) PyThread_tss_delete(Py_tss_t *key); +PyAPI_FUNC(int) PyThread_tss_set(Py_tss_t *key, void *value); +PyAPI_FUNC(void *) PyThread_tss_get(Py_tss_t *key); +#endif /* New in 3.7 */ + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_PYTHREAD_H +# include "cpython/pythread.h" +# undef Py_CPYTHON_PYTHREAD_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_PYTHREAD_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pytypedefs.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pytypedefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e78ed56a3b67cd19a6fbce550cb9b145c719ed31 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/pytypedefs.h @@ -0,0 +1,30 @@ +// Forward declarations of types of the Python C API. +// Declare them at the same place since redefining typedef is a C11 feature. +// Only use a forward declaration if there is an interdependency between two +// header files. + +#ifndef Py_PYTYPEDEFS_H +#define Py_PYTYPEDEFS_H +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct PyModuleDef PyModuleDef; +typedef struct PyModuleDef_Slot PyModuleDef_Slot; +typedef struct PyMethodDef PyMethodDef; +typedef struct PyGetSetDef PyGetSetDef; +typedef struct PyMemberDef PyMemberDef; + +typedef struct _object PyObject; +typedef struct _longobject PyLongObject; +typedef struct _typeobject PyTypeObject; +typedef struct PyCodeObject PyCodeObject; +typedef struct _frame PyFrameObject; + +typedef struct _ts PyThreadState; +typedef struct _is PyInterpreterState; + +#ifdef __cplusplus +} +#endif +#endif // !Py_PYTYPEDEFS_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/rangeobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/rangeobject.h new file mode 100644 index 0000000000000000000000000000000000000000..d6af8473f9e8d33f011c6c42d6350fa00ca6ac3d --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/rangeobject.h @@ -0,0 +1,27 @@ + +/* Range object interface */ + +#ifndef Py_RANGEOBJECT_H +#define Py_RANGEOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +/* +A range object represents an integer range. This is an immutable object; +a range cannot change its value after creation. + +Range objects behave like the corresponding tuple objects except that +they are represented by a start, stop, and step datamembers. +*/ + +PyAPI_DATA(PyTypeObject) PyRange_Type; +PyAPI_DATA(PyTypeObject) PyRangeIter_Type; +PyAPI_DATA(PyTypeObject) PyLongRangeIter_Type; + +#define PyRange_Check(op) Py_IS_TYPE(op, &PyRange_Type) + +#ifdef __cplusplus +} +#endif +#endif /* !Py_RANGEOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/setobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/setobject.h new file mode 100644 index 0000000000000000000000000000000000000000..fdad70644c545cbda5b29ae94b99e8ff9dbcce37 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/setobject.h @@ -0,0 +1,49 @@ +/* Set object interface */ + +#ifndef Py_SETOBJECT_H +#define Py_SETOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_DATA(PyTypeObject) PySet_Type; +PyAPI_DATA(PyTypeObject) PyFrozenSet_Type; +PyAPI_DATA(PyTypeObject) PySetIter_Type; + +PyAPI_FUNC(PyObject *) PySet_New(PyObject *); +PyAPI_FUNC(PyObject *) PyFrozenSet_New(PyObject *); + +PyAPI_FUNC(int) PySet_Add(PyObject *set, PyObject *key); +PyAPI_FUNC(int) PySet_Clear(PyObject *set); +PyAPI_FUNC(int) PySet_Contains(PyObject *anyset, PyObject *key); +PyAPI_FUNC(int) PySet_Discard(PyObject *set, PyObject *key); +PyAPI_FUNC(PyObject *) PySet_Pop(PyObject *set); +PyAPI_FUNC(Py_ssize_t) PySet_Size(PyObject *anyset); + +#define PyFrozenSet_CheckExact(ob) Py_IS_TYPE(ob, &PyFrozenSet_Type) +#define PyFrozenSet_Check(ob) \ + (Py_IS_TYPE(ob, &PyFrozenSet_Type) || \ + PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type)) + +#define PyAnySet_CheckExact(ob) \ + (Py_IS_TYPE(ob, &PySet_Type) || Py_IS_TYPE(ob, &PyFrozenSet_Type)) +#define PyAnySet_Check(ob) \ + (Py_IS_TYPE(ob, &PySet_Type) || Py_IS_TYPE(ob, &PyFrozenSet_Type) || \ + PyType_IsSubtype(Py_TYPE(ob), &PySet_Type) || \ + PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type)) + +#define PySet_CheckExact(op) Py_IS_TYPE(op, &PySet_Type) +#define PySet_Check(ob) \ + (Py_IS_TYPE(ob, &PySet_Type) || \ + PyType_IsSubtype(Py_TYPE(ob), &PySet_Type)) + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_SETOBJECT_H +# include "cpython/setobject.h" +# undef Py_CPYTHON_SETOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_SETOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/sliceobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/sliceobject.h new file mode 100644 index 0000000000000000000000000000000000000000..2c889508b4b495b56df2fc034f6f6ad5baebba89 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/sliceobject.h @@ -0,0 +1,65 @@ +#ifndef Py_SLICEOBJECT_H +#define Py_SLICEOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +/* The unique ellipsis object "..." */ + +PyAPI_DATA(PyObject) _Py_EllipsisObject; /* Don't use this directly */ + +#define Py_Ellipsis (&_Py_EllipsisObject) + +/* Slice object interface */ + +/* + +A slice object containing start, stop, and step data members (the +names are from range). After much talk with Guido, it was decided to +let these be any arbitrary python type. Py_None stands for omitted values. +*/ +#ifndef Py_LIMITED_API +typedef struct { + PyObject_HEAD + PyObject *start, *stop, *step; /* not NULL */ +} PySliceObject; +#endif + +PyAPI_DATA(PyTypeObject) PySlice_Type; +PyAPI_DATA(PyTypeObject) PyEllipsis_Type; + +#define PySlice_Check(op) Py_IS_TYPE(op, &PySlice_Type) + +PyAPI_FUNC(PyObject *) PySlice_New(PyObject* start, PyObject* stop, + PyObject* step); +#ifndef Py_LIMITED_API +PyAPI_FUNC(PyObject *) _PySlice_FromIndices(Py_ssize_t start, Py_ssize_t stop); +PyAPI_FUNC(int) _PySlice_GetLongIndices(PySliceObject *self, PyObject *length, + PyObject **start_ptr, PyObject **stop_ptr, + PyObject **step_ptr); +#endif +PyAPI_FUNC(int) PySlice_GetIndices(PyObject *r, Py_ssize_t length, + Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step); +Py_DEPRECATED(3.7) +PyAPI_FUNC(int) PySlice_GetIndicesEx(PyObject *r, Py_ssize_t length, + Py_ssize_t *start, Py_ssize_t *stop, + Py_ssize_t *step, + Py_ssize_t *slicelength); + +#if !defined(Py_LIMITED_API) || (Py_LIMITED_API+0 >= 0x03050400 && Py_LIMITED_API+0 < 0x03060000) || Py_LIMITED_API+0 >= 0x03060100 +#define PySlice_GetIndicesEx(slice, length, start, stop, step, slicelen) ( \ + PySlice_Unpack((slice), (start), (stop), (step)) < 0 ? \ + ((*(slicelen) = 0), -1) : \ + ((*(slicelen) = PySlice_AdjustIndices((length), (start), (stop), *(step))), \ + 0)) +PyAPI_FUNC(int) PySlice_Unpack(PyObject *slice, + Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step); +PyAPI_FUNC(Py_ssize_t) PySlice_AdjustIndices(Py_ssize_t length, + Py_ssize_t *start, Py_ssize_t *stop, + Py_ssize_t step); +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_SLICEOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/structmember.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/structmember.h new file mode 100644 index 0000000000000000000000000000000000000000..65a777d5f52117cabea9d8283a796ecbe2714bf7 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/structmember.h @@ -0,0 +1,75 @@ +#ifndef Py_STRUCTMEMBER_H +#define Py_STRUCTMEMBER_H +#ifdef __cplusplus +extern "C" { +#endif + + +/* Interface to map C struct members to Python object attributes */ + +#include /* For offsetof */ + +/* An array of PyMemberDef structures defines the name, type and offset + of selected members of a C structure. These can be read by + PyMember_GetOne() and set by PyMember_SetOne() (except if their READONLY + flag is set). The array must be terminated with an entry whose name + pointer is NULL. */ + +struct PyMemberDef { + const char *name; + int type; + Py_ssize_t offset; + int flags; + const char *doc; +}; + +/* Types */ +#define T_SHORT 0 +#define T_INT 1 +#define T_LONG 2 +#define T_FLOAT 3 +#define T_DOUBLE 4 +#define T_STRING 5 +#define T_OBJECT 6 +/* XXX the ordering here is weird for binary compatibility */ +#define T_CHAR 7 /* 1-character string */ +#define T_BYTE 8 /* 8-bit signed int */ +/* unsigned variants: */ +#define T_UBYTE 9 +#define T_USHORT 10 +#define T_UINT 11 +#define T_ULONG 12 + +/* Added by Jack: strings contained in the structure */ +#define T_STRING_INPLACE 13 + +/* Added by Lillo: bools contained in the structure (assumed char) */ +#define T_BOOL 14 + +#define T_OBJECT_EX 16 /* Like T_OBJECT, but raises AttributeError + when the value is NULL, instead of + converting to None. */ +#define T_LONGLONG 17 +#define T_ULONGLONG 18 + +#define T_PYSSIZET 19 /* Py_ssize_t */ +#define T_NONE 20 /* Value is always None */ + + +/* Flags */ +#define READONLY 1 +#define READ_RESTRICTED 2 +#define PY_WRITE_RESTRICTED 4 +#define RESTRICTED (READ_RESTRICTED | PY_WRITE_RESTRICTED) + +#define PY_AUDIT_READ READ_RESTRICTED + +/* Current API, use this */ +PyAPI_FUNC(PyObject *) PyMember_GetOne(const char *, PyMemberDef *); +PyAPI_FUNC(int) PyMember_SetOne(char *, PyMemberDef *, PyObject *); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_STRUCTMEMBER_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/structseq.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/structseq.h new file mode 100644 index 0000000000000000000000000000000000000000..4f5c09f7ba05ef3d58b4a74afe1cbab8515ca495 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/structseq.h @@ -0,0 +1,49 @@ + +/* Named tuple object interface */ + +#ifndef Py_STRUCTSEQ_H +#define Py_STRUCTSEQ_H +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct PyStructSequence_Field { + const char *name; + const char *doc; +} PyStructSequence_Field; + +typedef struct PyStructSequence_Desc { + const char *name; + const char *doc; + PyStructSequence_Field *fields; + int n_in_sequence; +} PyStructSequence_Desc; + +PyAPI_DATA(const char * const) PyStructSequence_UnnamedField; + +#ifndef Py_LIMITED_API +PyAPI_FUNC(void) PyStructSequence_InitType(PyTypeObject *type, + PyStructSequence_Desc *desc); +PyAPI_FUNC(int) PyStructSequence_InitType2(PyTypeObject *type, + PyStructSequence_Desc *desc); +#endif +PyAPI_FUNC(PyTypeObject*) PyStructSequence_NewType(PyStructSequence_Desc *desc); + +PyAPI_FUNC(PyObject *) PyStructSequence_New(PyTypeObject* type); + +#ifndef Py_LIMITED_API +typedef PyTupleObject PyStructSequence; + +/* Macro, *only* to be used to fill in brand new objects */ +#define PyStructSequence_SET_ITEM(op, i, v) PyTuple_SET_ITEM(op, i, v) + +#define PyStructSequence_GET_ITEM(op, i) PyTuple_GET_ITEM(op, i) +#endif + +PyAPI_FUNC(void) PyStructSequence_SetItem(PyObject*, Py_ssize_t, PyObject*); +PyAPI_FUNC(PyObject*) PyStructSequence_GetItem(PyObject*, Py_ssize_t); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_STRUCTSEQ_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/sysmodule.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/sysmodule.h new file mode 100644 index 0000000000000000000000000000000000000000..b5087119b1cae7d7c9c8becc3327a9a5040a6bc6 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/sysmodule.h @@ -0,0 +1,41 @@ + +/* System module interface */ + +#ifndef Py_SYSMODULE_H +#define Py_SYSMODULE_H +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_FUNC(PyObject *) PySys_GetObject(const char *); +PyAPI_FUNC(int) PySys_SetObject(const char *, PyObject *); + +Py_DEPRECATED(3.11) PyAPI_FUNC(void) PySys_SetArgv(int, wchar_t **); +Py_DEPRECATED(3.11) PyAPI_FUNC(void) PySys_SetArgvEx(int, wchar_t **, int); +Py_DEPRECATED(3.11) PyAPI_FUNC(void) PySys_SetPath(const wchar_t *); + +PyAPI_FUNC(void) PySys_WriteStdout(const char *format, ...) + Py_GCC_ATTRIBUTE((format(printf, 1, 2))); +PyAPI_FUNC(void) PySys_WriteStderr(const char *format, ...) + Py_GCC_ATTRIBUTE((format(printf, 1, 2))); +PyAPI_FUNC(void) PySys_FormatStdout(const char *format, ...); +PyAPI_FUNC(void) PySys_FormatStderr(const char *format, ...); + +PyAPI_FUNC(void) PySys_ResetWarnOptions(void); +Py_DEPRECATED(3.11) PyAPI_FUNC(void) PySys_AddWarnOption(const wchar_t *); +Py_DEPRECATED(3.11) PyAPI_FUNC(void) PySys_AddWarnOptionUnicode(PyObject *); +Py_DEPRECATED(3.11) PyAPI_FUNC(int) PySys_HasWarnOptions(void); + +Py_DEPRECATED(3.11) PyAPI_FUNC(void) PySys_AddXOption(const wchar_t *); +PyAPI_FUNC(PyObject *) PySys_GetXOptions(void); + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_SYSMODULE_H +# include "cpython/sysmodule.h" +# undef Py_CPYTHON_SYSMODULE_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_SYSMODULE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/token.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/token.h new file mode 100644 index 0000000000000000000000000000000000000000..eb1b9ea47b469aff22032524129060a04659d28f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/token.h @@ -0,0 +1,97 @@ +/* Auto-generated by Tools/scripts/generate_token.py */ + +/* Token types */ +#ifndef Py_LIMITED_API +#ifndef Py_TOKEN_H +#define Py_TOKEN_H +#ifdef __cplusplus +extern "C" { +#endif + +#undef TILDE /* Prevent clash of our definition with system macro. Ex AIX, ioctl.h */ + +#define ENDMARKER 0 +#define NAME 1 +#define NUMBER 2 +#define STRING 3 +#define NEWLINE 4 +#define INDENT 5 +#define DEDENT 6 +#define LPAR 7 +#define RPAR 8 +#define LSQB 9 +#define RSQB 10 +#define COLON 11 +#define COMMA 12 +#define SEMI 13 +#define PLUS 14 +#define MINUS 15 +#define STAR 16 +#define SLASH 17 +#define VBAR 18 +#define AMPER 19 +#define LESS 20 +#define GREATER 21 +#define EQUAL 22 +#define DOT 23 +#define PERCENT 24 +#define LBRACE 25 +#define RBRACE 26 +#define EQEQUAL 27 +#define NOTEQUAL 28 +#define LESSEQUAL 29 +#define GREATEREQUAL 30 +#define TILDE 31 +#define CIRCUMFLEX 32 +#define LEFTSHIFT 33 +#define RIGHTSHIFT 34 +#define DOUBLESTAR 35 +#define PLUSEQUAL 36 +#define MINEQUAL 37 +#define STAREQUAL 38 +#define SLASHEQUAL 39 +#define PERCENTEQUAL 40 +#define AMPEREQUAL 41 +#define VBAREQUAL 42 +#define CIRCUMFLEXEQUAL 43 +#define LEFTSHIFTEQUAL 44 +#define RIGHTSHIFTEQUAL 45 +#define DOUBLESTAREQUAL 46 +#define DOUBLESLASH 47 +#define DOUBLESLASHEQUAL 48 +#define AT 49 +#define ATEQUAL 50 +#define RARROW 51 +#define ELLIPSIS 52 +#define COLONEQUAL 53 +#define OP 54 +#define AWAIT 55 +#define ASYNC 56 +#define TYPE_IGNORE 57 +#define TYPE_COMMENT 58 +#define SOFT_KEYWORD 59 +#define ERRORTOKEN 60 +#define N_TOKENS 64 +#define NT_OFFSET 256 + +/* Special definitions for cooperation with parser */ + +#define ISTERMINAL(x) ((x) < NT_OFFSET) +#define ISNONTERMINAL(x) ((x) >= NT_OFFSET) +#define ISEOF(x) ((x) == ENDMARKER) +#define ISWHITESPACE(x) ((x) == ENDMARKER || \ + (x) == NEWLINE || \ + (x) == INDENT || \ + (x) == DEDENT) + + +PyAPI_DATA(const char * const) _PyParser_TokenNames[]; /* Token names */ +PyAPI_FUNC(int) PyToken_OneChar(int); +PyAPI_FUNC(int) PyToken_TwoChars(int, int); +PyAPI_FUNC(int) PyToken_ThreeChars(int, int, int); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_TOKEN_H */ +#endif /* Py_LIMITED_API */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/traceback.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/traceback.h new file mode 100644 index 0000000000000000000000000000000000000000..2dfa2ada4f2c375710b3150bacb358643b66a328 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/traceback.h @@ -0,0 +1,26 @@ +#ifndef Py_TRACEBACK_H +#define Py_TRACEBACK_H +#ifdef __cplusplus +extern "C" { +#endif + +/* Traceback interface */ + +PyAPI_FUNC(int) PyTraceBack_Here(PyFrameObject *); +PyAPI_FUNC(int) PyTraceBack_Print(PyObject *, PyObject *); + +/* Reveal traceback type so we can typecheck traceback objects */ +PyAPI_DATA(PyTypeObject) PyTraceBack_Type; +#define PyTraceBack_Check(v) Py_IS_TYPE(v, &PyTraceBack_Type) + + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_TRACEBACK_H +# include "cpython/traceback.h" +# undef Py_CPYTHON_TRACEBACK_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_TRACEBACK_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/tracemalloc.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/tracemalloc.h new file mode 100644 index 0000000000000000000000000000000000000000..bd14217c199c3cb212aa8253d1c32c0e53325b40 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/tracemalloc.h @@ -0,0 +1,38 @@ +#ifndef Py_TRACEMALLOC_H +#define Py_TRACEMALLOC_H + +#ifndef Py_LIMITED_API +/* Track an allocated memory block in the tracemalloc module. + Return 0 on success, return -1 on error (failed to allocate memory to store + the trace). + + Return -2 if tracemalloc is disabled. + + If memory block is already tracked, update the existing trace. */ +PyAPI_FUNC(int) PyTraceMalloc_Track( + unsigned int domain, + uintptr_t ptr, + size_t size); + +/* Untrack an allocated memory block in the tracemalloc module. + Do nothing if the block was not tracked. + + Return -2 if tracemalloc is disabled, otherwise return 0. */ +PyAPI_FUNC(int) PyTraceMalloc_Untrack( + unsigned int domain, + uintptr_t ptr); + +/* Get the traceback where a memory block was allocated. + + Return a tuple of (filename: str, lineno: int) tuples. + + Return None if the tracemalloc module is disabled or if the memory block + is not tracked by tracemalloc. + + Raise an exception and return NULL on error. */ +PyAPI_FUNC(PyObject*) _PyTraceMalloc_GetTraceback( + unsigned int domain, + uintptr_t ptr); +#endif + +#endif /* !Py_TRACEMALLOC_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/tupleobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/tupleobject.h new file mode 100644 index 0000000000000000000000000000000000000000..dc68e3fc5c6d8807a4bd6ca1b5c0368f03db0a1a --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/tupleobject.h @@ -0,0 +1,46 @@ +/* Tuple object interface */ + +#ifndef Py_TUPLEOBJECT_H +#define Py_TUPLEOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +/* +Another generally useful object type is a tuple of object pointers. +For Python, this is an immutable type. C code can change the tuple items +(but not their number), and even use tuples as general-purpose arrays of +object references, but in general only brand new tuples should be mutated, +not ones that might already have been exposed to Python code. + +*** WARNING *** PyTuple_SetItem does not increment the new item's reference +count, but does decrement the reference count of the item it replaces, +if not nil. It does *decrement* the reference count if it is *not* +inserted in the tuple. Similarly, PyTuple_GetItem does not increment the +returned item's reference count. +*/ + +PyAPI_DATA(PyTypeObject) PyTuple_Type; +PyAPI_DATA(PyTypeObject) PyTupleIter_Type; + +#define PyTuple_Check(op) \ + PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TUPLE_SUBCLASS) +#define PyTuple_CheckExact(op) Py_IS_TYPE(op, &PyTuple_Type) + +PyAPI_FUNC(PyObject *) PyTuple_New(Py_ssize_t size); +PyAPI_FUNC(Py_ssize_t) PyTuple_Size(PyObject *); +PyAPI_FUNC(PyObject *) PyTuple_GetItem(PyObject *, Py_ssize_t); +PyAPI_FUNC(int) PyTuple_SetItem(PyObject *, Py_ssize_t, PyObject *); +PyAPI_FUNC(PyObject *) PyTuple_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t); +PyAPI_FUNC(PyObject *) PyTuple_Pack(Py_ssize_t, ...); + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_TUPLEOBJECT_H +# include "cpython/tupleobject.h" +# undef Py_CPYTHON_TUPLEOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_TUPLEOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/typeslots.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/typeslots.h new file mode 100644 index 0000000000000000000000000000000000000000..506b05580de146bbcae3e25e1e9ec18c773e9014 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/typeslots.h @@ -0,0 +1,88 @@ +/* Do not renumber the file; these numbers are part of the stable ABI. */ +#define Py_bf_getbuffer 1 +#define Py_bf_releasebuffer 2 +#define Py_mp_ass_subscript 3 +#define Py_mp_length 4 +#define Py_mp_subscript 5 +#define Py_nb_absolute 6 +#define Py_nb_add 7 +#define Py_nb_and 8 +#define Py_nb_bool 9 +#define Py_nb_divmod 10 +#define Py_nb_float 11 +#define Py_nb_floor_divide 12 +#define Py_nb_index 13 +#define Py_nb_inplace_add 14 +#define Py_nb_inplace_and 15 +#define Py_nb_inplace_floor_divide 16 +#define Py_nb_inplace_lshift 17 +#define Py_nb_inplace_multiply 18 +#define Py_nb_inplace_or 19 +#define Py_nb_inplace_power 20 +#define Py_nb_inplace_remainder 21 +#define Py_nb_inplace_rshift 22 +#define Py_nb_inplace_subtract 23 +#define Py_nb_inplace_true_divide 24 +#define Py_nb_inplace_xor 25 +#define Py_nb_int 26 +#define Py_nb_invert 27 +#define Py_nb_lshift 28 +#define Py_nb_multiply 29 +#define Py_nb_negative 30 +#define Py_nb_or 31 +#define Py_nb_positive 32 +#define Py_nb_power 33 +#define Py_nb_remainder 34 +#define Py_nb_rshift 35 +#define Py_nb_subtract 36 +#define Py_nb_true_divide 37 +#define Py_nb_xor 38 +#define Py_sq_ass_item 39 +#define Py_sq_concat 40 +#define Py_sq_contains 41 +#define Py_sq_inplace_concat 42 +#define Py_sq_inplace_repeat 43 +#define Py_sq_item 44 +#define Py_sq_length 45 +#define Py_sq_repeat 46 +#define Py_tp_alloc 47 +#define Py_tp_base 48 +#define Py_tp_bases 49 +#define Py_tp_call 50 +#define Py_tp_clear 51 +#define Py_tp_dealloc 52 +#define Py_tp_del 53 +#define Py_tp_descr_get 54 +#define Py_tp_descr_set 55 +#define Py_tp_doc 56 +#define Py_tp_getattr 57 +#define Py_tp_getattro 58 +#define Py_tp_hash 59 +#define Py_tp_init 60 +#define Py_tp_is_gc 61 +#define Py_tp_iter 62 +#define Py_tp_iternext 63 +#define Py_tp_methods 64 +#define Py_tp_new 65 +#define Py_tp_repr 66 +#define Py_tp_richcompare 67 +#define Py_tp_setattr 68 +#define Py_tp_setattro 69 +#define Py_tp_str 70 +#define Py_tp_traverse 71 +#define Py_tp_members 72 +#define Py_tp_getset 73 +#define Py_tp_free 74 +#define Py_nb_matrix_multiply 75 +#define Py_nb_inplace_matrix_multiply 76 +#define Py_am_await 77 +#define Py_am_aiter 78 +#define Py_am_anext 79 +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 +/* New in 3.5 */ +#define Py_tp_finalize 80 +#endif +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 +/* New in 3.10 */ +#define Py_am_send 81 +#endif diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/unicodeobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/unicodeobject.h new file mode 100644 index 0000000000000000000000000000000000000000..1d2f54608544ed39e46f7304de601793ff7245b2 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/unicodeobject.h @@ -0,0 +1,1049 @@ +#ifndef Py_UNICODEOBJECT_H +#define Py_UNICODEOBJECT_H + +#include // va_list + +/* + +Unicode implementation based on original code by Fredrik Lundh, +modified by Marc-Andre Lemburg (mal@lemburg.com) according to the +Unicode Integration Proposal. (See +http://www.egenix.com/files/python/unicode-proposal.txt). + +Copyright (c) Corporation for National Research Initiatives. + + + Original header: + -------------------------------------------------------------------- + + * Yet another Unicode string type for Python. This type supports the + * 16-bit Basic Multilingual Plane (BMP) only. + * + * Written by Fredrik Lundh, January 1999. + * + * Copyright (c) 1999 by Secret Labs AB. + * Copyright (c) 1999 by Fredrik Lundh. + * + * fredrik@pythonware.com + * http://www.pythonware.com + * + * -------------------------------------------------------------------- + * This Unicode String Type is + * + * Copyright (c) 1999 by Secret Labs AB + * Copyright (c) 1999 by Fredrik Lundh + * + * By obtaining, using, and/or copying this software and/or its + * associated documentation, you agree that you have read, understood, + * and will comply with the following terms and conditions: + * + * Permission to use, copy, modify, and distribute this software and its + * associated documentation for any purpose and without fee is hereby + * granted, provided that the above copyright notice appears in all + * copies, and that both that copyright notice and this permission notice + * appear in supporting documentation, and that the name of Secret Labs + * AB or the author not be used in advertising or publicity pertaining to + * distribution of the software without specific, written prior + * permission. + * + * SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT + * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * -------------------------------------------------------------------- */ + +#include + +/* === Internal API ======================================================= */ + +/* --- Internal Unicode Format -------------------------------------------- */ + +/* Python 3.x requires unicode */ +#define Py_USING_UNICODE + +#ifndef SIZEOF_WCHAR_T +#error Must define SIZEOF_WCHAR_T +#endif + +#define Py_UNICODE_SIZE SIZEOF_WCHAR_T + +/* If wchar_t can be used for UCS-4 storage, set Py_UNICODE_WIDE. + Otherwise, Unicode strings are stored as UCS-2 (with limited support + for UTF-16) */ + +#if Py_UNICODE_SIZE >= 4 +#define Py_UNICODE_WIDE +#endif + +/* Set these flags if the platform has "wchar.h" and the + wchar_t type is a 16-bit unsigned type */ +/* #define HAVE_WCHAR_H */ +/* #define HAVE_USABLE_WCHAR_T */ + +/* If the compiler provides a wchar_t type we try to support it + through the interface functions PyUnicode_FromWideChar(), + PyUnicode_AsWideChar() and PyUnicode_AsWideCharString(). */ + +#ifdef HAVE_USABLE_WCHAR_T +# ifndef HAVE_WCHAR_H +# define HAVE_WCHAR_H +# endif +#endif + +#ifdef HAVE_WCHAR_H +# include +#endif + +/* Py_UCS4 and Py_UCS2 are typedefs for the respective + unicode representations. */ +typedef uint32_t Py_UCS4; +typedef uint16_t Py_UCS2; +typedef uint8_t Py_UCS1; + +#ifdef __cplusplus +extern "C" { +#endif + + +PyAPI_DATA(PyTypeObject) PyUnicode_Type; +PyAPI_DATA(PyTypeObject) PyUnicodeIter_Type; + +#define PyUnicode_Check(op) \ + PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_UNICODE_SUBCLASS) +#define PyUnicode_CheckExact(op) Py_IS_TYPE(op, &PyUnicode_Type) + +/* --- Constants ---------------------------------------------------------- */ + +/* This Unicode character will be used as replacement character during + decoding if the errors argument is set to "replace". Note: the + Unicode character U+FFFD is the official REPLACEMENT CHARACTER in + Unicode 3.0. */ + +#define Py_UNICODE_REPLACEMENT_CHARACTER ((Py_UCS4) 0xFFFD) + +/* === Public API ========================================================= */ + +/* Similar to PyUnicode_FromUnicode(), but u points to UTF-8 encoded bytes */ +PyAPI_FUNC(PyObject*) PyUnicode_FromStringAndSize( + const char *u, /* UTF-8 encoded string */ + Py_ssize_t size /* size of buffer */ + ); + +/* Similar to PyUnicode_FromUnicode(), but u points to null-terminated + UTF-8 encoded bytes. The size is determined with strlen(). */ +PyAPI_FUNC(PyObject*) PyUnicode_FromString( + const char *u /* UTF-8 encoded string */ + ); + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 +PyAPI_FUNC(PyObject*) PyUnicode_Substring( + PyObject *str, + Py_ssize_t start, + Py_ssize_t end); +#endif + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 +/* Copy the string into a UCS4 buffer including the null character if copy_null + is set. Return NULL and raise an exception on error. Raise a SystemError if + the buffer is smaller than the string. Return buffer on success. + + buflen is the length of the buffer in (Py_UCS4) characters. */ +PyAPI_FUNC(Py_UCS4*) PyUnicode_AsUCS4( + PyObject *unicode, + Py_UCS4* buffer, + Py_ssize_t buflen, + int copy_null); + +/* Copy the string into a UCS4 buffer. A new buffer is allocated using + * PyMem_Malloc; if this fails, NULL is returned with a memory error + exception set. */ +PyAPI_FUNC(Py_UCS4*) PyUnicode_AsUCS4Copy(PyObject *unicode); +#endif + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 +/* Get the length of the Unicode object. */ + +PyAPI_FUNC(Py_ssize_t) PyUnicode_GetLength( + PyObject *unicode +); +#endif + +/* Get the number of Py_UNICODE units in the + string representation. */ + +Py_DEPRECATED(3.3) PyAPI_FUNC(Py_ssize_t) PyUnicode_GetSize( + PyObject *unicode /* Unicode object */ + ); + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 +/* Read a character from the string. */ + +PyAPI_FUNC(Py_UCS4) PyUnicode_ReadChar( + PyObject *unicode, + Py_ssize_t index + ); + +/* Write a character to the string. The string must have been created through + PyUnicode_New, must not be shared, and must not have been hashed yet. + + Return 0 on success, -1 on error. */ + +PyAPI_FUNC(int) PyUnicode_WriteChar( + PyObject *unicode, + Py_ssize_t index, + Py_UCS4 character + ); +#endif + +/* Resize a Unicode object. The length is the number of characters, except + if the kind of the string is PyUnicode_WCHAR_KIND: in this case, the length + is the number of Py_UNICODE characters. + + *unicode is modified to point to the new (resized) object and 0 + returned on success. + + Try to resize the string in place (which is usually faster than allocating + a new string and copy characters), or create a new string. + + Error handling is implemented as follows: an exception is set, -1 + is returned and *unicode left untouched. + + WARNING: The function doesn't check string content, the result may not be a + string in canonical representation. */ + +PyAPI_FUNC(int) PyUnicode_Resize( + PyObject **unicode, /* Pointer to the Unicode object */ + Py_ssize_t length /* New length */ + ); + +/* Decode obj to a Unicode object. + + bytes, bytearray and other bytes-like objects are decoded according to the + given encoding and error handler. The encoding and error handler can be + NULL to have the interface use UTF-8 and "strict". + + All other objects (including Unicode objects) raise an exception. + + The API returns NULL in case of an error. The caller is responsible + for decref'ing the returned objects. + +*/ + +PyAPI_FUNC(PyObject*) PyUnicode_FromEncodedObject( + PyObject *obj, /* Object */ + const char *encoding, /* encoding */ + const char *errors /* error handling */ + ); + +/* Copy an instance of a Unicode subtype to a new true Unicode object if + necessary. If obj is already a true Unicode object (not a subtype), return + the reference with *incremented* refcount. + + The API returns NULL in case of an error. The caller is responsible + for decref'ing the returned objects. + +*/ + +PyAPI_FUNC(PyObject*) PyUnicode_FromObject( + PyObject *obj /* Object */ + ); + +PyAPI_FUNC(PyObject *) PyUnicode_FromFormatV( + const char *format, /* ASCII-encoded string */ + va_list vargs + ); +PyAPI_FUNC(PyObject *) PyUnicode_FromFormat( + const char *format, /* ASCII-encoded string */ + ... + ); + +PyAPI_FUNC(void) PyUnicode_InternInPlace(PyObject **); +PyAPI_FUNC(PyObject *) PyUnicode_InternFromString( + const char *u /* UTF-8 encoded string */ + ); + +// PyUnicode_InternImmortal() is deprecated since Python 3.10 +// and will be removed in Python 3.12. Use PyUnicode_InternInPlace() instead. +Py_DEPRECATED(3.10) PyAPI_FUNC(void) PyUnicode_InternImmortal(PyObject **); + +/* --- wchar_t support for platforms which support it --------------------- */ + +#ifdef HAVE_WCHAR_H + +/* Create a Unicode Object from the wchar_t buffer w of the given + size. + + The buffer is copied into the new object. */ + +PyAPI_FUNC(PyObject*) PyUnicode_FromWideChar( + const wchar_t *w, /* wchar_t buffer */ + Py_ssize_t size /* size of buffer */ + ); + +/* Copies the Unicode Object contents into the wchar_t buffer w. At + most size wchar_t characters are copied. + + Note that the resulting wchar_t string may or may not be + 0-terminated. It is the responsibility of the caller to make sure + that the wchar_t string is 0-terminated in case this is required by + the application. + + Returns the number of wchar_t characters copied (excluding a + possibly trailing 0-termination character) or -1 in case of an + error. */ + +PyAPI_FUNC(Py_ssize_t) PyUnicode_AsWideChar( + PyObject *unicode, /* Unicode object */ + wchar_t *w, /* wchar_t buffer */ + Py_ssize_t size /* size of buffer */ + ); + +/* Convert the Unicode object to a wide character string. The output string + always ends with a nul character. If size is not NULL, write the number of + wide characters (excluding the null character) into *size. + + Returns a buffer allocated by PyMem_Malloc() (use PyMem_Free() to free it) + on success. On error, returns NULL, *size is undefined and raises a + MemoryError. */ + +PyAPI_FUNC(wchar_t*) PyUnicode_AsWideCharString( + PyObject *unicode, /* Unicode object */ + Py_ssize_t *size /* number of characters of the result */ + ); + +#endif + +/* --- Unicode ordinals --------------------------------------------------- */ + +/* Create a Unicode Object from the given Unicode code point ordinal. + + The ordinal must be in range(0x110000). A ValueError is + raised in case it is not. + +*/ + +PyAPI_FUNC(PyObject*) PyUnicode_FromOrdinal(int ordinal); + +/* === Builtin Codecs ===================================================== + + Many of these APIs take two arguments encoding and errors. These + parameters encoding and errors have the same semantics as the ones + of the builtin str() API. + + Setting encoding to NULL causes the default encoding (UTF-8) to be used. + + Error handling is set by errors which may also be set to NULL + meaning to use the default handling defined for the codec. Default + error handling for all builtin codecs is "strict" (ValueErrors are + raised). + + The codecs all use a similar interface. Only deviation from the + generic ones are documented. + +*/ + +/* --- Manage the default encoding ---------------------------------------- */ + +/* Returns "utf-8". */ +PyAPI_FUNC(const char*) PyUnicode_GetDefaultEncoding(void); + +/* --- Generic Codecs ----------------------------------------------------- */ + +/* Create a Unicode object by decoding the encoded string s of the + given size. */ + +PyAPI_FUNC(PyObject*) PyUnicode_Decode( + const char *s, /* encoded string */ + Py_ssize_t size, /* size of buffer */ + const char *encoding, /* encoding */ + const char *errors /* error handling */ + ); + +/* Decode a Unicode object unicode and return the result as Python + object. + + This API is DEPRECATED. The only supported standard encoding is rot13. + Use PyCodec_Decode() to decode with rot13 and non-standard codecs + that decode from str. */ + +Py_DEPRECATED(3.6) PyAPI_FUNC(PyObject*) PyUnicode_AsDecodedObject( + PyObject *unicode, /* Unicode object */ + const char *encoding, /* encoding */ + const char *errors /* error handling */ + ); + +/* Decode a Unicode object unicode and return the result as Unicode + object. + + This API is DEPRECATED. The only supported standard encoding is rot13. + Use PyCodec_Decode() to decode with rot13 and non-standard codecs + that decode from str to str. */ + +Py_DEPRECATED(3.6) PyAPI_FUNC(PyObject*) PyUnicode_AsDecodedUnicode( + PyObject *unicode, /* Unicode object */ + const char *encoding, /* encoding */ + const char *errors /* error handling */ + ); + +/* Encodes a Unicode object and returns the result as Python + object. + + This API is DEPRECATED. It is superseded by PyUnicode_AsEncodedString() + since all standard encodings (except rot13) encode str to bytes. + Use PyCodec_Encode() for encoding with rot13 and non-standard codecs + that encode form str to non-bytes. */ + +Py_DEPRECATED(3.6) PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedObject( + PyObject *unicode, /* Unicode object */ + const char *encoding, /* encoding */ + const char *errors /* error handling */ + ); + +/* Encodes a Unicode object and returns the result as Python string + object. */ + +PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedString( + PyObject *unicode, /* Unicode object */ + const char *encoding, /* encoding */ + const char *errors /* error handling */ + ); + +/* Encodes a Unicode object and returns the result as Unicode + object. + + This API is DEPRECATED. The only supported standard encodings is rot13. + Use PyCodec_Encode() to encode with rot13 and non-standard codecs + that encode from str to str. */ + +Py_DEPRECATED(3.6) PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedUnicode( + PyObject *unicode, /* Unicode object */ + const char *encoding, /* encoding */ + const char *errors /* error handling */ + ); + +/* Build an encoding map. */ + +PyAPI_FUNC(PyObject*) PyUnicode_BuildEncodingMap( + PyObject* string /* 256 character map */ + ); + +/* --- UTF-7 Codecs ------------------------------------------------------- */ + +PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF7( + const char *string, /* UTF-7 encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors /* error handling */ + ); + +PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF7Stateful( + const char *string, /* UTF-7 encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors, /* error handling */ + Py_ssize_t *consumed /* bytes consumed */ + ); + +/* --- UTF-8 Codecs ------------------------------------------------------- */ + +PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF8( + const char *string, /* UTF-8 encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors /* error handling */ + ); + +PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF8Stateful( + const char *string, /* UTF-8 encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors, /* error handling */ + Py_ssize_t *consumed /* bytes consumed */ + ); + +PyAPI_FUNC(PyObject*) PyUnicode_AsUTF8String( + PyObject *unicode /* Unicode object */ + ); + +/* Returns a pointer to the default encoding (UTF-8) of the + Unicode object unicode and the size of the encoded representation + in bytes stored in *size. + + In case of an error, no *size is set. + + This function caches the UTF-8 encoded string in the unicodeobject + and subsequent calls will return the same string. The memory is released + when the unicodeobject is deallocated. +*/ + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 +PyAPI_FUNC(const char *) PyUnicode_AsUTF8AndSize( + PyObject *unicode, + Py_ssize_t *size); +#endif + +/* --- UTF-32 Codecs ------------------------------------------------------ */ + +/* Decodes length bytes from a UTF-32 encoded buffer string and returns + the corresponding Unicode object. + + errors (if non-NULL) defines the error handling. It defaults + to "strict". + + If byteorder is non-NULL, the decoder starts decoding using the + given byte order: + + *byteorder == -1: little endian + *byteorder == 0: native order + *byteorder == 1: big endian + + In native mode, the first four bytes of the stream are checked for a + BOM mark. If found, the BOM mark is analysed, the byte order + adjusted and the BOM skipped. In the other modes, no BOM mark + interpretation is done. After completion, *byteorder is set to the + current byte order at the end of input data. + + If byteorder is NULL, the codec starts in native order mode. + +*/ + +PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF32( + const char *string, /* UTF-32 encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors, /* error handling */ + int *byteorder /* pointer to byteorder to use + 0=native;-1=LE,1=BE; updated on + exit */ + ); + +PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF32Stateful( + const char *string, /* UTF-32 encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors, /* error handling */ + int *byteorder, /* pointer to byteorder to use + 0=native;-1=LE,1=BE; updated on + exit */ + Py_ssize_t *consumed /* bytes consumed */ + ); + +/* Returns a Python string using the UTF-32 encoding in native byte + order. The string always starts with a BOM mark. */ + +PyAPI_FUNC(PyObject*) PyUnicode_AsUTF32String( + PyObject *unicode /* Unicode object */ + ); + +/* Returns a Python string object holding the UTF-32 encoded value of + the Unicode data. + + If byteorder is not 0, output is written according to the following + byte order: + + byteorder == -1: little endian + byteorder == 0: native byte order (writes a BOM mark) + byteorder == 1: big endian + + If byteorder is 0, the output string will always start with the + Unicode BOM mark (U+FEFF). In the other two modes, no BOM mark is + prepended. + +*/ + +/* --- UTF-16 Codecs ------------------------------------------------------ */ + +/* Decodes length bytes from a UTF-16 encoded buffer string and returns + the corresponding Unicode object. + + errors (if non-NULL) defines the error handling. It defaults + to "strict". + + If byteorder is non-NULL, the decoder starts decoding using the + given byte order: + + *byteorder == -1: little endian + *byteorder == 0: native order + *byteorder == 1: big endian + + In native mode, the first two bytes of the stream are checked for a + BOM mark. If found, the BOM mark is analysed, the byte order + adjusted and the BOM skipped. In the other modes, no BOM mark + interpretation is done. After completion, *byteorder is set to the + current byte order at the end of input data. + + If byteorder is NULL, the codec starts in native order mode. + +*/ + +PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF16( + const char *string, /* UTF-16 encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors, /* error handling */ + int *byteorder /* pointer to byteorder to use + 0=native;-1=LE,1=BE; updated on + exit */ + ); + +PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF16Stateful( + const char *string, /* UTF-16 encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors, /* error handling */ + int *byteorder, /* pointer to byteorder to use + 0=native;-1=LE,1=BE; updated on + exit */ + Py_ssize_t *consumed /* bytes consumed */ + ); + +/* Returns a Python string using the UTF-16 encoding in native byte + order. The string always starts with a BOM mark. */ + +PyAPI_FUNC(PyObject*) PyUnicode_AsUTF16String( + PyObject *unicode /* Unicode object */ + ); + +/* --- Unicode-Escape Codecs ---------------------------------------------- */ + +PyAPI_FUNC(PyObject*) PyUnicode_DecodeUnicodeEscape( + const char *string, /* Unicode-Escape encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors /* error handling */ + ); + +PyAPI_FUNC(PyObject*) PyUnicode_AsUnicodeEscapeString( + PyObject *unicode /* Unicode object */ + ); + +/* --- Raw-Unicode-Escape Codecs ------------------------------------------ */ + +PyAPI_FUNC(PyObject*) PyUnicode_DecodeRawUnicodeEscape( + const char *string, /* Raw-Unicode-Escape encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors /* error handling */ + ); + +PyAPI_FUNC(PyObject*) PyUnicode_AsRawUnicodeEscapeString( + PyObject *unicode /* Unicode object */ + ); + +/* --- Latin-1 Codecs ----------------------------------------------------- + + Note: Latin-1 corresponds to the first 256 Unicode ordinals. */ + +PyAPI_FUNC(PyObject*) PyUnicode_DecodeLatin1( + const char *string, /* Latin-1 encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors /* error handling */ + ); + +PyAPI_FUNC(PyObject*) PyUnicode_AsLatin1String( + PyObject *unicode /* Unicode object */ + ); + +/* --- ASCII Codecs ------------------------------------------------------- + + Only 7-bit ASCII data is excepted. All other codes generate errors. + +*/ + +PyAPI_FUNC(PyObject*) PyUnicode_DecodeASCII( + const char *string, /* ASCII encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors /* error handling */ + ); + +PyAPI_FUNC(PyObject*) PyUnicode_AsASCIIString( + PyObject *unicode /* Unicode object */ + ); + +/* --- Character Map Codecs ----------------------------------------------- + + This codec uses mappings to encode and decode characters. + + Decoding mappings must map byte ordinals (integers in the range from 0 to + 255) to Unicode strings, integers (which are then interpreted as Unicode + ordinals) or None. Unmapped data bytes (ones which cause a LookupError) + as well as mapped to None, 0xFFFE or '\ufffe' are treated as "undefined + mapping" and cause an error. + + Encoding mappings must map Unicode ordinal integers to bytes objects, + integers in the range from 0 to 255 or None. Unmapped character + ordinals (ones which cause a LookupError) as well as mapped to + None are treated as "undefined mapping" and cause an error. + +*/ + +PyAPI_FUNC(PyObject*) PyUnicode_DecodeCharmap( + const char *string, /* Encoded string */ + Py_ssize_t length, /* size of string */ + PyObject *mapping, /* decoding mapping */ + const char *errors /* error handling */ + ); + +PyAPI_FUNC(PyObject*) PyUnicode_AsCharmapString( + PyObject *unicode, /* Unicode object */ + PyObject *mapping /* encoding mapping */ + ); + +/* --- MBCS codecs for Windows -------------------------------------------- */ + +#ifdef MS_WINDOWS +PyAPI_FUNC(PyObject*) PyUnicode_DecodeMBCS( + const char *string, /* MBCS encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors /* error handling */ + ); + +PyAPI_FUNC(PyObject*) PyUnicode_DecodeMBCSStateful( + const char *string, /* MBCS encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors, /* error handling */ + Py_ssize_t *consumed /* bytes consumed */ + ); + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 +PyAPI_FUNC(PyObject*) PyUnicode_DecodeCodePageStateful( + int code_page, /* code page number */ + const char *string, /* encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors, /* error handling */ + Py_ssize_t *consumed /* bytes consumed */ + ); +#endif + +PyAPI_FUNC(PyObject*) PyUnicode_AsMBCSString( + PyObject *unicode /* Unicode object */ + ); + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 +PyAPI_FUNC(PyObject*) PyUnicode_EncodeCodePage( + int code_page, /* code page number */ + PyObject *unicode, /* Unicode object */ + const char *errors /* error handling */ + ); +#endif + +#endif /* MS_WINDOWS */ + +/* --- Locale encoding --------------------------------------------------- */ + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 +/* Decode a string from the current locale encoding. The decoder is strict if + *surrogateescape* is equal to zero, otherwise it uses the 'surrogateescape' + error handler (PEP 383) to escape undecodable bytes. If a byte sequence can + be decoded as a surrogate character and *surrogateescape* is not equal to + zero, the byte sequence is escaped using the 'surrogateescape' error handler + instead of being decoded. *str* must end with a null character but cannot + contain embedded null characters. */ + +PyAPI_FUNC(PyObject*) PyUnicode_DecodeLocaleAndSize( + const char *str, + Py_ssize_t len, + const char *errors); + +/* Similar to PyUnicode_DecodeLocaleAndSize(), but compute the string + length using strlen(). */ + +PyAPI_FUNC(PyObject*) PyUnicode_DecodeLocale( + const char *str, + const char *errors); + +/* Encode a Unicode object to the current locale encoding. The encoder is + strict is *surrogateescape* is equal to zero, otherwise the + "surrogateescape" error handler is used. Return a bytes object. The string + cannot contain embedded null characters. */ + +PyAPI_FUNC(PyObject*) PyUnicode_EncodeLocale( + PyObject *unicode, + const char *errors + ); +#endif + +/* --- File system encoding ---------------------------------------------- */ + +/* ParseTuple converter: encode str objects to bytes using + PyUnicode_EncodeFSDefault(); bytes objects are output as-is. */ + +PyAPI_FUNC(int) PyUnicode_FSConverter(PyObject*, void*); + +/* ParseTuple converter: decode bytes objects to unicode using + PyUnicode_DecodeFSDefaultAndSize(); str objects are output as-is. */ + +PyAPI_FUNC(int) PyUnicode_FSDecoder(PyObject*, void*); + +/* Decode a null-terminated string using Py_FileSystemDefaultEncoding + and the "surrogateescape" error handler. + + If Py_FileSystemDefaultEncoding is not set, fall back to the locale + encoding. + + Use PyUnicode_DecodeFSDefaultAndSize() if the string length is known. +*/ + +PyAPI_FUNC(PyObject*) PyUnicode_DecodeFSDefault( + const char *s /* encoded string */ + ); + +/* Decode a string using Py_FileSystemDefaultEncoding + and the "surrogateescape" error handler. + + If Py_FileSystemDefaultEncoding is not set, fall back to the locale + encoding. +*/ + +PyAPI_FUNC(PyObject*) PyUnicode_DecodeFSDefaultAndSize( + const char *s, /* encoded string */ + Py_ssize_t size /* size */ + ); + +/* Encode a Unicode object to Py_FileSystemDefaultEncoding with the + "surrogateescape" error handler, and return bytes. + + If Py_FileSystemDefaultEncoding is not set, fall back to the locale + encoding. +*/ + +PyAPI_FUNC(PyObject*) PyUnicode_EncodeFSDefault( + PyObject *unicode + ); + +/* --- Methods & Slots ---------------------------------------------------- + + These are capable of handling Unicode objects and strings on input + (we refer to them as strings in the descriptions) and return + Unicode objects or integers as appropriate. */ + +/* Concat two strings giving a new Unicode string. */ + +PyAPI_FUNC(PyObject*) PyUnicode_Concat( + PyObject *left, /* Left string */ + PyObject *right /* Right string */ + ); + +/* Concat two strings and put the result in *pleft + (sets *pleft to NULL on error) */ + +PyAPI_FUNC(void) PyUnicode_Append( + PyObject **pleft, /* Pointer to left string */ + PyObject *right /* Right string */ + ); + +/* Concat two strings, put the result in *pleft and drop the right object + (sets *pleft to NULL on error) */ + +PyAPI_FUNC(void) PyUnicode_AppendAndDel( + PyObject **pleft, /* Pointer to left string */ + PyObject *right /* Right string */ + ); + +/* Split a string giving a list of Unicode strings. + + If sep is NULL, splitting will be done at all whitespace + substrings. Otherwise, splits occur at the given separator. + + At most maxsplit splits will be done. If negative, no limit is set. + + Separators are not included in the resulting list. + +*/ + +PyAPI_FUNC(PyObject*) PyUnicode_Split( + PyObject *s, /* String to split */ + PyObject *sep, /* String separator */ + Py_ssize_t maxsplit /* Maxsplit count */ + ); + +/* Dito, but split at line breaks. + + CRLF is considered to be one line break. Line breaks are not + included in the resulting list. */ + +PyAPI_FUNC(PyObject*) PyUnicode_Splitlines( + PyObject *s, /* String to split */ + int keepends /* If true, line end markers are included */ + ); + +/* Partition a string using a given separator. */ + +PyAPI_FUNC(PyObject*) PyUnicode_Partition( + PyObject *s, /* String to partition */ + PyObject *sep /* String separator */ + ); + +/* Partition a string using a given separator, searching from the end of the + string. */ + +PyAPI_FUNC(PyObject*) PyUnicode_RPartition( + PyObject *s, /* String to partition */ + PyObject *sep /* String separator */ + ); + +/* Split a string giving a list of Unicode strings. + + If sep is NULL, splitting will be done at all whitespace + substrings. Otherwise, splits occur at the given separator. + + At most maxsplit splits will be done. But unlike PyUnicode_Split + PyUnicode_RSplit splits from the end of the string. If negative, + no limit is set. + + Separators are not included in the resulting list. + +*/ + +PyAPI_FUNC(PyObject*) PyUnicode_RSplit( + PyObject *s, /* String to split */ + PyObject *sep, /* String separator */ + Py_ssize_t maxsplit /* Maxsplit count */ + ); + +/* Translate a string by applying a character mapping table to it and + return the resulting Unicode object. + + The mapping table must map Unicode ordinal integers to Unicode strings, + Unicode ordinal integers or None (causing deletion of the character). + + Mapping tables may be dictionaries or sequences. Unmapped character + ordinals (ones which cause a LookupError) are left untouched and + are copied as-is. + +*/ + +PyAPI_FUNC(PyObject *) PyUnicode_Translate( + PyObject *str, /* String */ + PyObject *table, /* Translate table */ + const char *errors /* error handling */ + ); + +/* Join a sequence of strings using the given separator and return + the resulting Unicode string. */ + +PyAPI_FUNC(PyObject*) PyUnicode_Join( + PyObject *separator, /* Separator string */ + PyObject *seq /* Sequence object */ + ); + +/* Return 1 if substr matches str[start:end] at the given tail end, 0 + otherwise. */ + +PyAPI_FUNC(Py_ssize_t) PyUnicode_Tailmatch( + PyObject *str, /* String */ + PyObject *substr, /* Prefix or Suffix string */ + Py_ssize_t start, /* Start index */ + Py_ssize_t end, /* Stop index */ + int direction /* Tail end: -1 prefix, +1 suffix */ + ); + +/* Return the first position of substr in str[start:end] using the + given search direction or -1 if not found. -2 is returned in case + an error occurred and an exception is set. */ + +PyAPI_FUNC(Py_ssize_t) PyUnicode_Find( + PyObject *str, /* String */ + PyObject *substr, /* Substring to find */ + Py_ssize_t start, /* Start index */ + Py_ssize_t end, /* Stop index */ + int direction /* Find direction: +1 forward, -1 backward */ + ); + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 +/* Like PyUnicode_Find, but search for single character only. */ +PyAPI_FUNC(Py_ssize_t) PyUnicode_FindChar( + PyObject *str, + Py_UCS4 ch, + Py_ssize_t start, + Py_ssize_t end, + int direction + ); +#endif + +/* Count the number of occurrences of substr in str[start:end]. */ + +PyAPI_FUNC(Py_ssize_t) PyUnicode_Count( + PyObject *str, /* String */ + PyObject *substr, /* Substring to count */ + Py_ssize_t start, /* Start index */ + Py_ssize_t end /* Stop index */ + ); + +/* Replace at most maxcount occurrences of substr in str with replstr + and return the resulting Unicode object. */ + +PyAPI_FUNC(PyObject *) PyUnicode_Replace( + PyObject *str, /* String */ + PyObject *substr, /* Substring to find */ + PyObject *replstr, /* Substring to replace */ + Py_ssize_t maxcount /* Max. number of replacements to apply; + -1 = all */ + ); + +/* Compare two strings and return -1, 0, 1 for less than, equal, + greater than resp. + Raise an exception and return -1 on error. */ + +PyAPI_FUNC(int) PyUnicode_Compare( + PyObject *left, /* Left string */ + PyObject *right /* Right string */ + ); + +/* Compare a Unicode object with C string and return -1, 0, 1 for less than, + equal, and greater than, respectively. It is best to pass only + ASCII-encoded strings, but the function interprets the input string as + ISO-8859-1 if it contains non-ASCII characters. + This function does not raise exceptions. */ + +PyAPI_FUNC(int) PyUnicode_CompareWithASCIIString( + PyObject *left, + const char *right /* ASCII-encoded string */ + ); + +/* Rich compare two strings and return one of the following: + + - NULL in case an exception was raised + - Py_True or Py_False for successful comparisons + - Py_NotImplemented in case the type combination is unknown + + Possible values for op: + + Py_GT, Py_GE, Py_EQ, Py_NE, Py_LT, Py_LE + +*/ + +PyAPI_FUNC(PyObject *) PyUnicode_RichCompare( + PyObject *left, /* Left string */ + PyObject *right, /* Right string */ + int op /* Operation: Py_EQ, Py_NE, Py_GT, etc. */ + ); + +/* Apply an argument tuple or dictionary to a format string and return + the resulting Unicode string. */ + +PyAPI_FUNC(PyObject *) PyUnicode_Format( + PyObject *format, /* Format string */ + PyObject *args /* Argument tuple or dictionary */ + ); + +/* Checks whether element is contained in container and return 1/0 + accordingly. + + element has to coerce to a one element Unicode string. -1 is + returned in case of an error. */ + +PyAPI_FUNC(int) PyUnicode_Contains( + PyObject *container, /* Container string */ + PyObject *element /* Element string */ + ); + +/* Checks whether argument is a valid identifier. */ + +PyAPI_FUNC(int) PyUnicode_IsIdentifier(PyObject *s); + +/* === Characters Type APIs =============================================== */ + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_UNICODEOBJECT_H +# include "cpython/unicodeobject.h" +# undef Py_CPYTHON_UNICODEOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_UNICODEOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/warnings.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/warnings.h new file mode 100644 index 0000000000000000000000000000000000000000..18ac1543a3ca9e1d5a100badc221a14d61a1d58f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/warnings.h @@ -0,0 +1,45 @@ +#ifndef Py_WARNINGS_H +#define Py_WARNINGS_H +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_FUNC(int) PyErr_WarnEx( + PyObject *category, + const char *message, /* UTF-8 encoded string */ + Py_ssize_t stack_level); + +PyAPI_FUNC(int) PyErr_WarnFormat( + PyObject *category, + Py_ssize_t stack_level, + const char *format, /* ASCII-encoded string */ + ...); + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000 +/* Emit a ResourceWarning warning */ +PyAPI_FUNC(int) PyErr_ResourceWarning( + PyObject *source, + Py_ssize_t stack_level, + const char *format, /* ASCII-encoded string */ + ...); +#endif + +PyAPI_FUNC(int) PyErr_WarnExplicit( + PyObject *category, + const char *message, /* UTF-8 encoded string */ + const char *filename, /* decoded from the filesystem encoding */ + int lineno, + const char *module, /* UTF-8 encoded string */ + PyObject *registry); + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_WARNINGS_H +# include "cpython/warnings.h" +# undef Py_CPYTHON_WARNINGS_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_WARNINGS_H */ + diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/weakrefobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/weakrefobject.h new file mode 100644 index 0000000000000000000000000000000000000000..f071e9c759a64142e1c33c4c81c1c853a42282ff --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/include/weakrefobject.h @@ -0,0 +1,42 @@ +/* Weak references objects for Python. */ + +#ifndef Py_WEAKREFOBJECT_H +#define Py_WEAKREFOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct _PyWeakReference PyWeakReference; + +PyAPI_DATA(PyTypeObject) _PyWeakref_RefType; +PyAPI_DATA(PyTypeObject) _PyWeakref_ProxyType; +PyAPI_DATA(PyTypeObject) _PyWeakref_CallableProxyType; + +#define PyWeakref_CheckRef(op) PyObject_TypeCheck(op, &_PyWeakref_RefType) +#define PyWeakref_CheckRefExact(op) \ + Py_IS_TYPE(op, &_PyWeakref_RefType) +#define PyWeakref_CheckProxy(op) \ + (Py_IS_TYPE(op, &_PyWeakref_ProxyType) || \ + Py_IS_TYPE(op, &_PyWeakref_CallableProxyType)) + +#define PyWeakref_Check(op) \ + (PyWeakref_CheckRef(op) || PyWeakref_CheckProxy(op)) + + +PyAPI_FUNC(PyObject *) PyWeakref_NewRef(PyObject *ob, + PyObject *callback); +PyAPI_FUNC(PyObject *) PyWeakref_NewProxy(PyObject *ob, + PyObject *callback); +PyAPI_FUNC(PyObject *) PyWeakref_GetObject(PyObject *ref); + + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_WEAKREFOBJECT_H +# include "cpython/weakrefobject.h" +# undef Py_CPYTHON_WEAKREFOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_WEAKREFOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/about.json b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/about.json new file mode 100644 index 0000000000000000000000000000000000000000..54c1d358607dac7e037efc0e9dfb3bca664a088c --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/about.json @@ -0,0 +1,319 @@ +{ + "channels": [ + "https://conda.anaconda.org/conda-forge" + ], + "conda_build_version": "26.1.0", + "conda_version": "26.1.1", + "description": "Python is a widely used high-level, general-purpose, interpreted, dynamic\nprogramming language. Its design philosophy emphasizes code\nreadability, and its syntax allows programmers to express concepts in\nfewer lines of code than would be possible in languages such as C++ or\nJava. The language provides constructs intended to enable clear programs\non both a small and large scale.\n", + "dev_url": "https://docs.python.org/devguide/", + "doc_source_url": "https://github.com/python/pythondotorg/blob/master/docs/source/index.rst", + "doc_url": "https://www.python.org/doc/versions/", + "env_vars": { + "CIO_TEST": "" + }, + "extra": { + "copy_test_source_files": true, + "feedstock-name": "python", + "final": true, + "flow_run_id": "azure_20260305.2.1", + "parent_recipe": { + "name": "python-split", + "path": "D:\\a\\1\\s\\recipe", + "version": "3.11.15" + }, + "recipe-maintainers": [ + "chrisburr", + "isuruf", + "jakirkham", + "mbargull", + "mingwandroid", + "msarahan", + "pelson", + "ocefpaf", + "scopatz", + "katietz", + "xhochy" + ], + "remote_url": "https://github.com/conda-forge/python-feedstock", + "sha": "a2cdf39f64e5f9a058b2741a7d840d5cac2fbed8" + }, + "home": "https://www.python.org/", + "identifiers": [], + "keywords": [], + "license": "Python-2.0", + "license_file": "LICENSE", + "root_pkgs": [ + "anaconda-auth 0.13.0 pyhd8ed1ab_0", + "anaconda-cli-base 0.8.1 pyhc364b38_1", + "anaconda-client 1.14.1 pyhcf101f3_0", + "annotated-doc 0.0.4 pyhcf101f3_0", + "annotated-types 0.7.0 pyhd8ed1ab_1", + "anyio 4.12.1 pyhcf101f3_0", + "archspec 0.2.5 pyhd8ed1ab_0", + "attrs 25.4.0 pyhcf101f3_1", + "backports 1.0 pyhd8ed1ab_5", + "backports.tarfile 1.2.0 pyhcf101f3_2", + "backports.zstd 1.3.0 py312h06d0912_0", + "beautifulsoup4 4.14.3 pyha770c72_0", + "boltons 25.0.0 pyhd8ed1ab_0", + "brotli-python 1.2.0 py312hc6d9e41_1", + "bzip2 1.0.8 h0ad9c76_9", + "ca-certificates 2026.2.25 h4c7d964_0", + "certifi 2026.2.25 pyhd8ed1ab_0", + "cffi 2.0.0 py312he06e257_1", + "chardet 5.2.0 pyhd8ed1ab_3", + "charset-normalizer 3.4.4 pyhd8ed1ab_0", + "click 8.3.1 pyha7b4d00_1", + "colorama 0.4.6 pyhd8ed1ab_1", + "conda 26.1.1 py312h2e8e312_0", + "conda-build 26.1.0 pyhe63316d_2", + "conda-env 2.6.0 1", + "conda-forge-ci-setup 4.24.2 py312h3368cd0_101", + "conda-forge-metadata 0.13.0 pyhcf101f3_0", + "conda-index 0.7.0 pyhd8ed1ab_0", + "conda-libmamba-solver 25.11.0 pyhd8ed1ab_1", + "conda-oci-mirror 0.2.3 pyhd8ed1ab_0", + "conda-package-handling 2.4.0 pyh7900ff3_2", + "conda-package-streaming 0.12.0 pyhd8ed1ab_0", + "cpp-expected 1.3.1 h477610d_0", + "cryptography 46.0.5 py312h232196e_0", + "defusedxml 0.7.1 pyhd8ed1ab_0", + "deprecated 1.3.1 pyhd8ed1ab_1", + "distro 1.9.0 pyhd8ed1ab_1", + "evalidate 2.0.5 pyhe01879c_0", + "exceptiongroup 1.3.1 pyhd8ed1ab_0", + "filelock 3.25.0 pyhd8ed1ab_0", + "fmt 12.1.0 h7f4e812_0", + "frozendict 2.4.7 py312he06e257_0", + "h11 0.16.0 pyhcf101f3_1", + "h2 4.3.0 pyhcf101f3_0", + "hpack 4.1.0 pyhd8ed1ab_0", + "httpcore 1.0.9 pyh29332c3_0", + "httpx 0.28.1 pyhd8ed1ab_0", + "hyperframe 6.1.0 pyhd8ed1ab_0", + "idna 3.11 pyhd8ed1ab_0", + "importlib-metadata 8.7.0 pyhe01879c_1", + "importlib_resources 6.5.2 pyhd8ed1ab_0", + "jaraco.classes 3.4.0 pyhcf101f3_3", + "jaraco.context 6.1.0 pyhcf101f3_0", + "jaraco.functools 4.4.0 pyhcf101f3_1", + "jinja2 3.1.6 pyhcf101f3_1", + "joblib 1.5.3 pyhd8ed1ab_0", + "jsonpatch 1.33 pyhd8ed1ab_1", + "jsonpointer 3.0.0 pyhcf101f3_3", + "jsonschema 4.26.0 pyhcf101f3_0", + "jsonschema-specifications 2025.9.1 pyhcf101f3_0", + "jupyter_core 5.9.1 pyh6dadd2b_0", + "keyring 25.7.0 pyh7428d3b_0", + "krb5 1.22.2 h0ea6238_0", + "lcms2 2.18 hf2c6c5f_0", + "lerc 4.0.0 h6470a55_1", + "libarchive 3.8.5 gpl_he24518a_100", + "libcurl 8.18.0 h8206538_1", + "libdeflate 1.25 h51727cc_0", + "libexpat 2.7.4 hac47afa_0", + "libffi 3.5.2 h3d046cb_0", + "libfreetype 2.14.1 h57928b3_0", + "libfreetype6 2.14.1 hdbac1cb_0", + "libgcc 15.2.0 h8ee18e1_18", + "libgomp 15.2.0 h8ee18e1_18", + "libiconv 1.18 hc1393d2_2", + "libjpeg-turbo 3.1.2 hfd05255_0", + "liblief 0.17.1 hac47afa_0", + "liblzma 5.8.2 hfd05255_0", + "libmamba 2.5.0 h06825f5_0", + "libmamba-spdlog 2.5.0 h9ae1bf1_0", + "libmambapy 2.5.0 py312h26e665a_0", + "libpng 1.6.55 h7351971_0", + "libsolv 0.7.35 h8883371_0", + "libsqlite 3.51.2 hf5d6505_0", + "libssh2 1.11.1 h9aa295b_0", + "libtiff 4.7.1 h8f73337_1", + "libwebp-base 1.6.0 h4d5522a_0", + "libwinpthread 12.0.0.r4.gg4f2fc60ca h57928b3_10", + "libxcb 1.17.0 h0e4246c_0", + "libxml2-16 2.15.2 h692994f_0", + "libxml2 2.15.2 h5d26750_0", + "libzlib 1.3.1 h2466b09_2", + "lz4-c 1.10.0 h2466b09_1", + "lzo 2.10 h6a83c73_1002", + "m2-bash 5.2.037.2 hc364b38_6", + "m2-brotli 1.1.0.2 hc364b38_6", + "m2-ca-certificates 20241223.1 hc364b38_6", + "m2-conda-epoch 20250515 0_x86_64", + "m2-coreutils 8.32.5 hc364b38_6", + "m2-curl 8.9.1.1 hc364b38_6", + "m2-db 6.2.32.5 hc364b38_6", + "m2-file 5.46.2 hc364b38_6", + "m2-filesystem 2025.02.23.1 hc364b38_10", + "m2-findutils 4.9.0.3 hc364b38_6", + "m2-gcc-libs 13.3.0.1 hc364b38_6", + "m2-gdbm 1.25.1 hc364b38_6", + "m2-git 2.49.0.1 hc364b38_6", + "m2-gmp 6.3.0.1 hc364b38_6", + "m2-gzip 1.14.1 hc364b38_6", + "m2-heimdal 7.8.0.5 hc364b38_6", + "m2-heimdal-libs 7.8.0.5 hc364b38_6", + "m2-info 7.2.1 hc364b38_6", + "m2-less 668.1 hc364b38_6", + "m2-libbz2 1.0.8.4 hc364b38_6", + "m2-libcbor 0.12.0.1 hc364b38_6", + "m2-libcurl 8.9.1.1 hc364b38_6", + "m2-libdb 6.2.32.5 hc364b38_6", + "m2-libedit 20240808_3.1.1 hc364b38_6", + "m2-libexpat 2.7.1.1 hc364b38_6", + "m2-libffi 3.4.8.1 hc364b38_6", + "m2-libfido2 1.16.0.1 hc364b38_6", + "m2-libgdbm 1.25.1 hc364b38_6", + "m2-libiconv 1.18.1 hc364b38_6", + "m2-libidn2 2.3.8.1 hc364b38_6", + "m2-libintl 0.22.5.1 hc364b38_6", + "m2-liblzma 5.8.1.1 hc364b38_6", + "m2-libnghttp2 1.65.0.1 hc364b38_6", + "m2-libopenssl 3.5.0.1 hc364b38_6", + "m2-libp11-kit 0.25.5.2 hc364b38_6", + "m2-libpcre2_8 10.45.1 hc364b38_6", + "m2-libpsl 0.21.5.2 hc364b38_6", + "m2-libreadline 8.2.013.1 hc364b38_6", + "m2-libsqlite 3.49.1.2 hc364b38_6", + "m2-libssh2 1.11.1.1 hc364b38_6", + "m2-libtasn1 4.20.0.1 hc364b38_6", + "m2-libunistring 1.3.1 hc364b38_6", + "m2-libxcrypt 4.4.38.1 hc364b38_6", + "m2-libzstd 1.5.7.1 hc364b38_6", + "m2-msys2-runtime 3.6.1.4 hc364b38_6", + "m2-nano 8.4.1 hc364b38_6", + "m2-ncurses 6.5.20240831.2 hc364b38_6", + "m2-openssh 9.9p2.1 hc364b38_6", + "m2-openssl 3.5.0.1 hc364b38_6", + "m2-p11-kit 0.25.5.2 hc364b38_6", + "m2-patch 2.7.6.3 hc364b38_6", + "m2-perl 5.38.4.2 hc364b38_6", + "m2-perl-authen-sasl 2.1800.1 hc364b38_6", + "m2-perl-clone 0.47.1 hc364b38_6", + "m2-perl-convert-binhex 1.125.2 hc364b38_6", + "m2-perl-encode-locale 1.05.2 hc364b38_6", + "m2-perl-error 0.17030.1 hc364b38_6", + "m2-perl-file-listing 6.16.1 hc364b38_6", + "m2-perl-html-parser 3.83.1 hc364b38_6", + "m2-perl-html-tagset 3.24.1 hc364b38_6", + "m2-perl-http-cookiejar 0.014.1 hc364b38_6", + "m2-perl-http-cookies 6.11.1 hc364b38_6", + "m2-perl-http-daemon 6.16.1 hc364b38_6", + "m2-perl-http-date 6.06.1 hc364b38_6", + "m2-perl-http-message 7.00.1 hc364b38_6", + "m2-perl-http-negotiate 6.01.3 hc364b38_6", + "m2-perl-io-html 1.004.2 hc364b38_6", + "m2-perl-io-socket-ip 0.41.2 hc364b38_6", + "m2-perl-io-socket-ssl 2.089.1 hc364b38_6", + "m2-perl-io-stringy 2.113.2 hc364b38_6", + "m2-perl-libwww 6.78.1 hc364b38_6", + "m2-perl-lwp-mediatypes 6.04.2 hc364b38_6", + "m2-perl-mailtools 2.22.1 hc364b38_6", + "m2-perl-mime-tools 5.515.1 hc364b38_6", + "m2-perl-net-http 6.23.1 hc364b38_6", + "m2-perl-net-smtp-ssl 1.04.2 hc364b38_6", + "m2-perl-net-ssleay 1.94.2 hc364b38_6", + "m2-perl-termreadkey 2.38.6 hc364b38_6", + "m2-perl-timedate 2.33.2 hc364b38_6", + "m2-perl-try-tiny 0.32.1 hc364b38_6", + "m2-perl-uri 5.31.1 hc364b38_6", + "m2-perl-www-robotrules 6.02.3 hc364b38_6", + "m2-sed 4.9.1 hc364b38_6", + "m2-zlib 1.3.1.1 hc364b38_6", + "mamba 2.5.0 hf588a56_0", + "markdown-it-py 4.0.0 pyhd8ed1ab_0", + "markupsafe 3.0.3 py312h05f76fc_1", + "mbedtls 3.6.3.1 he0c23c2_0", + "mdurl 0.1.2 pyhd8ed1ab_1", + "menuinst 2.4.2 py312hbb81ca0_0", + "more-itertools 10.8.0 pyhcf101f3_1", + "msgpack-python 1.1.2 py312hf90b1b7_1", + "nbformat 5.10.4 pyhd8ed1ab_1", + "nlohmann_json-abi 3.12.0 h0f90c79_1", + "openjpeg 2.5.4 h0e57b4f_0", + "openssl 3.6.1 hf411b9b_1", + "oras-py 0.1.14 pyhd8ed1ab_0", + "packaging 26.0 pyhcf101f3_0", + "pillow 12.1.1 py312h31f0997_0", + "pip 26.0.1 pyh8b19718_0", + "pkce 1.0.3 pyhd8ed1ab_1", + "pkginfo 1.12.1.2 pyhd8ed1ab_0", + "platformdirs 4.9.2 pyhcf101f3_0", + "pluggy 1.6.0 pyhf9edf01_1", + "psutil 7.2.2 py312he5662c2_0", + "pthread-stubs 0.4 h0e40799_1002", + "py-lief 0.17.1 py312hbb81ca0_0", + "pybind11-abi 11 hc364b38_1", + "pycosat 0.6.6 py312he06e257_3", + "pycparser 2.22 pyh29332c3_1", + "pydantic 2.12.5 pyhcf101f3_1", + "pydantic-core 2.41.5 py312hdabe01f_1", + "pydantic-settings 2.13.1 pyhd8ed1ab_0", + "pygments 2.19.2 pyhd8ed1ab_0", + "pyjwt 2.11.0 pyhd8ed1ab_0", + "pysocks 1.7.1 pyh09c184e_7", + "python 3.12.12 h0159041_2_cpython", + "python-dateutil 2.9.0.post0 pyhe01879c_2", + "python-dotenv 1.2.2 pyhcf101f3_0", + "python-fastjsonschema 2.21.2 pyhe01879c_0", + "python-libarchive-c 5.3 pyhe01879c_1", + "python_abi 3.12 8_cp312", + "pytz 2025.2 pyhd8ed1ab_0", + "pywin32 311 py312h829343e_1", + "pywin32-ctypes 0.2.3 py312h2e8e312_3", + "pyyaml 6.0.3 py312h05f76fc_1", + "rattler-build 0.58.4 he94b42d_0", + "rattler-build-conda-compat 1.4.11 pyhd8ed1ab_0", + "readchar 4.2.1 pyhe01879c_0", + "referencing 0.37.0 pyhcf101f3_0", + "reproc 14.2.5.post0 h2466b09_0", + "reproc-cpp 14.2.5.post0 he0c23c2_0", + "requests 2.32.5 pyhcf101f3_1", + "requests-toolbelt 1.0.0 pyhd8ed1ab_1", + "rich 14.3.3 pyhcf101f3_0", + "ripgrep 15.1.0 h77a83cd_0", + "rpds-py 0.30.0 py312hdabe01f_0", + "ruamel.yaml 0.18.17 py312he5662c2_2", + "ruamel.yaml.clib 0.2.15 py312he5662c2_1", + "semver 3.0.4 pyhcf101f3_1", + "setuptools 82.0.0 pyh332efcf_0", + "shellingham 1.5.4 pyhd8ed1ab_2", + "shyaml 0.6.2 pyhd3deb0d_0", + "simdjson 4.2.4 h49e36cd_0", + "six 1.17.0 pyhe01879c_1", + "sniffio 1.3.1 pyhd8ed1ab_2", + "soupsieve 2.8.3 pyhd8ed1ab_0", + "spdlog 1.17.0 h9f585f1_1", + "tk 8.6.13 h6ed50ae_3", + "tomli 2.4.0 pyhcf101f3_0", + "tomlkit 0.14.0 pyha770c72_0", + "tqdm 4.67.3 pyha7b4d00_0", + "traitlets 5.14.3 pyhd8ed1ab_1", + "truststore 0.10.4 pyhcf101f3_0", + "typer 0.24.0 pyhcf101f3_0", + "typing-extensions 4.15.0 h396c80c_0", + "typing-inspection 0.4.2 pyhd8ed1ab_1", + "typing_extensions 4.15.0 pyhcf101f3_0", + "tzdata 2025c hc9c84f9_1", + "ucrt 10.0.26100.0 h57928b3_0", + "urllib3 2.6.3 pyhd8ed1ab_0", + "vc 14.3 h41ae7f8_34", + "vc14_runtime 14.44.35208 h818238b_34", + "vcomp14 14.44.35208 h818238b_34", + "wheel 0.46.3 pyhd8ed1ab_0", + "win_inet_pton 1.1.0 pyh7428d3b_8", + "wrapt 2.1.1 py312he06e257_0", + "xorg-libxau 1.0.12 hba3369d_1", + "xorg-libxdmcp 1.1.5 hba3369d_1", + "yaml 0.2.5 h6a83c73_3", + "yaml-cpp 0.8.0 he0c23c2_0", + "zipp 3.23.0 pyhcf101f3_1", + "zlib-ng 2.3.3 h0261ad2_1", + "zstandard 0.25.0 py312he5662c2_1", + "zstd 1.5.7 h534d264_6", + "_openmp_mutex 4.5 20_gnu" + ], + "summary": "General purpose programming language", + "tags": [] +} \ No newline at end of file diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/files b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/files new file mode 100644 index 0000000000000000000000000000000000000000..4ca45df1978b7a360ba866f9a39007be7df2d5be --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/files @@ -0,0 +1,2407 @@ +DLLs/_asyncio.pyd +DLLs/_bz2.pyd +DLLs/_ctypes.pyd +DLLs/_ctypes_test.pyd +DLLs/_decimal.pyd +DLLs/_elementtree.pyd +DLLs/_hashlib.pyd +DLLs/_lzma.pyd +DLLs/_msi.pyd +DLLs/_multiprocessing.pyd +DLLs/_overlapped.pyd +DLLs/_queue.pyd +DLLs/_socket.pyd +DLLs/_sqlite3.pyd +DLLs/_ssl.pyd +DLLs/_testbuffer.pyd +DLLs/_testcapi.pyd +DLLs/_testconsole.pyd +DLLs/_testimportmultiple.pyd +DLLs/_testinternalcapi.pyd +DLLs/_testmultiphase.pyd +DLLs/_tkinter.pyd +DLLs/_uuid.pyd +DLLs/_zoneinfo.pyd +DLLs/py.ico +DLLs/pyc.ico +DLLs/pyexpat.pyd +DLLs/select.pyd +DLLs/unicodedata.pyd +DLLs/winsound.pyd +DLLs/xxlimited.pyd +DLLs/xxlimited_35.pyd +LICENSE_PYTHON.txt +Lib/__future__.py +Lib/__hello__.py +Lib/__phello__/__init__.py +Lib/__phello__/__pycache__/__init__.cpython-311.pyc +Lib/__phello__/__pycache__/spam.cpython-311.pyc +Lib/__phello__/ham/__init__.py +Lib/__phello__/ham/__pycache__/__init__.cpython-311.pyc +Lib/__phello__/ham/__pycache__/eggs.cpython-311.pyc +Lib/__phello__/ham/eggs.py +Lib/__phello__/spam.py +Lib/__pycache__/__future__.cpython-311.pyc +Lib/__pycache__/__hello__.cpython-311.pyc +Lib/__pycache__/_aix_support.cpython-311.pyc +Lib/__pycache__/_bootsubprocess.cpython-311.pyc +Lib/__pycache__/_collections_abc.cpython-311.pyc +Lib/__pycache__/_compat_pickle.cpython-311.pyc +Lib/__pycache__/_compression.cpython-311.pyc +Lib/__pycache__/_markupbase.cpython-311.pyc +Lib/__pycache__/_osx_support.cpython-311.pyc +Lib/__pycache__/_py_abc.cpython-311.pyc +Lib/__pycache__/_pydecimal.cpython-311.pyc +Lib/__pycache__/_pyio.cpython-311.pyc +Lib/__pycache__/_sitebuiltins.cpython-311.pyc +Lib/__pycache__/_strptime.cpython-311.pyc +Lib/__pycache__/_threading_local.cpython-311.pyc +Lib/__pycache__/_weakrefset.cpython-311.pyc +Lib/__pycache__/abc.cpython-311.pyc +Lib/__pycache__/aifc.cpython-311.pyc +Lib/__pycache__/antigravity.cpython-311.pyc +Lib/__pycache__/argparse.cpython-311.pyc +Lib/__pycache__/ast.cpython-311.pyc +Lib/__pycache__/asynchat.cpython-311.pyc +Lib/__pycache__/asyncore.cpython-311.pyc +Lib/__pycache__/base64.cpython-311.pyc +Lib/__pycache__/bdb.cpython-311.pyc +Lib/__pycache__/bisect.cpython-311.pyc +Lib/__pycache__/bz2.cpython-311.pyc +Lib/__pycache__/cProfile.cpython-311.pyc +Lib/__pycache__/calendar.cpython-311.pyc +Lib/__pycache__/cgi.cpython-311.pyc +Lib/__pycache__/cgitb.cpython-311.pyc +Lib/__pycache__/chunk.cpython-311.pyc +Lib/__pycache__/cmd.cpython-311.pyc +Lib/__pycache__/code.cpython-311.pyc +Lib/__pycache__/codecs.cpython-311.pyc +Lib/__pycache__/codeop.cpython-311.pyc +Lib/__pycache__/colorsys.cpython-311.pyc +Lib/__pycache__/compileall.cpython-311.pyc +Lib/__pycache__/configparser.cpython-311.pyc +Lib/__pycache__/contextlib.cpython-311.pyc +Lib/__pycache__/contextvars.cpython-311.pyc +Lib/__pycache__/copy.cpython-311.pyc +Lib/__pycache__/copyreg.cpython-311.pyc +Lib/__pycache__/crypt.cpython-311.pyc +Lib/__pycache__/csv.cpython-311.pyc +Lib/__pycache__/dataclasses.cpython-311.pyc +Lib/__pycache__/datetime.cpython-311.pyc +Lib/__pycache__/decimal.cpython-311.pyc +Lib/__pycache__/difflib.cpython-311.pyc +Lib/__pycache__/dis.cpython-311.pyc +Lib/__pycache__/doctest.cpython-311.pyc +Lib/__pycache__/enum.cpython-311.pyc +Lib/__pycache__/filecmp.cpython-311.pyc +Lib/__pycache__/fileinput.cpython-311.pyc +Lib/__pycache__/fnmatch.cpython-311.pyc +Lib/__pycache__/fractions.cpython-311.pyc +Lib/__pycache__/ftplib.cpython-311.pyc +Lib/__pycache__/functools.cpython-311.pyc +Lib/__pycache__/genericpath.cpython-311.pyc +Lib/__pycache__/getopt.cpython-311.pyc +Lib/__pycache__/getpass.cpython-311.pyc +Lib/__pycache__/gettext.cpython-311.pyc +Lib/__pycache__/glob.cpython-311.pyc +Lib/__pycache__/graphlib.cpython-311.pyc +Lib/__pycache__/gzip.cpython-311.pyc +Lib/__pycache__/hashlib.cpython-311.pyc +Lib/__pycache__/heapq.cpython-311.pyc +Lib/__pycache__/hmac.cpython-311.pyc +Lib/__pycache__/imaplib.cpython-311.pyc +Lib/__pycache__/imghdr.cpython-311.pyc +Lib/__pycache__/imp.cpython-311.pyc +Lib/__pycache__/inspect.cpython-311.pyc +Lib/__pycache__/io.cpython-311.pyc +Lib/__pycache__/ipaddress.cpython-311.pyc +Lib/__pycache__/keyword.cpython-311.pyc +Lib/__pycache__/linecache.cpython-311.pyc +Lib/__pycache__/locale.cpython-311.pyc +Lib/__pycache__/lzma.cpython-311.pyc +Lib/__pycache__/mailbox.cpython-311.pyc +Lib/__pycache__/mailcap.cpython-311.pyc +Lib/__pycache__/mimetypes.cpython-311.pyc +Lib/__pycache__/modulefinder.cpython-311.pyc +Lib/__pycache__/netrc.cpython-311.pyc +Lib/__pycache__/nntplib.cpython-311.pyc +Lib/__pycache__/ntpath.cpython-311.pyc +Lib/__pycache__/nturl2path.cpython-311.pyc +Lib/__pycache__/numbers.cpython-311.pyc +Lib/__pycache__/opcode.cpython-311.pyc +Lib/__pycache__/operator.cpython-311.pyc +Lib/__pycache__/optparse.cpython-311.pyc +Lib/__pycache__/os.cpython-311.pyc +Lib/__pycache__/pathlib.cpython-311.pyc +Lib/__pycache__/pdb.cpython-311.pyc +Lib/__pycache__/pickle.cpython-311.pyc +Lib/__pycache__/pickletools.cpython-311.pyc +Lib/__pycache__/pipes.cpython-311.pyc +Lib/__pycache__/pkgutil.cpython-311.pyc +Lib/__pycache__/platform.cpython-311.pyc +Lib/__pycache__/plistlib.cpython-311.pyc +Lib/__pycache__/poplib.cpython-311.pyc +Lib/__pycache__/posixpath.cpython-311.pyc +Lib/__pycache__/pprint.cpython-311.pyc +Lib/__pycache__/profile.cpython-311.pyc +Lib/__pycache__/pstats.cpython-311.pyc +Lib/__pycache__/pty.cpython-311.pyc +Lib/__pycache__/py_compile.cpython-311.pyc +Lib/__pycache__/pyclbr.cpython-311.pyc +Lib/__pycache__/pydoc.cpython-311.pyc +Lib/__pycache__/queue.cpython-311.pyc +Lib/__pycache__/quopri.cpython-311.pyc +Lib/__pycache__/random.cpython-311.pyc +Lib/__pycache__/reprlib.cpython-311.pyc +Lib/__pycache__/rlcompleter.cpython-311.pyc +Lib/__pycache__/runpy.cpython-311.pyc +Lib/__pycache__/sched.cpython-311.pyc +Lib/__pycache__/secrets.cpython-311.pyc +Lib/__pycache__/selectors.cpython-311.pyc +Lib/__pycache__/shelve.cpython-311.pyc +Lib/__pycache__/shlex.cpython-311.pyc +Lib/__pycache__/shutil.cpython-311.pyc +Lib/__pycache__/signal.cpython-311.pyc +Lib/__pycache__/site.cpython-311.pyc +Lib/__pycache__/smtpd.cpython-311.pyc +Lib/__pycache__/smtplib.cpython-311.pyc +Lib/__pycache__/sndhdr.cpython-311.pyc +Lib/__pycache__/socket.cpython-311.pyc +Lib/__pycache__/socketserver.cpython-311.pyc +Lib/__pycache__/sre_compile.cpython-311.pyc +Lib/__pycache__/sre_constants.cpython-311.pyc +Lib/__pycache__/sre_parse.cpython-311.pyc +Lib/__pycache__/ssl.cpython-311.pyc +Lib/__pycache__/stat.cpython-311.pyc +Lib/__pycache__/statistics.cpython-311.pyc +Lib/__pycache__/string.cpython-311.pyc +Lib/__pycache__/stringprep.cpython-311.pyc +Lib/__pycache__/struct.cpython-311.pyc +Lib/__pycache__/subprocess.cpython-311.pyc +Lib/__pycache__/sunau.cpython-311.pyc +Lib/__pycache__/symtable.cpython-311.pyc +Lib/__pycache__/sysconfig.cpython-311.pyc +Lib/__pycache__/tabnanny.cpython-311.pyc +Lib/__pycache__/tarfile.cpython-311.pyc +Lib/__pycache__/telnetlib.cpython-311.pyc +Lib/__pycache__/tempfile.cpython-311.pyc +Lib/__pycache__/textwrap.cpython-311.pyc +Lib/__pycache__/this.cpython-311.pyc +Lib/__pycache__/threading.cpython-311.pyc +Lib/__pycache__/timeit.cpython-311.pyc +Lib/__pycache__/token.cpython-311.pyc +Lib/__pycache__/tokenize.cpython-311.pyc +Lib/__pycache__/trace.cpython-311.pyc +Lib/__pycache__/traceback.cpython-311.pyc +Lib/__pycache__/tracemalloc.cpython-311.pyc +Lib/__pycache__/tty.cpython-311.pyc +Lib/__pycache__/turtle.cpython-311.pyc +Lib/__pycache__/types.cpython-311.pyc +Lib/__pycache__/typing.cpython-311.pyc +Lib/__pycache__/uu.cpython-311.pyc +Lib/__pycache__/uuid.cpython-311.pyc +Lib/__pycache__/warnings.cpython-311.pyc +Lib/__pycache__/wave.cpython-311.pyc +Lib/__pycache__/weakref.cpython-311.pyc +Lib/__pycache__/webbrowser.cpython-311.pyc +Lib/__pycache__/xdrlib.cpython-311.pyc +Lib/__pycache__/zipapp.cpython-311.pyc +Lib/__pycache__/zipfile.cpython-311.pyc +Lib/__pycache__/zipimport.cpython-311.pyc +Lib/_aix_support.py +Lib/_bootsubprocess.py +Lib/_collections_abc.py +Lib/_compat_pickle.py +Lib/_compression.py +Lib/_markupbase.py +Lib/_osx_support.py +Lib/_py_abc.py +Lib/_pydecimal.py +Lib/_pyio.py +Lib/_sitebuiltins.py +Lib/_strptime.py +Lib/_threading_local.py +Lib/_weakrefset.py +Lib/abc.py +Lib/aifc.py +Lib/antigravity.py +Lib/argparse.py +Lib/ast.py +Lib/asynchat.py +Lib/asyncio/__init__.py +Lib/asyncio/__main__.py +Lib/asyncio/__pycache__/__init__.cpython-311.pyc +Lib/asyncio/__pycache__/__main__.cpython-311.pyc +Lib/asyncio/__pycache__/base_events.cpython-311.pyc +Lib/asyncio/__pycache__/base_futures.cpython-311.pyc +Lib/asyncio/__pycache__/base_subprocess.cpython-311.pyc +Lib/asyncio/__pycache__/base_tasks.cpython-311.pyc +Lib/asyncio/__pycache__/constants.cpython-311.pyc +Lib/asyncio/__pycache__/coroutines.cpython-311.pyc +Lib/asyncio/__pycache__/events.cpython-311.pyc +Lib/asyncio/__pycache__/exceptions.cpython-311.pyc +Lib/asyncio/__pycache__/format_helpers.cpython-311.pyc +Lib/asyncio/__pycache__/futures.cpython-311.pyc +Lib/asyncio/__pycache__/locks.cpython-311.pyc +Lib/asyncio/__pycache__/log.cpython-311.pyc +Lib/asyncio/__pycache__/mixins.cpython-311.pyc +Lib/asyncio/__pycache__/proactor_events.cpython-311.pyc +Lib/asyncio/__pycache__/protocols.cpython-311.pyc +Lib/asyncio/__pycache__/queues.cpython-311.pyc +Lib/asyncio/__pycache__/runners.cpython-311.pyc +Lib/asyncio/__pycache__/selector_events.cpython-311.pyc +Lib/asyncio/__pycache__/sslproto.cpython-311.pyc +Lib/asyncio/__pycache__/staggered.cpython-311.pyc +Lib/asyncio/__pycache__/streams.cpython-311.pyc +Lib/asyncio/__pycache__/subprocess.cpython-311.pyc +Lib/asyncio/__pycache__/taskgroups.cpython-311.pyc +Lib/asyncio/__pycache__/tasks.cpython-311.pyc +Lib/asyncio/__pycache__/threads.cpython-311.pyc +Lib/asyncio/__pycache__/timeouts.cpython-311.pyc +Lib/asyncio/__pycache__/transports.cpython-311.pyc +Lib/asyncio/__pycache__/trsock.cpython-311.pyc +Lib/asyncio/__pycache__/unix_events.cpython-311.pyc +Lib/asyncio/__pycache__/windows_events.cpython-311.pyc +Lib/asyncio/__pycache__/windows_utils.cpython-311.pyc +Lib/asyncio/base_events.py +Lib/asyncio/base_futures.py +Lib/asyncio/base_subprocess.py +Lib/asyncio/base_tasks.py +Lib/asyncio/constants.py +Lib/asyncio/coroutines.py +Lib/asyncio/events.py +Lib/asyncio/exceptions.py +Lib/asyncio/format_helpers.py +Lib/asyncio/futures.py +Lib/asyncio/locks.py +Lib/asyncio/log.py +Lib/asyncio/mixins.py +Lib/asyncio/proactor_events.py +Lib/asyncio/protocols.py +Lib/asyncio/queues.py +Lib/asyncio/runners.py +Lib/asyncio/selector_events.py +Lib/asyncio/sslproto.py +Lib/asyncio/staggered.py +Lib/asyncio/streams.py +Lib/asyncio/subprocess.py +Lib/asyncio/taskgroups.py +Lib/asyncio/tasks.py +Lib/asyncio/threads.py +Lib/asyncio/timeouts.py +Lib/asyncio/transports.py +Lib/asyncio/trsock.py +Lib/asyncio/unix_events.py +Lib/asyncio/windows_events.py +Lib/asyncio/windows_utils.py +Lib/asyncore.py +Lib/base64.py +Lib/bdb.py +Lib/bisect.py +Lib/bz2.py +Lib/cProfile.py +Lib/calendar.py +Lib/cgi.py +Lib/cgitb.py +Lib/chunk.py +Lib/cmd.py +Lib/code.py +Lib/codecs.py +Lib/codeop.py +Lib/collections/__init__.py +Lib/collections/__pycache__/__init__.cpython-311.pyc +Lib/collections/__pycache__/abc.cpython-311.pyc +Lib/collections/abc.py +Lib/colorsys.py +Lib/compileall.py +Lib/concurrent/__init__.py +Lib/concurrent/__pycache__/__init__.cpython-311.pyc +Lib/concurrent/futures/__init__.py +Lib/concurrent/futures/__pycache__/__init__.cpython-311.pyc +Lib/concurrent/futures/__pycache__/_base.cpython-311.pyc +Lib/concurrent/futures/__pycache__/process.cpython-311.pyc +Lib/concurrent/futures/__pycache__/thread.cpython-311.pyc +Lib/concurrent/futures/_base.py +Lib/concurrent/futures/process.py +Lib/concurrent/futures/thread.py +Lib/configparser.py +Lib/contextlib.py +Lib/contextvars.py +Lib/copy.py +Lib/copyreg.py +Lib/crypt.py +Lib/csv.py +Lib/ctypes/__init__.py +Lib/ctypes/__pycache__/__init__.cpython-311.pyc +Lib/ctypes/__pycache__/_aix.cpython-311.pyc +Lib/ctypes/__pycache__/_endian.cpython-311.pyc +Lib/ctypes/__pycache__/util.cpython-311.pyc +Lib/ctypes/__pycache__/wintypes.cpython-311.pyc +Lib/ctypes/_aix.py +Lib/ctypes/_endian.py +Lib/ctypes/macholib/README.ctypes +Lib/ctypes/macholib/__init__.py +Lib/ctypes/macholib/__pycache__/__init__.cpython-311.pyc +Lib/ctypes/macholib/__pycache__/dyld.cpython-311.pyc +Lib/ctypes/macholib/__pycache__/dylib.cpython-311.pyc +Lib/ctypes/macholib/__pycache__/framework.cpython-311.pyc +Lib/ctypes/macholib/dyld.py +Lib/ctypes/macholib/dylib.py +Lib/ctypes/macholib/fetch_macholib +Lib/ctypes/macholib/fetch_macholib.bat +Lib/ctypes/macholib/framework.py +Lib/ctypes/test/__init__.py +Lib/ctypes/test/__main__.py +Lib/ctypes/test/__pycache__/__init__.cpython-311.pyc +Lib/ctypes/test/__pycache__/__main__.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_anon.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_array_in_pointer.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_arrays.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_as_parameter.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_bitfields.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_buffers.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_bytes.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_byteswap.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_callbacks.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_cast.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_cfuncs.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_checkretval.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_delattr.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_errno.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_find.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_frombuffer.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_funcptr.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_functions.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_incomplete.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_init.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_internals.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_keeprefs.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_libc.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_loading.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_macholib.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_memfunctions.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_numbers.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_objects.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_parameters.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_pep3118.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_pickling.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_pointers.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_prototypes.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_python_api.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_random_things.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_refcounts.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_repr.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_returnfuncptrs.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_simplesubclasses.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_sizes.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_slicing.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_stringptr.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_strings.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_struct_fields.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_structures.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_unaligned_structures.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_unicode.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_values.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_varsize_struct.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_win32.cpython-311.pyc +Lib/ctypes/test/__pycache__/test_wintypes.cpython-311.pyc +Lib/ctypes/test/test_anon.py +Lib/ctypes/test/test_array_in_pointer.py +Lib/ctypes/test/test_arrays.py +Lib/ctypes/test/test_as_parameter.py +Lib/ctypes/test/test_bitfields.py +Lib/ctypes/test/test_buffers.py +Lib/ctypes/test/test_bytes.py +Lib/ctypes/test/test_byteswap.py +Lib/ctypes/test/test_callbacks.py +Lib/ctypes/test/test_cast.py +Lib/ctypes/test/test_cfuncs.py +Lib/ctypes/test/test_checkretval.py +Lib/ctypes/test/test_delattr.py +Lib/ctypes/test/test_errno.py +Lib/ctypes/test/test_find.py +Lib/ctypes/test/test_frombuffer.py +Lib/ctypes/test/test_funcptr.py +Lib/ctypes/test/test_functions.py +Lib/ctypes/test/test_incomplete.py +Lib/ctypes/test/test_init.py +Lib/ctypes/test/test_internals.py +Lib/ctypes/test/test_keeprefs.py +Lib/ctypes/test/test_libc.py +Lib/ctypes/test/test_loading.py +Lib/ctypes/test/test_macholib.py +Lib/ctypes/test/test_memfunctions.py +Lib/ctypes/test/test_numbers.py +Lib/ctypes/test/test_objects.py +Lib/ctypes/test/test_parameters.py +Lib/ctypes/test/test_pep3118.py +Lib/ctypes/test/test_pickling.py +Lib/ctypes/test/test_pointers.py +Lib/ctypes/test/test_prototypes.py +Lib/ctypes/test/test_python_api.py +Lib/ctypes/test/test_random_things.py +Lib/ctypes/test/test_refcounts.py +Lib/ctypes/test/test_repr.py +Lib/ctypes/test/test_returnfuncptrs.py +Lib/ctypes/test/test_simplesubclasses.py +Lib/ctypes/test/test_sizes.py +Lib/ctypes/test/test_slicing.py +Lib/ctypes/test/test_stringptr.py +Lib/ctypes/test/test_strings.py +Lib/ctypes/test/test_struct_fields.py +Lib/ctypes/test/test_structures.py +Lib/ctypes/test/test_unaligned_structures.py +Lib/ctypes/test/test_unicode.py +Lib/ctypes/test/test_values.py +Lib/ctypes/test/test_varsize_struct.py +Lib/ctypes/test/test_win32.py +Lib/ctypes/test/test_wintypes.py +Lib/ctypes/util.py +Lib/ctypes/wintypes.py +Lib/curses/__init__.py +Lib/curses/__pycache__/__init__.cpython-311.pyc +Lib/curses/__pycache__/ascii.cpython-311.pyc +Lib/curses/__pycache__/has_key.cpython-311.pyc +Lib/curses/__pycache__/panel.cpython-311.pyc +Lib/curses/__pycache__/textpad.cpython-311.pyc +Lib/curses/ascii.py +Lib/curses/has_key.py +Lib/curses/panel.py +Lib/curses/textpad.py +Lib/dataclasses.py +Lib/datetime.py +Lib/dbm/__init__.py +Lib/dbm/__pycache__/__init__.cpython-311.pyc +Lib/dbm/__pycache__/dumb.cpython-311.pyc +Lib/dbm/__pycache__/gnu.cpython-311.pyc +Lib/dbm/__pycache__/ndbm.cpython-311.pyc +Lib/dbm/dumb.py +Lib/dbm/gnu.py +Lib/dbm/ndbm.py +Lib/decimal.py +Lib/difflib.py +Lib/dis.py +Lib/distutils/README +Lib/distutils/__init__.py +Lib/distutils/__pycache__/__init__.cpython-311.pyc +Lib/distutils/__pycache__/_msvccompiler.cpython-311.pyc +Lib/distutils/__pycache__/archive_util.cpython-311.pyc +Lib/distutils/__pycache__/bcppcompiler.cpython-311.pyc +Lib/distutils/__pycache__/ccompiler.cpython-311.pyc +Lib/distutils/__pycache__/cmd.cpython-311.pyc +Lib/distutils/__pycache__/config.cpython-311.pyc +Lib/distutils/__pycache__/core.cpython-311.pyc +Lib/distutils/__pycache__/cygwinccompiler.cpython-311.pyc +Lib/distutils/__pycache__/debug.cpython-311.pyc +Lib/distutils/__pycache__/dep_util.cpython-311.pyc +Lib/distutils/__pycache__/dir_util.cpython-311.pyc +Lib/distutils/__pycache__/dist.cpython-311.pyc +Lib/distutils/__pycache__/errors.cpython-311.pyc +Lib/distutils/__pycache__/extension.cpython-311.pyc +Lib/distutils/__pycache__/fancy_getopt.cpython-311.pyc +Lib/distutils/__pycache__/file_util.cpython-311.pyc +Lib/distutils/__pycache__/filelist.cpython-311.pyc +Lib/distutils/__pycache__/log.cpython-311.pyc +Lib/distutils/__pycache__/msvc9compiler.cpython-311.pyc +Lib/distutils/__pycache__/msvccompiler.cpython-311.pyc +Lib/distutils/__pycache__/spawn.cpython-311.pyc +Lib/distutils/__pycache__/sysconfig.cpython-311.pyc +Lib/distutils/__pycache__/text_file.cpython-311.pyc +Lib/distutils/__pycache__/unixccompiler.cpython-311.pyc +Lib/distutils/__pycache__/util.cpython-311.pyc +Lib/distutils/__pycache__/version.cpython-311.pyc +Lib/distutils/__pycache__/versionpredicate.cpython-311.pyc +Lib/distutils/_msvccompiler.py +Lib/distutils/archive_util.py +Lib/distutils/bcppcompiler.py +Lib/distutils/ccompiler.py +Lib/distutils/cmd.py +Lib/distutils/command/__init__.py +Lib/distutils/command/__pycache__/__init__.cpython-311.pyc +Lib/distutils/command/__pycache__/bdist.cpython-311.pyc +Lib/distutils/command/__pycache__/bdist_dumb.cpython-311.pyc +Lib/distutils/command/__pycache__/bdist_rpm.cpython-311.pyc +Lib/distutils/command/__pycache__/build.cpython-311.pyc +Lib/distutils/command/__pycache__/build_clib.cpython-311.pyc +Lib/distutils/command/__pycache__/build_ext.cpython-311.pyc +Lib/distutils/command/__pycache__/build_py.cpython-311.pyc +Lib/distutils/command/__pycache__/build_scripts.cpython-311.pyc +Lib/distutils/command/__pycache__/check.cpython-311.pyc +Lib/distutils/command/__pycache__/clean.cpython-311.pyc +Lib/distutils/command/__pycache__/config.cpython-311.pyc +Lib/distutils/command/__pycache__/install.cpython-311.pyc +Lib/distutils/command/__pycache__/install_data.cpython-311.pyc +Lib/distutils/command/__pycache__/install_egg_info.cpython-311.pyc +Lib/distutils/command/__pycache__/install_headers.cpython-311.pyc +Lib/distutils/command/__pycache__/install_lib.cpython-311.pyc +Lib/distutils/command/__pycache__/install_scripts.cpython-311.pyc +Lib/distutils/command/__pycache__/register.cpython-311.pyc +Lib/distutils/command/__pycache__/sdist.cpython-311.pyc +Lib/distutils/command/__pycache__/upload.cpython-311.pyc +Lib/distutils/command/bdist.py +Lib/distutils/command/bdist_dumb.py +Lib/distutils/command/bdist_rpm.py +Lib/distutils/command/build.py +Lib/distutils/command/build_clib.py +Lib/distutils/command/build_ext.py +Lib/distutils/command/build_py.py +Lib/distutils/command/build_scripts.py +Lib/distutils/command/check.py +Lib/distutils/command/clean.py +Lib/distutils/command/command_template +Lib/distutils/command/config.py +Lib/distutils/command/install.py +Lib/distutils/command/install_data.py +Lib/distutils/command/install_egg_info.py +Lib/distutils/command/install_headers.py +Lib/distutils/command/install_lib.py +Lib/distutils/command/install_scripts.py +Lib/distutils/command/register.py +Lib/distutils/command/sdist.py +Lib/distutils/command/upload.py +Lib/distutils/config.py +Lib/distutils/core.py +Lib/distutils/cygwinccompiler.py +Lib/distutils/debug.py +Lib/distutils/dep_util.py +Lib/distutils/dir_util.py +Lib/distutils/dist.py +Lib/distutils/errors.py +Lib/distutils/extension.py +Lib/distutils/fancy_getopt.py +Lib/distutils/file_util.py +Lib/distutils/filelist.py +Lib/distutils/log.py +Lib/distutils/msvc9compiler.py +Lib/distutils/msvccompiler.py +Lib/distutils/spawn.py +Lib/distutils/sysconfig.py +Lib/distutils/tests/Setup.sample +Lib/distutils/tests/__init__.py +Lib/distutils/tests/__pycache__/__init__.cpython-311.pyc +Lib/distutils/tests/__pycache__/support.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_archive_util.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_bdist.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_bdist_dumb.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_bdist_rpm.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_build.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_build_clib.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_build_ext.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_build_py.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_build_scripts.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_check.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_clean.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_cmd.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_config.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_config_cmd.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_core.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_cygwinccompiler.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_dep_util.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_dir_util.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_dist.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_extension.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_file_util.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_filelist.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_install.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_install_data.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_install_headers.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_install_lib.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_install_scripts.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_log.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_msvc9compiler.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_msvccompiler.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_register.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_sdist.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_spawn.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_sysconfig.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_text_file.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_unixccompiler.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_upload.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_util.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_version.cpython-311.pyc +Lib/distutils/tests/__pycache__/test_versionpredicate.cpython-311.pyc +Lib/distutils/tests/includetest.rst +Lib/distutils/tests/support.py +Lib/distutils/tests/test_archive_util.py +Lib/distutils/tests/test_bdist.py +Lib/distutils/tests/test_bdist_dumb.py +Lib/distutils/tests/test_bdist_rpm.py +Lib/distutils/tests/test_build.py +Lib/distutils/tests/test_build_clib.py +Lib/distutils/tests/test_build_ext.py +Lib/distutils/tests/test_build_py.py +Lib/distutils/tests/test_build_scripts.py +Lib/distutils/tests/test_check.py +Lib/distutils/tests/test_clean.py +Lib/distutils/tests/test_cmd.py +Lib/distutils/tests/test_config.py +Lib/distutils/tests/test_config_cmd.py +Lib/distutils/tests/test_core.py +Lib/distutils/tests/test_cygwinccompiler.py +Lib/distutils/tests/test_dep_util.py +Lib/distutils/tests/test_dir_util.py +Lib/distutils/tests/test_dist.py +Lib/distutils/tests/test_extension.py +Lib/distutils/tests/test_file_util.py +Lib/distutils/tests/test_filelist.py +Lib/distutils/tests/test_install.py +Lib/distutils/tests/test_install_data.py +Lib/distutils/tests/test_install_headers.py +Lib/distutils/tests/test_install_lib.py +Lib/distutils/tests/test_install_scripts.py +Lib/distutils/tests/test_log.py +Lib/distutils/tests/test_msvc9compiler.py +Lib/distutils/tests/test_msvccompiler.py +Lib/distutils/tests/test_register.py +Lib/distutils/tests/test_sdist.py +Lib/distutils/tests/test_spawn.py +Lib/distutils/tests/test_sysconfig.py +Lib/distutils/tests/test_text_file.py +Lib/distutils/tests/test_unixccompiler.py +Lib/distutils/tests/test_upload.py +Lib/distutils/tests/test_util.py +Lib/distutils/tests/test_version.py +Lib/distutils/tests/test_versionpredicate.py +Lib/distutils/text_file.py +Lib/distutils/unixccompiler.py +Lib/distutils/util.py +Lib/distutils/version.py +Lib/distutils/versionpredicate.py +Lib/doctest.py +Lib/email/__init__.py +Lib/email/__pycache__/__init__.cpython-311.pyc +Lib/email/__pycache__/_encoded_words.cpython-311.pyc +Lib/email/__pycache__/_header_value_parser.cpython-311.pyc +Lib/email/__pycache__/_parseaddr.cpython-311.pyc +Lib/email/__pycache__/_policybase.cpython-311.pyc +Lib/email/__pycache__/base64mime.cpython-311.pyc +Lib/email/__pycache__/charset.cpython-311.pyc +Lib/email/__pycache__/contentmanager.cpython-311.pyc +Lib/email/__pycache__/encoders.cpython-311.pyc +Lib/email/__pycache__/errors.cpython-311.pyc +Lib/email/__pycache__/feedparser.cpython-311.pyc +Lib/email/__pycache__/generator.cpython-311.pyc +Lib/email/__pycache__/header.cpython-311.pyc +Lib/email/__pycache__/headerregistry.cpython-311.pyc +Lib/email/__pycache__/iterators.cpython-311.pyc +Lib/email/__pycache__/message.cpython-311.pyc +Lib/email/__pycache__/parser.cpython-311.pyc +Lib/email/__pycache__/policy.cpython-311.pyc +Lib/email/__pycache__/quoprimime.cpython-311.pyc +Lib/email/__pycache__/utils.cpython-311.pyc +Lib/email/_encoded_words.py +Lib/email/_header_value_parser.py +Lib/email/_parseaddr.py +Lib/email/_policybase.py +Lib/email/architecture.rst +Lib/email/base64mime.py +Lib/email/charset.py +Lib/email/contentmanager.py +Lib/email/encoders.py +Lib/email/errors.py +Lib/email/feedparser.py +Lib/email/generator.py +Lib/email/header.py +Lib/email/headerregistry.py +Lib/email/iterators.py +Lib/email/message.py +Lib/email/mime/__init__.py +Lib/email/mime/__pycache__/__init__.cpython-311.pyc +Lib/email/mime/__pycache__/application.cpython-311.pyc +Lib/email/mime/__pycache__/audio.cpython-311.pyc +Lib/email/mime/__pycache__/base.cpython-311.pyc +Lib/email/mime/__pycache__/image.cpython-311.pyc +Lib/email/mime/__pycache__/message.cpython-311.pyc +Lib/email/mime/__pycache__/multipart.cpython-311.pyc +Lib/email/mime/__pycache__/nonmultipart.cpython-311.pyc +Lib/email/mime/__pycache__/text.cpython-311.pyc +Lib/email/mime/application.py +Lib/email/mime/audio.py +Lib/email/mime/base.py +Lib/email/mime/image.py +Lib/email/mime/message.py +Lib/email/mime/multipart.py +Lib/email/mime/nonmultipart.py +Lib/email/mime/text.py +Lib/email/parser.py +Lib/email/policy.py +Lib/email/quoprimime.py +Lib/email/utils.py +Lib/encodings/__init__.py +Lib/encodings/__pycache__/__init__.cpython-311.pyc +Lib/encodings/__pycache__/aliases.cpython-311.pyc +Lib/encodings/__pycache__/ascii.cpython-311.pyc +Lib/encodings/__pycache__/base64_codec.cpython-311.pyc +Lib/encodings/__pycache__/big5.cpython-311.pyc +Lib/encodings/__pycache__/big5hkscs.cpython-311.pyc +Lib/encodings/__pycache__/bz2_codec.cpython-311.pyc +Lib/encodings/__pycache__/charmap.cpython-311.pyc +Lib/encodings/__pycache__/cp037.cpython-311.pyc +Lib/encodings/__pycache__/cp1006.cpython-311.pyc +Lib/encodings/__pycache__/cp1026.cpython-311.pyc +Lib/encodings/__pycache__/cp1125.cpython-311.pyc +Lib/encodings/__pycache__/cp1140.cpython-311.pyc +Lib/encodings/__pycache__/cp1250.cpython-311.pyc +Lib/encodings/__pycache__/cp1251.cpython-311.pyc +Lib/encodings/__pycache__/cp1252.cpython-311.pyc +Lib/encodings/__pycache__/cp1253.cpython-311.pyc +Lib/encodings/__pycache__/cp1254.cpython-311.pyc +Lib/encodings/__pycache__/cp1255.cpython-311.pyc +Lib/encodings/__pycache__/cp1256.cpython-311.pyc +Lib/encodings/__pycache__/cp1257.cpython-311.pyc +Lib/encodings/__pycache__/cp1258.cpython-311.pyc +Lib/encodings/__pycache__/cp273.cpython-311.pyc +Lib/encodings/__pycache__/cp424.cpython-311.pyc +Lib/encodings/__pycache__/cp437.cpython-311.pyc +Lib/encodings/__pycache__/cp500.cpython-311.pyc +Lib/encodings/__pycache__/cp720.cpython-311.pyc +Lib/encodings/__pycache__/cp737.cpython-311.pyc +Lib/encodings/__pycache__/cp775.cpython-311.pyc +Lib/encodings/__pycache__/cp850.cpython-311.pyc +Lib/encodings/__pycache__/cp852.cpython-311.pyc +Lib/encodings/__pycache__/cp855.cpython-311.pyc +Lib/encodings/__pycache__/cp856.cpython-311.pyc +Lib/encodings/__pycache__/cp857.cpython-311.pyc +Lib/encodings/__pycache__/cp858.cpython-311.pyc +Lib/encodings/__pycache__/cp860.cpython-311.pyc +Lib/encodings/__pycache__/cp861.cpython-311.pyc +Lib/encodings/__pycache__/cp862.cpython-311.pyc +Lib/encodings/__pycache__/cp863.cpython-311.pyc +Lib/encodings/__pycache__/cp864.cpython-311.pyc +Lib/encodings/__pycache__/cp865.cpython-311.pyc +Lib/encodings/__pycache__/cp866.cpython-311.pyc +Lib/encodings/__pycache__/cp869.cpython-311.pyc +Lib/encodings/__pycache__/cp874.cpython-311.pyc +Lib/encodings/__pycache__/cp875.cpython-311.pyc +Lib/encodings/__pycache__/cp932.cpython-311.pyc +Lib/encodings/__pycache__/cp949.cpython-311.pyc +Lib/encodings/__pycache__/cp950.cpython-311.pyc +Lib/encodings/__pycache__/euc_jis_2004.cpython-311.pyc +Lib/encodings/__pycache__/euc_jisx0213.cpython-311.pyc +Lib/encodings/__pycache__/euc_jp.cpython-311.pyc +Lib/encodings/__pycache__/euc_kr.cpython-311.pyc +Lib/encodings/__pycache__/gb18030.cpython-311.pyc +Lib/encodings/__pycache__/gb2312.cpython-311.pyc +Lib/encodings/__pycache__/gbk.cpython-311.pyc +Lib/encodings/__pycache__/hex_codec.cpython-311.pyc +Lib/encodings/__pycache__/hp_roman8.cpython-311.pyc +Lib/encodings/__pycache__/hz.cpython-311.pyc +Lib/encodings/__pycache__/idna.cpython-311.pyc +Lib/encodings/__pycache__/iso2022_jp.cpython-311.pyc +Lib/encodings/__pycache__/iso2022_jp_1.cpython-311.pyc +Lib/encodings/__pycache__/iso2022_jp_2.cpython-311.pyc +Lib/encodings/__pycache__/iso2022_jp_2004.cpython-311.pyc +Lib/encodings/__pycache__/iso2022_jp_3.cpython-311.pyc +Lib/encodings/__pycache__/iso2022_jp_ext.cpython-311.pyc +Lib/encodings/__pycache__/iso2022_kr.cpython-311.pyc +Lib/encodings/__pycache__/iso8859_1.cpython-311.pyc +Lib/encodings/__pycache__/iso8859_10.cpython-311.pyc +Lib/encodings/__pycache__/iso8859_11.cpython-311.pyc +Lib/encodings/__pycache__/iso8859_13.cpython-311.pyc +Lib/encodings/__pycache__/iso8859_14.cpython-311.pyc +Lib/encodings/__pycache__/iso8859_15.cpython-311.pyc +Lib/encodings/__pycache__/iso8859_16.cpython-311.pyc +Lib/encodings/__pycache__/iso8859_2.cpython-311.pyc +Lib/encodings/__pycache__/iso8859_3.cpython-311.pyc +Lib/encodings/__pycache__/iso8859_4.cpython-311.pyc +Lib/encodings/__pycache__/iso8859_5.cpython-311.pyc +Lib/encodings/__pycache__/iso8859_6.cpython-311.pyc +Lib/encodings/__pycache__/iso8859_7.cpython-311.pyc +Lib/encodings/__pycache__/iso8859_8.cpython-311.pyc +Lib/encodings/__pycache__/iso8859_9.cpython-311.pyc +Lib/encodings/__pycache__/johab.cpython-311.pyc +Lib/encodings/__pycache__/koi8_r.cpython-311.pyc +Lib/encodings/__pycache__/koi8_t.cpython-311.pyc +Lib/encodings/__pycache__/koi8_u.cpython-311.pyc +Lib/encodings/__pycache__/kz1048.cpython-311.pyc +Lib/encodings/__pycache__/latin_1.cpython-311.pyc +Lib/encodings/__pycache__/mac_arabic.cpython-311.pyc +Lib/encodings/__pycache__/mac_croatian.cpython-311.pyc +Lib/encodings/__pycache__/mac_cyrillic.cpython-311.pyc +Lib/encodings/__pycache__/mac_farsi.cpython-311.pyc +Lib/encodings/__pycache__/mac_greek.cpython-311.pyc +Lib/encodings/__pycache__/mac_iceland.cpython-311.pyc +Lib/encodings/__pycache__/mac_latin2.cpython-311.pyc +Lib/encodings/__pycache__/mac_roman.cpython-311.pyc +Lib/encodings/__pycache__/mac_romanian.cpython-311.pyc +Lib/encodings/__pycache__/mac_turkish.cpython-311.pyc +Lib/encodings/__pycache__/mbcs.cpython-311.pyc +Lib/encodings/__pycache__/oem.cpython-311.pyc +Lib/encodings/__pycache__/palmos.cpython-311.pyc +Lib/encodings/__pycache__/ptcp154.cpython-311.pyc +Lib/encodings/__pycache__/punycode.cpython-311.pyc +Lib/encodings/__pycache__/quopri_codec.cpython-311.pyc +Lib/encodings/__pycache__/raw_unicode_escape.cpython-311.pyc +Lib/encodings/__pycache__/rot_13.cpython-311.pyc +Lib/encodings/__pycache__/shift_jis.cpython-311.pyc +Lib/encodings/__pycache__/shift_jis_2004.cpython-311.pyc +Lib/encodings/__pycache__/shift_jisx0213.cpython-311.pyc +Lib/encodings/__pycache__/tis_620.cpython-311.pyc +Lib/encodings/__pycache__/undefined.cpython-311.pyc +Lib/encodings/__pycache__/unicode_escape.cpython-311.pyc +Lib/encodings/__pycache__/utf_16.cpython-311.pyc +Lib/encodings/__pycache__/utf_16_be.cpython-311.pyc +Lib/encodings/__pycache__/utf_16_le.cpython-311.pyc +Lib/encodings/__pycache__/utf_32.cpython-311.pyc +Lib/encodings/__pycache__/utf_32_be.cpython-311.pyc +Lib/encodings/__pycache__/utf_32_le.cpython-311.pyc +Lib/encodings/__pycache__/utf_7.cpython-311.pyc +Lib/encodings/__pycache__/utf_8.cpython-311.pyc +Lib/encodings/__pycache__/utf_8_sig.cpython-311.pyc +Lib/encodings/__pycache__/uu_codec.cpython-311.pyc +Lib/encodings/__pycache__/zlib_codec.cpython-311.pyc +Lib/encodings/aliases.py +Lib/encodings/ascii.py +Lib/encodings/base64_codec.py +Lib/encodings/big5.py +Lib/encodings/big5hkscs.py +Lib/encodings/bz2_codec.py +Lib/encodings/charmap.py +Lib/encodings/cp037.py +Lib/encodings/cp1006.py +Lib/encodings/cp1026.py +Lib/encodings/cp1125.py +Lib/encodings/cp1140.py +Lib/encodings/cp1250.py +Lib/encodings/cp1251.py +Lib/encodings/cp1252.py +Lib/encodings/cp1253.py +Lib/encodings/cp1254.py +Lib/encodings/cp1255.py +Lib/encodings/cp1256.py +Lib/encodings/cp1257.py +Lib/encodings/cp1258.py +Lib/encodings/cp273.py +Lib/encodings/cp424.py +Lib/encodings/cp437.py +Lib/encodings/cp500.py +Lib/encodings/cp720.py +Lib/encodings/cp737.py +Lib/encodings/cp775.py +Lib/encodings/cp850.py +Lib/encodings/cp852.py +Lib/encodings/cp855.py +Lib/encodings/cp856.py +Lib/encodings/cp857.py +Lib/encodings/cp858.py +Lib/encodings/cp860.py +Lib/encodings/cp861.py +Lib/encodings/cp862.py +Lib/encodings/cp863.py +Lib/encodings/cp864.py +Lib/encodings/cp865.py +Lib/encodings/cp866.py +Lib/encodings/cp869.py +Lib/encodings/cp874.py +Lib/encodings/cp875.py +Lib/encodings/cp932.py +Lib/encodings/cp949.py +Lib/encodings/cp950.py +Lib/encodings/euc_jis_2004.py +Lib/encodings/euc_jisx0213.py +Lib/encodings/euc_jp.py +Lib/encodings/euc_kr.py +Lib/encodings/gb18030.py +Lib/encodings/gb2312.py +Lib/encodings/gbk.py +Lib/encodings/hex_codec.py +Lib/encodings/hp_roman8.py +Lib/encodings/hz.py +Lib/encodings/idna.py +Lib/encodings/iso2022_jp.py +Lib/encodings/iso2022_jp_1.py +Lib/encodings/iso2022_jp_2.py +Lib/encodings/iso2022_jp_2004.py +Lib/encodings/iso2022_jp_3.py +Lib/encodings/iso2022_jp_ext.py +Lib/encodings/iso2022_kr.py +Lib/encodings/iso8859_1.py +Lib/encodings/iso8859_10.py +Lib/encodings/iso8859_11.py +Lib/encodings/iso8859_13.py +Lib/encodings/iso8859_14.py +Lib/encodings/iso8859_15.py +Lib/encodings/iso8859_16.py +Lib/encodings/iso8859_2.py +Lib/encodings/iso8859_3.py +Lib/encodings/iso8859_4.py +Lib/encodings/iso8859_5.py +Lib/encodings/iso8859_6.py +Lib/encodings/iso8859_7.py +Lib/encodings/iso8859_8.py +Lib/encodings/iso8859_9.py +Lib/encodings/johab.py +Lib/encodings/koi8_r.py +Lib/encodings/koi8_t.py +Lib/encodings/koi8_u.py +Lib/encodings/kz1048.py +Lib/encodings/latin_1.py +Lib/encodings/mac_arabic.py +Lib/encodings/mac_croatian.py +Lib/encodings/mac_cyrillic.py +Lib/encodings/mac_farsi.py +Lib/encodings/mac_greek.py +Lib/encodings/mac_iceland.py +Lib/encodings/mac_latin2.py +Lib/encodings/mac_roman.py +Lib/encodings/mac_romanian.py +Lib/encodings/mac_turkish.py +Lib/encodings/mbcs.py +Lib/encodings/oem.py +Lib/encodings/palmos.py +Lib/encodings/ptcp154.py +Lib/encodings/punycode.py +Lib/encodings/quopri_codec.py +Lib/encodings/raw_unicode_escape.py +Lib/encodings/rot_13.py +Lib/encodings/shift_jis.py +Lib/encodings/shift_jis_2004.py +Lib/encodings/shift_jisx0213.py +Lib/encodings/tis_620.py +Lib/encodings/undefined.py +Lib/encodings/unicode_escape.py +Lib/encodings/utf_16.py +Lib/encodings/utf_16_be.py +Lib/encodings/utf_16_le.py +Lib/encodings/utf_32.py +Lib/encodings/utf_32_be.py +Lib/encodings/utf_32_le.py +Lib/encodings/utf_7.py +Lib/encodings/utf_8.py +Lib/encodings/utf_8_sig.py +Lib/encodings/uu_codec.py +Lib/encodings/zlib_codec.py +Lib/ensurepip/__init__.py +Lib/ensurepip/__main__.py +Lib/ensurepip/__pycache__/__init__.cpython-311.pyc +Lib/ensurepip/__pycache__/__main__.cpython-311.pyc +Lib/ensurepip/__pycache__/_uninstall.cpython-311.pyc +Lib/ensurepip/_bundled/pip-24.0-py3-none-any.whl +Lib/ensurepip/_bundled/setuptools-79.0.1-py3-none-any.whl +Lib/ensurepip/_uninstall.py +Lib/enum.py +Lib/filecmp.py +Lib/fileinput.py +Lib/fnmatch.py +Lib/fractions.py +Lib/ftplib.py +Lib/functools.py +Lib/genericpath.py +Lib/getopt.py +Lib/getpass.py +Lib/gettext.py +Lib/glob.py +Lib/graphlib.py +Lib/gzip.py +Lib/hashlib.py +Lib/heapq.py +Lib/hmac.py +Lib/html/__init__.py +Lib/html/__pycache__/__init__.cpython-311.pyc +Lib/html/__pycache__/entities.cpython-311.pyc +Lib/html/__pycache__/parser.cpython-311.pyc +Lib/html/entities.py +Lib/html/parser.py +Lib/http/__init__.py +Lib/http/__pycache__/__init__.cpython-311.pyc +Lib/http/__pycache__/client.cpython-311.pyc +Lib/http/__pycache__/cookiejar.cpython-311.pyc +Lib/http/__pycache__/cookies.cpython-311.pyc +Lib/http/__pycache__/server.cpython-311.pyc +Lib/http/client.py +Lib/http/cookiejar.py +Lib/http/cookies.py +Lib/http/server.py +Lib/idlelib/CREDITS.txt +Lib/idlelib/ChangeLog +Lib/idlelib/HISTORY.txt +Lib/idlelib/Icons/README.txt +Lib/idlelib/Icons/folder.gif +Lib/idlelib/Icons/idle.ico +Lib/idlelib/Icons/idle_16.gif +Lib/idlelib/Icons/idle_16.png +Lib/idlelib/Icons/idle_256.png +Lib/idlelib/Icons/idle_32.gif +Lib/idlelib/Icons/idle_32.png +Lib/idlelib/Icons/idle_48.gif +Lib/idlelib/Icons/idle_48.png +Lib/idlelib/Icons/minusnode.gif +Lib/idlelib/Icons/openfolder.gif +Lib/idlelib/Icons/plusnode.gif +Lib/idlelib/Icons/python.gif +Lib/idlelib/Icons/tk.gif +Lib/idlelib/NEWS2x.txt +Lib/idlelib/News3.txt +Lib/idlelib/README.txt +Lib/idlelib/TODO.txt +Lib/idlelib/__init__.py +Lib/idlelib/__main__.py +Lib/idlelib/__pycache__/__init__.cpython-311.pyc +Lib/idlelib/__pycache__/__main__.cpython-311.pyc +Lib/idlelib/__pycache__/autocomplete.cpython-311.pyc +Lib/idlelib/__pycache__/autocomplete_w.cpython-311.pyc +Lib/idlelib/__pycache__/autoexpand.cpython-311.pyc +Lib/idlelib/__pycache__/browser.cpython-311.pyc +Lib/idlelib/__pycache__/calltip.cpython-311.pyc +Lib/idlelib/__pycache__/calltip_w.cpython-311.pyc +Lib/idlelib/__pycache__/codecontext.cpython-311.pyc +Lib/idlelib/__pycache__/colorizer.cpython-311.pyc +Lib/idlelib/__pycache__/config.cpython-311.pyc +Lib/idlelib/__pycache__/config_key.cpython-311.pyc +Lib/idlelib/__pycache__/configdialog.cpython-311.pyc +Lib/idlelib/__pycache__/debugger.cpython-311.pyc +Lib/idlelib/__pycache__/debugger_r.cpython-311.pyc +Lib/idlelib/__pycache__/debugobj.cpython-311.pyc +Lib/idlelib/__pycache__/debugobj_r.cpython-311.pyc +Lib/idlelib/__pycache__/delegator.cpython-311.pyc +Lib/idlelib/__pycache__/dynoption.cpython-311.pyc +Lib/idlelib/__pycache__/editor.cpython-311.pyc +Lib/idlelib/__pycache__/filelist.cpython-311.pyc +Lib/idlelib/__pycache__/format.cpython-311.pyc +Lib/idlelib/__pycache__/grep.cpython-311.pyc +Lib/idlelib/__pycache__/help.cpython-311.pyc +Lib/idlelib/__pycache__/help_about.cpython-311.pyc +Lib/idlelib/__pycache__/history.cpython-311.pyc +Lib/idlelib/__pycache__/hyperparser.cpython-311.pyc +Lib/idlelib/__pycache__/idle.cpython-311.pyc +Lib/idlelib/__pycache__/iomenu.cpython-311.pyc +Lib/idlelib/__pycache__/macosx.cpython-311.pyc +Lib/idlelib/__pycache__/mainmenu.cpython-311.pyc +Lib/idlelib/__pycache__/multicall.cpython-311.pyc +Lib/idlelib/__pycache__/outwin.cpython-311.pyc +Lib/idlelib/__pycache__/parenmatch.cpython-311.pyc +Lib/idlelib/__pycache__/pathbrowser.cpython-311.pyc +Lib/idlelib/__pycache__/percolator.cpython-311.pyc +Lib/idlelib/__pycache__/pyparse.cpython-311.pyc +Lib/idlelib/__pycache__/pyshell.cpython-311.pyc +Lib/idlelib/__pycache__/query.cpython-311.pyc +Lib/idlelib/__pycache__/redirector.cpython-311.pyc +Lib/idlelib/__pycache__/replace.cpython-311.pyc +Lib/idlelib/__pycache__/rpc.cpython-311.pyc +Lib/idlelib/__pycache__/run.cpython-311.pyc +Lib/idlelib/__pycache__/runscript.cpython-311.pyc +Lib/idlelib/__pycache__/scrolledlist.cpython-311.pyc +Lib/idlelib/__pycache__/search.cpython-311.pyc +Lib/idlelib/__pycache__/searchbase.cpython-311.pyc +Lib/idlelib/__pycache__/searchengine.cpython-311.pyc +Lib/idlelib/__pycache__/sidebar.cpython-311.pyc +Lib/idlelib/__pycache__/squeezer.cpython-311.pyc +Lib/idlelib/__pycache__/stackviewer.cpython-311.pyc +Lib/idlelib/__pycache__/statusbar.cpython-311.pyc +Lib/idlelib/__pycache__/textview.cpython-311.pyc +Lib/idlelib/__pycache__/tooltip.cpython-311.pyc +Lib/idlelib/__pycache__/tree.cpython-311.pyc +Lib/idlelib/__pycache__/undo.cpython-311.pyc +Lib/idlelib/__pycache__/util.cpython-311.pyc +Lib/idlelib/__pycache__/window.cpython-311.pyc +Lib/idlelib/__pycache__/zoomheight.cpython-311.pyc +Lib/idlelib/__pycache__/zzdummy.cpython-311.pyc +Lib/idlelib/autocomplete.py +Lib/idlelib/autocomplete_w.py +Lib/idlelib/autoexpand.py +Lib/idlelib/browser.py +Lib/idlelib/calltip.py +Lib/idlelib/calltip_w.py +Lib/idlelib/codecontext.py +Lib/idlelib/colorizer.py +Lib/idlelib/config-extensions.def +Lib/idlelib/config-highlight.def +Lib/idlelib/config-keys.def +Lib/idlelib/config-main.def +Lib/idlelib/config.py +Lib/idlelib/config_key.py +Lib/idlelib/configdialog.py +Lib/idlelib/debugger.py +Lib/idlelib/debugger_r.py +Lib/idlelib/debugobj.py +Lib/idlelib/debugobj_r.py +Lib/idlelib/delegator.py +Lib/idlelib/dynoption.py +Lib/idlelib/editor.py +Lib/idlelib/extend.txt +Lib/idlelib/filelist.py +Lib/idlelib/format.py +Lib/idlelib/grep.py +Lib/idlelib/help.html +Lib/idlelib/help.py +Lib/idlelib/help_about.py +Lib/idlelib/history.py +Lib/idlelib/hyperparser.py +Lib/idlelib/idle.bat +Lib/idlelib/idle.py +Lib/idlelib/idle.pyw +Lib/idlelib/idle_test/README.txt +Lib/idlelib/idle_test/__init__.py +Lib/idlelib/idle_test/__pycache__/__init__.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/htest.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/mock_idle.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/mock_tk.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/template.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_autocomplete.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_autocomplete_w.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_autoexpand.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_browser.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_calltip.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_calltip_w.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_codecontext.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_colorizer.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_config.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_config_key.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_configdialog.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_debugger.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_debugger_r.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_debugobj.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_debugobj_r.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_delegator.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_editmenu.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_editor.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_filelist.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_format.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_grep.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_help.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_help_about.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_history.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_hyperparser.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_iomenu.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_macosx.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_mainmenu.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_multicall.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_outwin.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_parenmatch.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_pathbrowser.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_percolator.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_pyparse.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_pyshell.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_query.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_redirector.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_replace.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_rpc.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_run.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_runscript.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_scrolledlist.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_search.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_searchbase.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_searchengine.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_sidebar.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_squeezer.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_stackviewer.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_statusbar.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_text.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_textview.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_tooltip.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_tree.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_undo.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_util.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_warning.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_window.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_zoomheight.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/test_zzdummy.cpython-311.pyc +Lib/idlelib/idle_test/__pycache__/tkinter_testing_utils.cpython-311.pyc +Lib/idlelib/idle_test/example_noext +Lib/idlelib/idle_test/example_stub.pyi +Lib/idlelib/idle_test/htest.py +Lib/idlelib/idle_test/mock_idle.py +Lib/idlelib/idle_test/mock_tk.py +Lib/idlelib/idle_test/template.py +Lib/idlelib/idle_test/test_autocomplete.py +Lib/idlelib/idle_test/test_autocomplete_w.py +Lib/idlelib/idle_test/test_autoexpand.py +Lib/idlelib/idle_test/test_browser.py +Lib/idlelib/idle_test/test_calltip.py +Lib/idlelib/idle_test/test_calltip_w.py +Lib/idlelib/idle_test/test_codecontext.py +Lib/idlelib/idle_test/test_colorizer.py +Lib/idlelib/idle_test/test_config.py +Lib/idlelib/idle_test/test_config_key.py +Lib/idlelib/idle_test/test_configdialog.py +Lib/idlelib/idle_test/test_debugger.py +Lib/idlelib/idle_test/test_debugger_r.py +Lib/idlelib/idle_test/test_debugobj.py +Lib/idlelib/idle_test/test_debugobj_r.py +Lib/idlelib/idle_test/test_delegator.py +Lib/idlelib/idle_test/test_editmenu.py +Lib/idlelib/idle_test/test_editor.py +Lib/idlelib/idle_test/test_filelist.py +Lib/idlelib/idle_test/test_format.py +Lib/idlelib/idle_test/test_grep.py +Lib/idlelib/idle_test/test_help.py +Lib/idlelib/idle_test/test_help_about.py +Lib/idlelib/idle_test/test_history.py +Lib/idlelib/idle_test/test_hyperparser.py +Lib/idlelib/idle_test/test_iomenu.py +Lib/idlelib/idle_test/test_macosx.py +Lib/idlelib/idle_test/test_mainmenu.py +Lib/idlelib/idle_test/test_multicall.py +Lib/idlelib/idle_test/test_outwin.py +Lib/idlelib/idle_test/test_parenmatch.py +Lib/idlelib/idle_test/test_pathbrowser.py +Lib/idlelib/idle_test/test_percolator.py +Lib/idlelib/idle_test/test_pyparse.py +Lib/idlelib/idle_test/test_pyshell.py +Lib/idlelib/idle_test/test_query.py +Lib/idlelib/idle_test/test_redirector.py +Lib/idlelib/idle_test/test_replace.py +Lib/idlelib/idle_test/test_rpc.py +Lib/idlelib/idle_test/test_run.py +Lib/idlelib/idle_test/test_runscript.py +Lib/idlelib/idle_test/test_scrolledlist.py +Lib/idlelib/idle_test/test_search.py +Lib/idlelib/idle_test/test_searchbase.py +Lib/idlelib/idle_test/test_searchengine.py +Lib/idlelib/idle_test/test_sidebar.py +Lib/idlelib/idle_test/test_squeezer.py +Lib/idlelib/idle_test/test_stackviewer.py +Lib/idlelib/idle_test/test_statusbar.py +Lib/idlelib/idle_test/test_text.py +Lib/idlelib/idle_test/test_textview.py +Lib/idlelib/idle_test/test_tooltip.py +Lib/idlelib/idle_test/test_tree.py +Lib/idlelib/idle_test/test_undo.py +Lib/idlelib/idle_test/test_util.py +Lib/idlelib/idle_test/test_warning.py +Lib/idlelib/idle_test/test_window.py +Lib/idlelib/idle_test/test_zoomheight.py +Lib/idlelib/idle_test/test_zzdummy.py +Lib/idlelib/idle_test/tkinter_testing_utils.py +Lib/idlelib/iomenu.py +Lib/idlelib/macosx.py +Lib/idlelib/mainmenu.py +Lib/idlelib/multicall.py +Lib/idlelib/outwin.py +Lib/idlelib/parenmatch.py +Lib/idlelib/pathbrowser.py +Lib/idlelib/percolator.py +Lib/idlelib/pyparse.py +Lib/idlelib/pyshell.py +Lib/idlelib/query.py +Lib/idlelib/redirector.py +Lib/idlelib/replace.py +Lib/idlelib/rpc.py +Lib/idlelib/run.py +Lib/idlelib/runscript.py +Lib/idlelib/scrolledlist.py +Lib/idlelib/search.py +Lib/idlelib/searchbase.py +Lib/idlelib/searchengine.py +Lib/idlelib/sidebar.py +Lib/idlelib/squeezer.py +Lib/idlelib/stackviewer.py +Lib/idlelib/statusbar.py +Lib/idlelib/textview.py +Lib/idlelib/tooltip.py +Lib/idlelib/tree.py +Lib/idlelib/undo.py +Lib/idlelib/util.py +Lib/idlelib/window.py +Lib/idlelib/zoomheight.py +Lib/idlelib/zzdummy.py +Lib/imaplib.py +Lib/imghdr.py +Lib/imp.py +Lib/importlib/__init__.py +Lib/importlib/__pycache__/__init__.cpython-311.pyc +Lib/importlib/__pycache__/_abc.cpython-311.pyc +Lib/importlib/__pycache__/_bootstrap.cpython-311.pyc +Lib/importlib/__pycache__/_bootstrap_external.cpython-311.pyc +Lib/importlib/__pycache__/abc.cpython-311.pyc +Lib/importlib/__pycache__/machinery.cpython-311.pyc +Lib/importlib/__pycache__/readers.cpython-311.pyc +Lib/importlib/__pycache__/simple.cpython-311.pyc +Lib/importlib/__pycache__/util.cpython-311.pyc +Lib/importlib/_abc.py +Lib/importlib/_bootstrap.py +Lib/importlib/_bootstrap_external.py +Lib/importlib/abc.py +Lib/importlib/machinery.py +Lib/importlib/metadata/__init__.py +Lib/importlib/metadata/__pycache__/__init__.cpython-311.pyc +Lib/importlib/metadata/__pycache__/_adapters.cpython-311.pyc +Lib/importlib/metadata/__pycache__/_collections.cpython-311.pyc +Lib/importlib/metadata/__pycache__/_functools.cpython-311.pyc +Lib/importlib/metadata/__pycache__/_itertools.cpython-311.pyc +Lib/importlib/metadata/__pycache__/_meta.cpython-311.pyc +Lib/importlib/metadata/__pycache__/_text.cpython-311.pyc +Lib/importlib/metadata/_adapters.py +Lib/importlib/metadata/_collections.py +Lib/importlib/metadata/_functools.py +Lib/importlib/metadata/_itertools.py +Lib/importlib/metadata/_meta.py +Lib/importlib/metadata/_text.py +Lib/importlib/readers.py +Lib/importlib/resources/__init__.py +Lib/importlib/resources/__pycache__/__init__.cpython-311.pyc +Lib/importlib/resources/__pycache__/_adapters.cpython-311.pyc +Lib/importlib/resources/__pycache__/_common.cpython-311.pyc +Lib/importlib/resources/__pycache__/_itertools.cpython-311.pyc +Lib/importlib/resources/__pycache__/_legacy.cpython-311.pyc +Lib/importlib/resources/__pycache__/abc.cpython-311.pyc +Lib/importlib/resources/__pycache__/readers.cpython-311.pyc +Lib/importlib/resources/__pycache__/simple.cpython-311.pyc +Lib/importlib/resources/_adapters.py +Lib/importlib/resources/_common.py +Lib/importlib/resources/_itertools.py +Lib/importlib/resources/_legacy.py +Lib/importlib/resources/abc.py +Lib/importlib/resources/readers.py +Lib/importlib/resources/simple.py +Lib/importlib/simple.py +Lib/importlib/util.py +Lib/inspect.py +Lib/io.py +Lib/ipaddress.py +Lib/json/__init__.py +Lib/json/__pycache__/__init__.cpython-311.pyc +Lib/json/__pycache__/decoder.cpython-311.pyc +Lib/json/__pycache__/encoder.cpython-311.pyc +Lib/json/__pycache__/scanner.cpython-311.pyc +Lib/json/__pycache__/tool.cpython-311.pyc +Lib/json/decoder.py +Lib/json/encoder.py +Lib/json/scanner.py +Lib/json/tool.py +Lib/keyword.py +Lib/lib2to3/Grammar.txt +Lib/lib2to3/Grammar3.11.15.final.0.pickle +Lib/lib2to3/PatternGrammar.txt +Lib/lib2to3/PatternGrammar3.11.15.final.0.pickle +Lib/lib2to3/__init__.py +Lib/lib2to3/__main__.py +Lib/lib2to3/__pycache__/__init__.cpython-311.pyc +Lib/lib2to3/__pycache__/__main__.cpython-311.pyc +Lib/lib2to3/__pycache__/btm_matcher.cpython-311.pyc +Lib/lib2to3/__pycache__/btm_utils.cpython-311.pyc +Lib/lib2to3/__pycache__/fixer_base.cpython-311.pyc +Lib/lib2to3/__pycache__/fixer_util.cpython-311.pyc +Lib/lib2to3/__pycache__/main.cpython-311.pyc +Lib/lib2to3/__pycache__/patcomp.cpython-311.pyc +Lib/lib2to3/__pycache__/pygram.cpython-311.pyc +Lib/lib2to3/__pycache__/pytree.cpython-311.pyc +Lib/lib2to3/__pycache__/refactor.cpython-311.pyc +Lib/lib2to3/btm_matcher.py +Lib/lib2to3/btm_utils.py +Lib/lib2to3/fixer_base.py +Lib/lib2to3/fixer_util.py +Lib/lib2to3/fixes/__init__.py +Lib/lib2to3/fixes/__pycache__/__init__.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_apply.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_asserts.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_basestring.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_buffer.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_dict.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_except.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_exec.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_execfile.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_exitfunc.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_filter.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_funcattrs.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_future.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_getcwdu.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_has_key.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_idioms.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_import.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_imports.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_imports2.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_input.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_intern.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_isinstance.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_itertools.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_itertools_imports.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_long.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_map.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_metaclass.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_methodattrs.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_ne.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_next.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_nonzero.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_numliterals.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_operator.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_paren.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_print.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_raise.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_raw_input.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_reduce.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_reload.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_renames.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_repr.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_set_literal.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_standarderror.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_sys_exc.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_throw.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_tuple_params.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_types.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_unicode.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_urllib.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_ws_comma.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_xrange.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_xreadlines.cpython-311.pyc +Lib/lib2to3/fixes/__pycache__/fix_zip.cpython-311.pyc +Lib/lib2to3/fixes/fix_apply.py +Lib/lib2to3/fixes/fix_asserts.py +Lib/lib2to3/fixes/fix_basestring.py +Lib/lib2to3/fixes/fix_buffer.py +Lib/lib2to3/fixes/fix_dict.py +Lib/lib2to3/fixes/fix_except.py +Lib/lib2to3/fixes/fix_exec.py +Lib/lib2to3/fixes/fix_execfile.py +Lib/lib2to3/fixes/fix_exitfunc.py +Lib/lib2to3/fixes/fix_filter.py +Lib/lib2to3/fixes/fix_funcattrs.py +Lib/lib2to3/fixes/fix_future.py +Lib/lib2to3/fixes/fix_getcwdu.py +Lib/lib2to3/fixes/fix_has_key.py +Lib/lib2to3/fixes/fix_idioms.py +Lib/lib2to3/fixes/fix_import.py +Lib/lib2to3/fixes/fix_imports.py +Lib/lib2to3/fixes/fix_imports2.py +Lib/lib2to3/fixes/fix_input.py +Lib/lib2to3/fixes/fix_intern.py +Lib/lib2to3/fixes/fix_isinstance.py +Lib/lib2to3/fixes/fix_itertools.py +Lib/lib2to3/fixes/fix_itertools_imports.py +Lib/lib2to3/fixes/fix_long.py +Lib/lib2to3/fixes/fix_map.py +Lib/lib2to3/fixes/fix_metaclass.py +Lib/lib2to3/fixes/fix_methodattrs.py +Lib/lib2to3/fixes/fix_ne.py +Lib/lib2to3/fixes/fix_next.py +Lib/lib2to3/fixes/fix_nonzero.py +Lib/lib2to3/fixes/fix_numliterals.py +Lib/lib2to3/fixes/fix_operator.py +Lib/lib2to3/fixes/fix_paren.py +Lib/lib2to3/fixes/fix_print.py +Lib/lib2to3/fixes/fix_raise.py +Lib/lib2to3/fixes/fix_raw_input.py +Lib/lib2to3/fixes/fix_reduce.py +Lib/lib2to3/fixes/fix_reload.py +Lib/lib2to3/fixes/fix_renames.py +Lib/lib2to3/fixes/fix_repr.py +Lib/lib2to3/fixes/fix_set_literal.py +Lib/lib2to3/fixes/fix_standarderror.py +Lib/lib2to3/fixes/fix_sys_exc.py +Lib/lib2to3/fixes/fix_throw.py +Lib/lib2to3/fixes/fix_tuple_params.py +Lib/lib2to3/fixes/fix_types.py +Lib/lib2to3/fixes/fix_unicode.py +Lib/lib2to3/fixes/fix_urllib.py +Lib/lib2to3/fixes/fix_ws_comma.py +Lib/lib2to3/fixes/fix_xrange.py +Lib/lib2to3/fixes/fix_xreadlines.py +Lib/lib2to3/fixes/fix_zip.py +Lib/lib2to3/main.py +Lib/lib2to3/patcomp.py +Lib/lib2to3/pgen2/__init__.py +Lib/lib2to3/pgen2/__pycache__/__init__.cpython-311.pyc +Lib/lib2to3/pgen2/__pycache__/conv.cpython-311.pyc +Lib/lib2to3/pgen2/__pycache__/driver.cpython-311.pyc +Lib/lib2to3/pgen2/__pycache__/grammar.cpython-311.pyc +Lib/lib2to3/pgen2/__pycache__/literals.cpython-311.pyc +Lib/lib2to3/pgen2/__pycache__/parse.cpython-311.pyc +Lib/lib2to3/pgen2/__pycache__/pgen.cpython-311.pyc +Lib/lib2to3/pgen2/__pycache__/token.cpython-311.pyc +Lib/lib2to3/pgen2/__pycache__/tokenize.cpython-311.pyc +Lib/lib2to3/pgen2/conv.py +Lib/lib2to3/pgen2/driver.py +Lib/lib2to3/pgen2/grammar.py +Lib/lib2to3/pgen2/literals.py +Lib/lib2to3/pgen2/parse.py +Lib/lib2to3/pgen2/pgen.py +Lib/lib2to3/pgen2/token.py +Lib/lib2to3/pgen2/tokenize.py +Lib/lib2to3/pygram.py +Lib/lib2to3/pytree.py +Lib/lib2to3/refactor.py +Lib/linecache.py +Lib/locale.py +Lib/logging/__init__.py +Lib/logging/__pycache__/__init__.cpython-311.pyc +Lib/logging/__pycache__/config.cpython-311.pyc +Lib/logging/__pycache__/handlers.cpython-311.pyc +Lib/logging/config.py +Lib/logging/handlers.py +Lib/lzma.py +Lib/mailbox.py +Lib/mailcap.py +Lib/mimetypes.py +Lib/modulefinder.py +Lib/msilib/__init__.py +Lib/msilib/__pycache__/__init__.cpython-311.pyc +Lib/msilib/__pycache__/schema.cpython-311.pyc +Lib/msilib/__pycache__/sequence.cpython-311.pyc +Lib/msilib/__pycache__/text.cpython-311.pyc +Lib/msilib/schema.py +Lib/msilib/sequence.py +Lib/msilib/text.py +Lib/multiprocessing/__init__.py +Lib/multiprocessing/__pycache__/__init__.cpython-311.pyc +Lib/multiprocessing/__pycache__/connection.cpython-311.pyc +Lib/multiprocessing/__pycache__/context.cpython-311.pyc +Lib/multiprocessing/__pycache__/forkserver.cpython-311.pyc +Lib/multiprocessing/__pycache__/heap.cpython-311.pyc +Lib/multiprocessing/__pycache__/managers.cpython-311.pyc +Lib/multiprocessing/__pycache__/pool.cpython-311.pyc +Lib/multiprocessing/__pycache__/popen_fork.cpython-311.pyc +Lib/multiprocessing/__pycache__/popen_forkserver.cpython-311.pyc +Lib/multiprocessing/__pycache__/popen_spawn_posix.cpython-311.pyc +Lib/multiprocessing/__pycache__/popen_spawn_win32.cpython-311.pyc +Lib/multiprocessing/__pycache__/process.cpython-311.pyc +Lib/multiprocessing/__pycache__/queues.cpython-311.pyc +Lib/multiprocessing/__pycache__/reduction.cpython-311.pyc +Lib/multiprocessing/__pycache__/resource_sharer.cpython-311.pyc +Lib/multiprocessing/__pycache__/resource_tracker.cpython-311.pyc +Lib/multiprocessing/__pycache__/shared_memory.cpython-311.pyc +Lib/multiprocessing/__pycache__/sharedctypes.cpython-311.pyc +Lib/multiprocessing/__pycache__/spawn.cpython-311.pyc +Lib/multiprocessing/__pycache__/synchronize.cpython-311.pyc +Lib/multiprocessing/__pycache__/util.cpython-311.pyc +Lib/multiprocessing/connection.py +Lib/multiprocessing/context.py +Lib/multiprocessing/dummy/__init__.py +Lib/multiprocessing/dummy/__pycache__/__init__.cpython-311.pyc +Lib/multiprocessing/dummy/__pycache__/connection.cpython-311.pyc +Lib/multiprocessing/dummy/connection.py +Lib/multiprocessing/forkserver.py +Lib/multiprocessing/heap.py +Lib/multiprocessing/managers.py +Lib/multiprocessing/pool.py +Lib/multiprocessing/popen_fork.py +Lib/multiprocessing/popen_forkserver.py +Lib/multiprocessing/popen_spawn_posix.py +Lib/multiprocessing/popen_spawn_win32.py +Lib/multiprocessing/process.py +Lib/multiprocessing/queues.py +Lib/multiprocessing/reduction.py +Lib/multiprocessing/resource_sharer.py +Lib/multiprocessing/resource_tracker.py +Lib/multiprocessing/shared_memory.py +Lib/multiprocessing/sharedctypes.py +Lib/multiprocessing/spawn.py +Lib/multiprocessing/synchronize.py +Lib/multiprocessing/util.py +Lib/netrc.py +Lib/nntplib.py +Lib/ntpath.py +Lib/nturl2path.py +Lib/numbers.py +Lib/opcode.py +Lib/operator.py +Lib/optparse.py +Lib/os.py +Lib/pathlib.py +Lib/pdb.py +Lib/pickle.py +Lib/pickletools.py +Lib/pipes.py +Lib/pkgutil.py +Lib/platform.py +Lib/plistlib.py +Lib/poplib.py +Lib/posixpath.py +Lib/pprint.py +Lib/profile.py +Lib/pstats.py +Lib/pty.py +Lib/py_compile.py +Lib/pyclbr.py +Lib/pydoc.py +Lib/pydoc_data/__init__.py +Lib/pydoc_data/__pycache__/__init__.cpython-311.pyc +Lib/pydoc_data/__pycache__/topics.cpython-311.pyc +Lib/pydoc_data/_pydoc.css +Lib/pydoc_data/topics.py +Lib/queue.py +Lib/quopri.py +Lib/random.py +Lib/re/__init__.py +Lib/re/__pycache__/__init__.cpython-311.pyc +Lib/re/__pycache__/_casefix.cpython-311.pyc +Lib/re/__pycache__/_compiler.cpython-311.pyc +Lib/re/__pycache__/_constants.cpython-311.pyc +Lib/re/__pycache__/_parser.cpython-311.pyc +Lib/re/_casefix.py +Lib/re/_compiler.py +Lib/re/_constants.py +Lib/re/_parser.py +Lib/reprlib.py +Lib/rlcompleter.py +Lib/runpy.py +Lib/sched.py +Lib/secrets.py +Lib/selectors.py +Lib/shelve.py +Lib/shlex.py +Lib/shutil.py +Lib/signal.py +Lib/site-packages/README.txt +Lib/site.py +Lib/smtpd.py +Lib/smtplib.py +Lib/sndhdr.py +Lib/socket.py +Lib/socketserver.py +Lib/sqlite3/__init__.py +Lib/sqlite3/__pycache__/__init__.cpython-311.pyc +Lib/sqlite3/__pycache__/dbapi2.cpython-311.pyc +Lib/sqlite3/__pycache__/dump.cpython-311.pyc +Lib/sqlite3/dbapi2.py +Lib/sqlite3/dump.py +Lib/sre_compile.py +Lib/sre_constants.py +Lib/sre_parse.py +Lib/ssl.py +Lib/stat.py +Lib/statistics.py +Lib/string.py +Lib/stringprep.py +Lib/struct.py +Lib/subprocess.py +Lib/sunau.py +Lib/symtable.py +Lib/sysconfig.py +Lib/tabnanny.py +Lib/tarfile.py +Lib/telnetlib.py +Lib/tempfile.py +Lib/test/__init__.py +Lib/test/__pycache__/__init__.cpython-311.pyc +Lib/test/support/__init__.py +Lib/test/support/__pycache__/__init__.cpython-311.pyc +Lib/test/support/__pycache__/bytecode_helper.cpython-311.pyc +Lib/test/support/__pycache__/hashlib_helper.cpython-311.pyc +Lib/test/support/__pycache__/import_helper.cpython-311.pyc +Lib/test/support/__pycache__/interpreters.cpython-311.pyc +Lib/test/support/__pycache__/logging_helper.cpython-311.pyc +Lib/test/support/__pycache__/os_helper.cpython-311.pyc +Lib/test/support/__pycache__/pty_helper.cpython-311.pyc +Lib/test/support/__pycache__/script_helper.cpython-311.pyc +Lib/test/support/__pycache__/socket_helper.cpython-311.pyc +Lib/test/support/__pycache__/threading_helper.cpython-311.pyc +Lib/test/support/__pycache__/warnings_helper.cpython-311.pyc +Lib/test/support/bytecode_helper.py +Lib/test/support/hashlib_helper.py +Lib/test/support/import_helper.py +Lib/test/support/interpreters.py +Lib/test/support/logging_helper.py +Lib/test/support/os_helper.py +Lib/test/support/pty_helper.py +Lib/test/support/script_helper.py +Lib/test/support/socket_helper.py +Lib/test/support/threading_helper.py +Lib/test/support/warnings_helper.py +Lib/textwrap.py +Lib/this.py +Lib/threading.py +Lib/timeit.py +Lib/tkinter/__init__.py +Lib/tkinter/__main__.py +Lib/tkinter/__pycache__/__init__.cpython-311.pyc +Lib/tkinter/__pycache__/__main__.cpython-311.pyc +Lib/tkinter/__pycache__/colorchooser.cpython-311.pyc +Lib/tkinter/__pycache__/commondialog.cpython-311.pyc +Lib/tkinter/__pycache__/constants.cpython-311.pyc +Lib/tkinter/__pycache__/dialog.cpython-311.pyc +Lib/tkinter/__pycache__/dnd.cpython-311.pyc +Lib/tkinter/__pycache__/filedialog.cpython-311.pyc +Lib/tkinter/__pycache__/font.cpython-311.pyc +Lib/tkinter/__pycache__/messagebox.cpython-311.pyc +Lib/tkinter/__pycache__/scrolledtext.cpython-311.pyc +Lib/tkinter/__pycache__/simpledialog.cpython-311.pyc +Lib/tkinter/__pycache__/tix.cpython-311.pyc +Lib/tkinter/__pycache__/ttk.cpython-311.pyc +Lib/tkinter/colorchooser.py +Lib/tkinter/commondialog.py +Lib/tkinter/constants.py +Lib/tkinter/dialog.py +Lib/tkinter/dnd.py +Lib/tkinter/filedialog.py +Lib/tkinter/font.py +Lib/tkinter/messagebox.py +Lib/tkinter/scrolledtext.py +Lib/tkinter/simpledialog.py +Lib/tkinter/test/README +Lib/tkinter/test/__init__.py +Lib/tkinter/test/__pycache__/__init__.cpython-311.pyc +Lib/tkinter/test/__pycache__/support.cpython-311.pyc +Lib/tkinter/test/__pycache__/widget_tests.cpython-311.pyc +Lib/tkinter/test/support.py +Lib/tkinter/test/test_tkinter/__init__.py +Lib/tkinter/test/test_tkinter/__pycache__/__init__.cpython-311.pyc +Lib/tkinter/test/test_tkinter/__pycache__/test_colorchooser.cpython-311.pyc +Lib/tkinter/test/test_tkinter/__pycache__/test_font.cpython-311.pyc +Lib/tkinter/test/test_tkinter/__pycache__/test_geometry_managers.cpython-311.pyc +Lib/tkinter/test/test_tkinter/__pycache__/test_images.cpython-311.pyc +Lib/tkinter/test/test_tkinter/__pycache__/test_loadtk.cpython-311.pyc +Lib/tkinter/test/test_tkinter/__pycache__/test_messagebox.cpython-311.pyc +Lib/tkinter/test/test_tkinter/__pycache__/test_misc.cpython-311.pyc +Lib/tkinter/test/test_tkinter/__pycache__/test_simpledialog.cpython-311.pyc +Lib/tkinter/test/test_tkinter/__pycache__/test_text.cpython-311.pyc +Lib/tkinter/test/test_tkinter/__pycache__/test_variables.cpython-311.pyc +Lib/tkinter/test/test_tkinter/__pycache__/test_widgets.cpython-311.pyc +Lib/tkinter/test/test_tkinter/test_colorchooser.py +Lib/tkinter/test/test_tkinter/test_font.py +Lib/tkinter/test/test_tkinter/test_geometry_managers.py +Lib/tkinter/test/test_tkinter/test_images.py +Lib/tkinter/test/test_tkinter/test_loadtk.py +Lib/tkinter/test/test_tkinter/test_messagebox.py +Lib/tkinter/test/test_tkinter/test_misc.py +Lib/tkinter/test/test_tkinter/test_simpledialog.py +Lib/tkinter/test/test_tkinter/test_text.py +Lib/tkinter/test/test_tkinter/test_variables.py +Lib/tkinter/test/test_tkinter/test_widgets.py +Lib/tkinter/test/test_ttk/__init__.py +Lib/tkinter/test/test_ttk/__pycache__/__init__.cpython-311.pyc +Lib/tkinter/test/test_ttk/__pycache__/test_extensions.cpython-311.pyc +Lib/tkinter/test/test_ttk/__pycache__/test_style.cpython-311.pyc +Lib/tkinter/test/test_ttk/__pycache__/test_widgets.cpython-311.pyc +Lib/tkinter/test/test_ttk/test_extensions.py +Lib/tkinter/test/test_ttk/test_style.py +Lib/tkinter/test/test_ttk/test_widgets.py +Lib/tkinter/test/widget_tests.py +Lib/tkinter/tix.py +Lib/tkinter/ttk.py +Lib/token.py +Lib/tokenize.py +Lib/tomllib/__init__.py +Lib/tomllib/__pycache__/__init__.cpython-311.pyc +Lib/tomllib/__pycache__/_parser.cpython-311.pyc +Lib/tomllib/__pycache__/_re.cpython-311.pyc +Lib/tomllib/__pycache__/_types.cpython-311.pyc +Lib/tomllib/_parser.py +Lib/tomllib/_re.py +Lib/tomllib/_types.py +Lib/trace.py +Lib/traceback.py +Lib/tracemalloc.py +Lib/tty.py +Lib/turtle.py +Lib/turtledemo/__init__.py +Lib/turtledemo/__main__.py +Lib/turtledemo/__pycache__/__init__.cpython-311.pyc +Lib/turtledemo/__pycache__/__main__.cpython-311.pyc +Lib/turtledemo/__pycache__/bytedesign.cpython-311.pyc +Lib/turtledemo/__pycache__/chaos.cpython-311.pyc +Lib/turtledemo/__pycache__/clock.cpython-311.pyc +Lib/turtledemo/__pycache__/colormixer.cpython-311.pyc +Lib/turtledemo/__pycache__/forest.cpython-311.pyc +Lib/turtledemo/__pycache__/fractalcurves.cpython-311.pyc +Lib/turtledemo/__pycache__/lindenmayer.cpython-311.pyc +Lib/turtledemo/__pycache__/minimal_hanoi.cpython-311.pyc +Lib/turtledemo/__pycache__/nim.cpython-311.pyc +Lib/turtledemo/__pycache__/paint.cpython-311.pyc +Lib/turtledemo/__pycache__/peace.cpython-311.pyc +Lib/turtledemo/__pycache__/penrose.cpython-311.pyc +Lib/turtledemo/__pycache__/planet_and_moon.cpython-311.pyc +Lib/turtledemo/__pycache__/rosette.cpython-311.pyc +Lib/turtledemo/__pycache__/round_dance.cpython-311.pyc +Lib/turtledemo/__pycache__/sorting_animate.cpython-311.pyc +Lib/turtledemo/__pycache__/tree.cpython-311.pyc +Lib/turtledemo/__pycache__/two_canvases.cpython-311.pyc +Lib/turtledemo/__pycache__/yinyang.cpython-311.pyc +Lib/turtledemo/bytedesign.py +Lib/turtledemo/chaos.py +Lib/turtledemo/clock.py +Lib/turtledemo/colormixer.py +Lib/turtledemo/forest.py +Lib/turtledemo/fractalcurves.py +Lib/turtledemo/lindenmayer.py +Lib/turtledemo/minimal_hanoi.py +Lib/turtledemo/nim.py +Lib/turtledemo/paint.py +Lib/turtledemo/peace.py +Lib/turtledemo/penrose.py +Lib/turtledemo/planet_and_moon.py +Lib/turtledemo/rosette.py +Lib/turtledemo/round_dance.py +Lib/turtledemo/sorting_animate.py +Lib/turtledemo/tree.py +Lib/turtledemo/turtle.cfg +Lib/turtledemo/two_canvases.py +Lib/turtledemo/yinyang.py +Lib/types.py +Lib/typing.py +Lib/unittest/__init__.py +Lib/unittest/__main__.py +Lib/unittest/__pycache__/__init__.cpython-311.pyc +Lib/unittest/__pycache__/__main__.cpython-311.pyc +Lib/unittest/__pycache__/_log.cpython-311.pyc +Lib/unittest/__pycache__/async_case.cpython-311.pyc +Lib/unittest/__pycache__/case.cpython-311.pyc +Lib/unittest/__pycache__/loader.cpython-311.pyc +Lib/unittest/__pycache__/main.cpython-311.pyc +Lib/unittest/__pycache__/mock.cpython-311.pyc +Lib/unittest/__pycache__/result.cpython-311.pyc +Lib/unittest/__pycache__/runner.cpython-311.pyc +Lib/unittest/__pycache__/signals.cpython-311.pyc +Lib/unittest/__pycache__/suite.cpython-311.pyc +Lib/unittest/__pycache__/util.cpython-311.pyc +Lib/unittest/_log.py +Lib/unittest/async_case.py +Lib/unittest/case.py +Lib/unittest/loader.py +Lib/unittest/main.py +Lib/unittest/mock.py +Lib/unittest/result.py +Lib/unittest/runner.py +Lib/unittest/signals.py +Lib/unittest/suite.py +Lib/unittest/test/__init__.py +Lib/unittest/test/__main__.py +Lib/unittest/test/__pycache__/__init__.cpython-311.pyc +Lib/unittest/test/__pycache__/__main__.cpython-311.pyc +Lib/unittest/test/__pycache__/_test_warnings.cpython-311.pyc +Lib/unittest/test/__pycache__/dummy.cpython-311.pyc +Lib/unittest/test/__pycache__/support.cpython-311.pyc +Lib/unittest/test/__pycache__/test_assertions.cpython-311.pyc +Lib/unittest/test/__pycache__/test_async_case.cpython-311.pyc +Lib/unittest/test/__pycache__/test_break.cpython-311.pyc +Lib/unittest/test/__pycache__/test_case.cpython-311.pyc +Lib/unittest/test/__pycache__/test_discovery.cpython-311.pyc +Lib/unittest/test/__pycache__/test_functiontestcase.cpython-311.pyc +Lib/unittest/test/__pycache__/test_loader.cpython-311.pyc +Lib/unittest/test/__pycache__/test_program.cpython-311.pyc +Lib/unittest/test/__pycache__/test_result.cpython-311.pyc +Lib/unittest/test/__pycache__/test_runner.cpython-311.pyc +Lib/unittest/test/__pycache__/test_setups.cpython-311.pyc +Lib/unittest/test/__pycache__/test_skipping.cpython-311.pyc +Lib/unittest/test/__pycache__/test_suite.cpython-311.pyc +Lib/unittest/test/_test_warnings.py +Lib/unittest/test/dummy.py +Lib/unittest/test/support.py +Lib/unittest/test/test_assertions.py +Lib/unittest/test/test_async_case.py +Lib/unittest/test/test_break.py +Lib/unittest/test/test_case.py +Lib/unittest/test/test_discovery.py +Lib/unittest/test/test_functiontestcase.py +Lib/unittest/test/test_loader.py +Lib/unittest/test/test_program.py +Lib/unittest/test/test_result.py +Lib/unittest/test/test_runner.py +Lib/unittest/test/test_setups.py +Lib/unittest/test/test_skipping.py +Lib/unittest/test/test_suite.py +Lib/unittest/test/testmock/__init__.py +Lib/unittest/test/testmock/__main__.py +Lib/unittest/test/testmock/__pycache__/__init__.cpython-311.pyc +Lib/unittest/test/testmock/__pycache__/__main__.cpython-311.pyc +Lib/unittest/test/testmock/__pycache__/support.cpython-311.pyc +Lib/unittest/test/testmock/__pycache__/testasync.cpython-311.pyc +Lib/unittest/test/testmock/__pycache__/testcallable.cpython-311.pyc +Lib/unittest/test/testmock/__pycache__/testhelpers.cpython-311.pyc +Lib/unittest/test/testmock/__pycache__/testmagicmethods.cpython-311.pyc +Lib/unittest/test/testmock/__pycache__/testmock.cpython-311.pyc +Lib/unittest/test/testmock/__pycache__/testpatch.cpython-311.pyc +Lib/unittest/test/testmock/__pycache__/testsealable.cpython-311.pyc +Lib/unittest/test/testmock/__pycache__/testsentinel.cpython-311.pyc +Lib/unittest/test/testmock/__pycache__/testwith.cpython-311.pyc +Lib/unittest/test/testmock/support.py +Lib/unittest/test/testmock/testasync.py +Lib/unittest/test/testmock/testcallable.py +Lib/unittest/test/testmock/testhelpers.py +Lib/unittest/test/testmock/testmagicmethods.py +Lib/unittest/test/testmock/testmock.py +Lib/unittest/test/testmock/testpatch.py +Lib/unittest/test/testmock/testsealable.py +Lib/unittest/test/testmock/testsentinel.py +Lib/unittest/test/testmock/testwith.py +Lib/unittest/util.py +Lib/urllib/__init__.py +Lib/urllib/__pycache__/__init__.cpython-311.pyc +Lib/urllib/__pycache__/error.cpython-311.pyc +Lib/urllib/__pycache__/parse.cpython-311.pyc +Lib/urllib/__pycache__/request.cpython-311.pyc +Lib/urllib/__pycache__/response.cpython-311.pyc +Lib/urllib/__pycache__/robotparser.cpython-311.pyc +Lib/urllib/error.py +Lib/urllib/parse.py +Lib/urllib/request.py +Lib/urllib/response.py +Lib/urllib/robotparser.py +Lib/uu.py +Lib/uuid.py +Lib/venv/__init__.py +Lib/venv/__main__.py +Lib/venv/__pycache__/__init__.cpython-311.pyc +Lib/venv/__pycache__/__main__.cpython-311.pyc +Lib/venv/scripts/common/Activate.ps1 +Lib/venv/scripts/common/activate +Lib/venv/scripts/nt/activate.bat +Lib/venv/scripts/nt/deactivate.bat +Lib/venv/scripts/nt/python.exe +Lib/venv/scripts/nt/pythonw.exe +Lib/venv/scripts/posix/activate.csh +Lib/venv/scripts/posix/activate.fish +Lib/warnings.py +Lib/wave.py +Lib/weakref.py +Lib/webbrowser.py +Lib/wsgiref/__init__.py +Lib/wsgiref/__pycache__/__init__.cpython-311.pyc +Lib/wsgiref/__pycache__/handlers.cpython-311.pyc +Lib/wsgiref/__pycache__/headers.cpython-311.pyc +Lib/wsgiref/__pycache__/simple_server.cpython-311.pyc +Lib/wsgiref/__pycache__/types.cpython-311.pyc +Lib/wsgiref/__pycache__/util.cpython-311.pyc +Lib/wsgiref/__pycache__/validate.cpython-311.pyc +Lib/wsgiref/handlers.py +Lib/wsgiref/headers.py +Lib/wsgiref/simple_server.py +Lib/wsgiref/types.py +Lib/wsgiref/util.py +Lib/wsgiref/validate.py +Lib/xdrlib.py +Lib/xml/__init__.py +Lib/xml/__pycache__/__init__.cpython-311.pyc +Lib/xml/dom/NodeFilter.py +Lib/xml/dom/__init__.py +Lib/xml/dom/__pycache__/NodeFilter.cpython-311.pyc +Lib/xml/dom/__pycache__/__init__.cpython-311.pyc +Lib/xml/dom/__pycache__/domreg.cpython-311.pyc +Lib/xml/dom/__pycache__/expatbuilder.cpython-311.pyc +Lib/xml/dom/__pycache__/minicompat.cpython-311.pyc +Lib/xml/dom/__pycache__/minidom.cpython-311.pyc +Lib/xml/dom/__pycache__/pulldom.cpython-311.pyc +Lib/xml/dom/__pycache__/xmlbuilder.cpython-311.pyc +Lib/xml/dom/domreg.py +Lib/xml/dom/expatbuilder.py +Lib/xml/dom/minicompat.py +Lib/xml/dom/minidom.py +Lib/xml/dom/pulldom.py +Lib/xml/dom/xmlbuilder.py +Lib/xml/etree/ElementInclude.py +Lib/xml/etree/ElementPath.py +Lib/xml/etree/ElementTree.py +Lib/xml/etree/__init__.py +Lib/xml/etree/__pycache__/ElementInclude.cpython-311.pyc +Lib/xml/etree/__pycache__/ElementPath.cpython-311.pyc +Lib/xml/etree/__pycache__/ElementTree.cpython-311.pyc +Lib/xml/etree/__pycache__/__init__.cpython-311.pyc +Lib/xml/etree/__pycache__/cElementTree.cpython-311.pyc +Lib/xml/etree/cElementTree.py +Lib/xml/parsers/__init__.py +Lib/xml/parsers/__pycache__/__init__.cpython-311.pyc +Lib/xml/parsers/__pycache__/expat.cpython-311.pyc +Lib/xml/parsers/expat.py +Lib/xml/sax/__init__.py +Lib/xml/sax/__pycache__/__init__.cpython-311.pyc +Lib/xml/sax/__pycache__/_exceptions.cpython-311.pyc +Lib/xml/sax/__pycache__/expatreader.cpython-311.pyc +Lib/xml/sax/__pycache__/handler.cpython-311.pyc +Lib/xml/sax/__pycache__/saxutils.cpython-311.pyc +Lib/xml/sax/__pycache__/xmlreader.cpython-311.pyc +Lib/xml/sax/_exceptions.py +Lib/xml/sax/expatreader.py +Lib/xml/sax/handler.py +Lib/xml/sax/saxutils.py +Lib/xml/sax/xmlreader.py +Lib/xmlrpc/__init__.py +Lib/xmlrpc/__pycache__/__init__.cpython-311.pyc +Lib/xmlrpc/__pycache__/client.cpython-311.pyc +Lib/xmlrpc/__pycache__/server.cpython-311.pyc +Lib/xmlrpc/client.py +Lib/xmlrpc/server.py +Lib/zipapp.py +Lib/zipfile.py +Lib/zipimport.py +Lib/zoneinfo/__init__.py +Lib/zoneinfo/__pycache__/__init__.cpython-311.pyc +Lib/zoneinfo/__pycache__/_common.cpython-311.pyc +Lib/zoneinfo/__pycache__/_tzpath.cpython-311.pyc +Lib/zoneinfo/__pycache__/_zoneinfo.cpython-311.pyc +Lib/zoneinfo/_common.py +Lib/zoneinfo/_tzpath.py +Lib/zoneinfo/_zoneinfo.py +Scripts/2to3-script.py +Scripts/2to3.exe +Scripts/idle-script.py +Scripts/idle.exe +Scripts/pydoc-script.py +Scripts/pydoc.exe +Tools/demo/__pycache__/beer.cpython-311.pyc +Tools/demo/__pycache__/eiffel.cpython-311.pyc +Tools/demo/__pycache__/hanoi.cpython-311.pyc +Tools/demo/__pycache__/life.cpython-311.pyc +Tools/demo/__pycache__/markov.cpython-311.pyc +Tools/demo/__pycache__/mcast.cpython-311.pyc +Tools/demo/__pycache__/queens.cpython-311.pyc +Tools/demo/__pycache__/redemo.cpython-311.pyc +Tools/demo/__pycache__/rpython.cpython-311.pyc +Tools/demo/__pycache__/rpythond.cpython-311.pyc +Tools/demo/__pycache__/sortvisu.cpython-311.pyc +Tools/demo/__pycache__/spreadsheet.cpython-311.pyc +Tools/demo/__pycache__/vector.cpython-311.pyc +Tools/demo/beer.py +Tools/demo/eiffel.py +Tools/demo/hanoi.py +Tools/demo/life.py +Tools/demo/markov.py +Tools/demo/mcast.py +Tools/demo/queens.py +Tools/demo/redemo.py +Tools/demo/rpython.py +Tools/demo/rpythond.py +Tools/demo/sortvisu.py +Tools/demo/spreadsheet.py +Tools/demo/vector.py +Tools/i18n/__pycache__/makelocalealias.cpython-311.pyc +Tools/i18n/__pycache__/msgfmt.cpython-311.pyc +Tools/i18n/__pycache__/pygettext.cpython-311.pyc +Tools/i18n/makelocalealias.py +Tools/i18n/msgfmt.py +Tools/i18n/pygettext.py +Tools/scripts/2to3.py +Tools/scripts/__pycache__/2to3.cpython-311.pyc +Tools/scripts/__pycache__/abitype.cpython-311.pyc +Tools/scripts/__pycache__/analyze_dxp.cpython-311.pyc +Tools/scripts/__pycache__/byext.cpython-311.pyc +Tools/scripts/__pycache__/byteyears.cpython-311.pyc +Tools/scripts/__pycache__/checkpip.cpython-311.pyc +Tools/scripts/__pycache__/cleanfuture.cpython-311.pyc +Tools/scripts/__pycache__/combinerefs.cpython-311.pyc +Tools/scripts/__pycache__/copytime.cpython-311.pyc +Tools/scripts/__pycache__/crlf.cpython-311.pyc +Tools/scripts/__pycache__/db2pickle.cpython-311.pyc +Tools/scripts/__pycache__/deepfreeze.cpython-311.pyc +Tools/scripts/__pycache__/diff.cpython-311.pyc +Tools/scripts/__pycache__/dutree.cpython-311.pyc +Tools/scripts/__pycache__/eptags.cpython-311.pyc +Tools/scripts/__pycache__/find-uname.cpython-311.pyc +Tools/scripts/__pycache__/find_recursionlimit.cpython-311.pyc +Tools/scripts/__pycache__/finddiv.cpython-311.pyc +Tools/scripts/__pycache__/findlinksto.cpython-311.pyc +Tools/scripts/__pycache__/findnocoding.cpython-311.pyc +Tools/scripts/__pycache__/fixcid.cpython-311.pyc +Tools/scripts/__pycache__/fixdiv.cpython-311.pyc +Tools/scripts/__pycache__/fixheader.cpython-311.pyc +Tools/scripts/__pycache__/fixnotice.cpython-311.pyc +Tools/scripts/__pycache__/fixps.cpython-311.pyc +Tools/scripts/__pycache__/freeze_modules.cpython-311.pyc +Tools/scripts/__pycache__/generate_global_objects.cpython-310.pyc +Tools/scripts/__pycache__/generate_global_objects.cpython-311.pyc +Tools/scripts/__pycache__/generate_opcode_h.cpython-311.pyc +Tools/scripts/__pycache__/generate_re_casefix.cpython-311.pyc +Tools/scripts/__pycache__/generate_sre_constants.cpython-311.pyc +Tools/scripts/__pycache__/generate_stdlib_module_names.cpython-311.pyc +Tools/scripts/__pycache__/generate_token.cpython-311.pyc +Tools/scripts/__pycache__/get-remote-certificate.cpython-311.pyc +Tools/scripts/__pycache__/google.cpython-311.pyc +Tools/scripts/__pycache__/gprof2html.cpython-311.pyc +Tools/scripts/__pycache__/highlight.cpython-311.pyc +Tools/scripts/__pycache__/ifdef.cpython-311.pyc +Tools/scripts/__pycache__/import_diagnostics.cpython-311.pyc +Tools/scripts/__pycache__/lfcr.cpython-311.pyc +Tools/scripts/__pycache__/linktree.cpython-311.pyc +Tools/scripts/__pycache__/lll.cpython-311.pyc +Tools/scripts/__pycache__/mailerdaemon.cpython-311.pyc +Tools/scripts/__pycache__/make_ctype.cpython-311.pyc +Tools/scripts/__pycache__/md5sum.cpython-311.pyc +Tools/scripts/__pycache__/mkreal.cpython-311.pyc +Tools/scripts/__pycache__/ndiff.cpython-311.pyc +Tools/scripts/__pycache__/nm2def.cpython-311.pyc +Tools/scripts/__pycache__/objgraph.cpython-311.pyc +Tools/scripts/__pycache__/parse_html5_entities.cpython-311.pyc +Tools/scripts/__pycache__/parseentities.cpython-311.pyc +Tools/scripts/__pycache__/patchcheck.cpython-311.pyc +Tools/scripts/__pycache__/pathfix.cpython-311.pyc +Tools/scripts/__pycache__/pdeps.cpython-311.pyc +Tools/scripts/__pycache__/pep384_macrocheck.cpython-311.pyc +Tools/scripts/__pycache__/pickle2db.cpython-311.pyc +Tools/scripts/__pycache__/pindent.cpython-311.pyc +Tools/scripts/__pycache__/ptags.cpython-311.pyc +Tools/scripts/__pycache__/pydoc3.cpython-311.pyc +Tools/scripts/__pycache__/pysource.cpython-311.pyc +Tools/scripts/__pycache__/reindent-rst.cpython-311.pyc +Tools/scripts/__pycache__/reindent.cpython-311.pyc +Tools/scripts/__pycache__/rgrep.cpython-311.pyc +Tools/scripts/__pycache__/run_tests.cpython-311.pyc +Tools/scripts/__pycache__/smelly.cpython-311.pyc +Tools/scripts/__pycache__/sortperf.cpython-311.pyc +Tools/scripts/__pycache__/stable_abi.cpython-311.pyc +Tools/scripts/__pycache__/startuptime.cpython-311.pyc +Tools/scripts/__pycache__/suff.cpython-311.pyc +Tools/scripts/__pycache__/summarize_stats.cpython-311.pyc +Tools/scripts/__pycache__/texi2html.cpython-311.pyc +Tools/scripts/__pycache__/umarshal.cpython-310.pyc +Tools/scripts/__pycache__/umarshal.cpython-311.pyc +Tools/scripts/__pycache__/untabify.cpython-311.pyc +Tools/scripts/__pycache__/update_file.cpython-311.pyc +Tools/scripts/__pycache__/var_access_benchmark.cpython-311.pyc +Tools/scripts/__pycache__/verify_ensurepip_wheels.cpython-311.pyc +Tools/scripts/__pycache__/which.cpython-311.pyc +Tools/scripts/__pycache__/win_add2path.cpython-311.pyc +Tools/scripts/abitype.py +Tools/scripts/analyze_dxp.py +Tools/scripts/byext.py +Tools/scripts/byteyears.py +Tools/scripts/checkpip.py +Tools/scripts/cleanfuture.py +Tools/scripts/combinerefs.py +Tools/scripts/copytime.py +Tools/scripts/crlf.py +Tools/scripts/db2pickle.py +Tools/scripts/deepfreeze.py +Tools/scripts/diff.py +Tools/scripts/dutree.py +Tools/scripts/eptags.py +Tools/scripts/find-uname.py +Tools/scripts/find_recursionlimit.py +Tools/scripts/finddiv.py +Tools/scripts/findlinksto.py +Tools/scripts/findnocoding.py +Tools/scripts/fixcid.py +Tools/scripts/fixdiv.py +Tools/scripts/fixheader.py +Tools/scripts/fixnotice.py +Tools/scripts/fixps.py +Tools/scripts/freeze_modules.py +Tools/scripts/generate_global_objects.py +Tools/scripts/generate_opcode_h.py +Tools/scripts/generate_re_casefix.py +Tools/scripts/generate_sre_constants.py +Tools/scripts/generate_stdlib_module_names.py +Tools/scripts/generate_token.py +Tools/scripts/get-remote-certificate.py +Tools/scripts/google.py +Tools/scripts/gprof2html.py +Tools/scripts/highlight.py +Tools/scripts/ifdef.py +Tools/scripts/import_diagnostics.py +Tools/scripts/lfcr.py +Tools/scripts/linktree.py +Tools/scripts/lll.py +Tools/scripts/mailerdaemon.py +Tools/scripts/make_ctype.py +Tools/scripts/md5sum.py +Tools/scripts/mkreal.py +Tools/scripts/ndiff.py +Tools/scripts/nm2def.py +Tools/scripts/objgraph.py +Tools/scripts/parse_html5_entities.py +Tools/scripts/parseentities.py +Tools/scripts/patchcheck.py +Tools/scripts/pathfix.py +Tools/scripts/pdeps.py +Tools/scripts/pep384_macrocheck.py +Tools/scripts/pickle2db.py +Tools/scripts/pindent.py +Tools/scripts/ptags.py +Tools/scripts/pydoc3.py +Tools/scripts/pysource.py +Tools/scripts/reindent-rst.py +Tools/scripts/reindent.py +Tools/scripts/rgrep.py +Tools/scripts/run_tests.py +Tools/scripts/smelly.py +Tools/scripts/sortperf.py +Tools/scripts/stable_abi.py +Tools/scripts/startuptime.py +Tools/scripts/suff.py +Tools/scripts/summarize_stats.py +Tools/scripts/texi2html.py +Tools/scripts/umarshal.py +Tools/scripts/untabify.py +Tools/scripts/update_file.py +Tools/scripts/var_access_benchmark.py +Tools/scripts/verify_ensurepip_wheels.py +Tools/scripts/which.py +Tools/scripts/win_add2path.py +include/Python.h +include/README.rst +include/abstract.h +include/bltinmodule.h +include/boolobject.h +include/bytearrayobject.h +include/bytesobject.h +include/ceval.h +include/codecs.h +include/compile.h +include/complexobject.h +include/cpython/abstract.h +include/cpython/bytearrayobject.h +include/cpython/bytesobject.h +include/cpython/cellobject.h +include/cpython/ceval.h +include/cpython/classobject.h +include/cpython/code.h +include/cpython/compile.h +include/cpython/complexobject.h +include/cpython/context.h +include/cpython/descrobject.h +include/cpython/dictobject.h +include/cpython/fileobject.h +include/cpython/fileutils.h +include/cpython/floatobject.h +include/cpython/frameobject.h +include/cpython/funcobject.h +include/cpython/genobject.h +include/cpython/import.h +include/cpython/initconfig.h +include/cpython/listobject.h +include/cpython/longintrepr.h +include/cpython/longobject.h +include/cpython/methodobject.h +include/cpython/modsupport.h +include/cpython/object.h +include/cpython/objimpl.h +include/cpython/odictobject.h +include/cpython/picklebufobject.h +include/cpython/pthread_stubs.h +include/cpython/pyctype.h +include/cpython/pydebug.h +include/cpython/pyerrors.h +include/cpython/pyfpe.h +include/cpython/pyframe.h +include/cpython/pylifecycle.h +include/cpython/pymem.h +include/cpython/pystate.h +include/cpython/pythonrun.h +include/cpython/pythread.h +include/cpython/pytime.h +include/cpython/setobject.h +include/cpython/sysmodule.h +include/cpython/traceback.h +include/cpython/tupleobject.h +include/cpython/unicodeobject.h +include/cpython/warnings.h +include/cpython/weakrefobject.h +include/datetime.h +include/descrobject.h +include/dictobject.h +include/dynamic_annotations.h +include/enumobject.h +include/errcode.h +include/exports.h +include/fileobject.h +include/fileutils.h +include/floatobject.h +include/frameobject.h +include/genericaliasobject.h +include/import.h +include/internal/pycore_abstract.h +include/internal/pycore_accu.h +include/internal/pycore_asdl.h +include/internal/pycore_ast.h +include/internal/pycore_ast_state.h +include/internal/pycore_atomic.h +include/internal/pycore_atomic_funcs.h +include/internal/pycore_bitutils.h +include/internal/pycore_blocks_output_buffer.h +include/internal/pycore_bytes_methods.h +include/internal/pycore_bytesobject.h +include/internal/pycore_call.h +include/internal/pycore_ceval.h +include/internal/pycore_code.h +include/internal/pycore_compile.h +include/internal/pycore_condvar.h +include/internal/pycore_context.h +include/internal/pycore_dict.h +include/internal/pycore_dtoa.h +include/internal/pycore_emscripten_signal.h +include/internal/pycore_exceptions.h +include/internal/pycore_fileutils.h +include/internal/pycore_floatobject.h +include/internal/pycore_format.h +include/internal/pycore_frame.h +include/internal/pycore_function.h +include/internal/pycore_gc.h +include/internal/pycore_genobject.h +include/internal/pycore_getopt.h +include/internal/pycore_gil.h +include/internal/pycore_global_objects.h +include/internal/pycore_global_strings.h +include/internal/pycore_hamt.h +include/internal/pycore_hashtable.h +include/internal/pycore_import.h +include/internal/pycore_initconfig.h +include/internal/pycore_interp.h +include/internal/pycore_interpreteridobject.h +include/internal/pycore_list.h +include/internal/pycore_long.h +include/internal/pycore_moduleobject.h +include/internal/pycore_namespace.h +include/internal/pycore_object.h +include/internal/pycore_opcode.h +include/internal/pycore_parser.h +include/internal/pycore_pathconfig.h +include/internal/pycore_pyarena.h +include/internal/pycore_pyerrors.h +include/internal/pycore_pyhash.h +include/internal/pycore_pylifecycle.h +include/internal/pycore_pymath.h +include/internal/pycore_pymem.h +include/internal/pycore_pystate.h +include/internal/pycore_runtime.h +include/internal/pycore_runtime_init.h +include/internal/pycore_signal.h +include/internal/pycore_sliceobject.h +include/internal/pycore_strhex.h +include/internal/pycore_structseq.h +include/internal/pycore_symtable.h +include/internal/pycore_sysmodule.h +include/internal/pycore_traceback.h +include/internal/pycore_tuple.h +include/internal/pycore_typeobject.h +include/internal/pycore_ucnhash.h +include/internal/pycore_unicodeobject.h +include/internal/pycore_unionobject.h +include/internal/pycore_warnings.h +include/intrcheck.h +include/iterobject.h +include/listobject.h +include/longobject.h +include/marshal.h +include/memoryobject.h +include/methodobject.h +include/modsupport.h +include/moduleobject.h +include/object.h +include/objimpl.h +include/opcode.h +include/osdefs.h +include/osmodule.h +include/patchlevel.h +include/py_curses.h +include/pybuffer.h +include/pycapsule.h +include/pyconfig.h +include/pydtrace.d +include/pydtrace.h +include/pyerrors.h +include/pyexpat.h +include/pyframe.h +include/pyhash.h +include/pylifecycle.h +include/pymacconfig.h +include/pymacro.h +include/pymath.h +include/pymem.h +include/pyport.h +include/pystate.h +include/pystrcmp.h +include/pystrtod.h +include/pythonrun.h +include/pythread.h +include/pytypedefs.h +include/rangeobject.h +include/setobject.h +include/sliceobject.h +include/structmember.h +include/structseq.h +include/sysmodule.h +include/token.h +include/traceback.h +include/tracemalloc.h +include/tupleobject.h +include/typeslots.h +include/unicodeobject.h +include/warnings.h +include/weakrefobject.h +libs/_tkinter.lib +libs/python3.lib +libs/python311.lib +python.exe +python.pdb +python3.dll +python311.dll +python311.pdb +pythonw.exe +pythonw.pdb diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/git b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/git new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/has_prefix b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/has_prefix new file mode 100644 index 0000000000000000000000000000000000000000..48989877e2c2c74c67f82ad98a45b944897d0cda --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/has_prefix @@ -0,0 +1,4 @@ +"D:\bld\python-split_1772728140663\_h_env" binary "DLLs/_tkinter.pyd" +"D:\bld\python-split_1772728140663\_h_env" binary "python.pdb" +"D:\bld\python-split_1772728140663\_h_env" binary "python311.pdb" +"D:\bld\python-split_1772728140663\_h_env" binary "pythonw.pdb" diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/hash_input.json b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/hash_input.json new file mode 100644 index 0000000000000000000000000000000000000000..3d1852b2aa2f81e1ffead41968db212a749e4d39 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/hash_input.json @@ -0,0 +1,15 @@ +{ + "sqlite": "3", + "expat": "2", + "zlib": "1", + "bzip2": "1", + "libffi": "3.5", + "channel_targets": "conda-forge main", + "target_platform": "win-64", + "liblzma_devel": "5", + "cxx_compiler": "vs2022", + "c_compiler": "vs2022", + "tk": "8.6", + "c_stdlib": "vs", + "openssl": "3.5" +} \ No newline at end of file diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/index.json b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/index.json new file mode 100644 index 0000000000000000000000000000000000000000..ca934f547a1511bed2ad14ad95d14a2b464893c2 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/index.json @@ -0,0 +1,28 @@ +{ + "arch": "x86_64", + "build": "h0159041_0_cpython", + "build_number": 0, + "constrains": [ + "python_abi 3.11.* *_cp311" + ], + "depends": [ + "bzip2 >=1.0.8,<2.0a0", + "libexpat >=2.7.4,<3.0a0", + "libffi >=3.5.2,<3.6.0a0", + "liblzma >=5.8.2,<6.0a0", + "libsqlite >=3.51.2,<4.0a0", + "libzlib >=1.3.1,<2.0a0", + "openssl >=3.5.5,<4.0a0", + "tk >=8.6.13,<8.7.0a0", + "tzdata", + "ucrt >=10.0.20348.0", + "vc >=14.3,<15", + "vc14_runtime >=14.44.35208" + ], + "license": "Python-2.0", + "name": "python", + "platform": "win", + "subdir": "win-64", + "timestamp": 1772728847666, + "version": "3.11.15" +} \ No newline at end of file diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/no_link b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/no_link new file mode 100644 index 0000000000000000000000000000000000000000..da8be4f3456f520ea63ba53df946a908f70571aa --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/no_link @@ -0,0 +1 @@ +DLLs/_ctypes.pyd diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/paths.json b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/paths.json new file mode 100644 index 0000000000000000000000000000000000000000..7f46b6e1131d0ed883ebcad3c0b2fd6176cd25b5 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_0_cpython/info/paths.json @@ -0,0 +1,14456 @@ +{ + "paths": [ + { + "_path": "DLLs/_asyncio.pyd", + "path_type": "hardlink", + "sha256": "d5d6e1e4146b36da38c50cab95960606918f2b4741ce309de93111922586ac25", + "size_in_bytes": 55296 + }, + { + "_path": "DLLs/_bz2.pyd", + "path_type": "hardlink", + "sha256": "313c987e98dea75f0b53aab8f7fedb0317192a35477c1ec4e1be4b5bbf5f9874", + "size_in_bytes": 24064 + }, + { + "_path": "DLLs/_ctypes.pyd", + "no_link": true, + "path_type": "hardlink", + "sha256": "97f99dd1faab6b0e1105c6d4f96f78de7fa747cb37fb62daa0f889bd526818fc", + "size_in_bytes": 121344 + }, + { + "_path": "DLLs/_ctypes_test.pyd", + "path_type": "hardlink", + "sha256": "b9e9f027d096f36a78436247bf6875515a7f95c255776e7b32f2d62e66a5264c", + "size_in_bytes": 25088 + }, + { + "_path": "DLLs/_decimal.pyd", + "path_type": "hardlink", + "sha256": "6a937959818d585ca4935e95c6396fdf66b7cd02102310d8bf47014a6c102875", + "size_in_bytes": 290816 + }, + { + "_path": "DLLs/_elementtree.pyd", + "path_type": "hardlink", + "sha256": "fdafb7c86b7c0d713fa6eacad92be31a73448b105f2c859cf7daec51697be27e", + "size_in_bytes": 60928 + }, + { + "_path": "DLLs/_hashlib.pyd", + "path_type": "hardlink", + "sha256": "c32356abe7661451bbff44118ec2afad36a2960d0cb69ece45dd6da97ab30962", + "size_in_bytes": 49152 + }, + { + "_path": "DLLs/_lzma.pyd", + "path_type": "hardlink", + "sha256": "fdf71bb4637f216298a37a9ba128f70fe942f0946db06de3a6fe80d8edf6339d", + "size_in_bytes": 37376 + }, + { + "_path": "DLLs/_msi.pyd", + "path_type": "hardlink", + "sha256": "5cc03d5d116a4822267784ada00bf0731010f0dacc51edd3874204c714cc65ce", + "size_in_bytes": 33280 + }, + { + "_path": "DLLs/_multiprocessing.pyd", + "path_type": "hardlink", + "sha256": "0eca302b4088dec4d5ef9904fbc0c50e43e4cab6100d807d5ecf2be5b6dc0c05", + "size_in_bytes": 24064 + }, + { + "_path": "DLLs/_overlapped.pyd", + "path_type": "hardlink", + "sha256": "885f5f77d0793233363e6a4072a7efc0605c08e0388fd307c9dc54244c79b015", + "size_in_bytes": 41984 + }, + { + "_path": "DLLs/_queue.pyd", + "path_type": "hardlink", + "sha256": "dcba9d1b3467e34aa6f80fc0c40748330518360e7c7c6f12ef9b30537d449733", + "size_in_bytes": 19968 + }, + { + "_path": "DLLs/_socket.pyd", + "path_type": "hardlink", + "sha256": "f5402f9552dd758eeed7e155a4cf9909e9a29930bb8902b2d6789cbe1a23f161", + "size_in_bytes": 69632 + }, + { + "_path": "DLLs/_sqlite3.pyd", + "path_type": "hardlink", + "sha256": "f6bae387386e1aa45c6207d15210feeee27dcd66f881e5a782b3a43c76d83126", + "size_in_bytes": 99328 + }, + { + "_path": "DLLs/_ssl.pyd", + "path_type": "hardlink", + "sha256": "e76094af2f6b0e00d7381b121ce40dca83a867589366e2111454c739cf8ed8a8", + "size_in_bytes": 171008 + }, + { + "_path": "DLLs/_testbuffer.pyd", + "path_type": "hardlink", + "sha256": "cdf5d235ca15fbcf4c2879707e1c379601a7425ec8e2d5f1331d46a8e90a47bd", + "size_in_bytes": 43520 + }, + { + "_path": "DLLs/_testcapi.pyd", + "path_type": "hardlink", + "sha256": "4902fee66b24f5a3126dca6b9976c4def962615bcea4c0fdba14a5b9e7c186c7", + "size_in_bytes": 135168 + }, + { + "_path": "DLLs/_testconsole.pyd", + "path_type": "hardlink", + "sha256": "d205d75fb2f112b4e1c4af7904e91b5f659a2ba86f915ba0e40bd0bb6d8d0e54", + "size_in_bytes": 14848 + }, + { + "_path": "DLLs/_testimportmultiple.pyd", + "path_type": "hardlink", + "sha256": "d300e656090638546dbad5c5d17c2e1e422bbabef6f00c5e301383c60a39b598", + "size_in_bytes": 13312 + }, + { + "_path": "DLLs/_testinternalcapi.pyd", + "path_type": "hardlink", + "sha256": "82a0704218c2b3846bfb6948271eda4d468737513fbf36e61e2489cea5affce4", + "size_in_bytes": 28160 + }, + { + "_path": "DLLs/_testmultiphase.pyd", + "path_type": "hardlink", + "sha256": "b051e8b22422a774b62a372e0be3a7f276ba96e81afdc9607634390f94b595bb", + "size_in_bytes": 26624 + }, + { + "_path": "DLLs/_tkinter.pyd", + "file_mode": "binary", + "path_type": "hardlink", + "prefix_placeholder": "D:\\bld\\python-split_1772728140663\\_h_env", + "sha256": "1fbf25dbc762d537ec7a05f179e22d9850be5fb6d4b738419743f361cd81f799", + "size_in_bytes": 55296 + }, + { + "_path": "DLLs/_uuid.pyd", + "path_type": "hardlink", + "sha256": "4b57fd00e0e0e22ea29c54b4198f11e36542fca6d2e6a77f7c14fd08732f6339", + "size_in_bytes": 13824 + }, + { + "_path": "DLLs/_zoneinfo.pyd", + "path_type": "hardlink", + "sha256": "3c96bcab269a995372435194f3487d133e04248f262e9ee3f23e197caad18acc", + "size_in_bytes": 33792 + }, + { + "_path": "DLLs/py.ico", + "path_type": "hardlink", + "sha256": "150c470f9943b806b44312efdec85755f22f8d7d52b31f93a9af3c43e8627381", + "size_in_bytes": 75809 + }, + { + "_path": "DLLs/pyc.ico", + "path_type": "hardlink", + "sha256": "fda28a734788a3f175cb6aed4daeb5f05f0e49f6a272ccd2051ba337f7b3b42f", + "size_in_bytes": 78396 + }, + { + "_path": "DLLs/pyexpat.pyd", + "path_type": "hardlink", + "sha256": "38b61303cf8db85bf58f915edca9c669b631f60ac1438f61a984a0e21ae44e58", + "size_in_bytes": 57856 + }, + { + "_path": "DLLs/select.pyd", + "path_type": "hardlink", + "sha256": "8dc7d113ca29c2187d7c42e7a696b41d6ce9030bc2f2bb260af53612af856b8a", + "size_in_bytes": 19456 + }, + { + "_path": "DLLs/unicodedata.pyd", + "path_type": "hardlink", + "sha256": "8de6e76567c08c3bd291d2c9c7ddea5172a20df2b7b302f231cb8c2323eed87d", + "size_in_bytes": 1127936 + }, + { + "_path": "DLLs/winsound.pyd", + "path_type": "hardlink", + "sha256": "cd9875701272405b876fe418618c1fae0e6f9b18f9f5673fa9398ebf7b2aca74", + "size_in_bytes": 19456 + }, + { + "_path": "DLLs/xxlimited.pyd", + "path_type": "hardlink", + "sha256": "eb3a90832852d4123c55d5120ba47ccc87d4edd9e77cdef9d3712aacf04b775f", + "size_in_bytes": 14336 + }, + { + "_path": "DLLs/xxlimited_35.pyd", + "path_type": "hardlink", + "sha256": "3dc5d7df8a1f14fb2758d916a9ebd20ca468acc7179d517607057894247aeffb", + "size_in_bytes": 13824 + }, + { + "_path": "LICENSE_PYTHON.txt", + "path_type": "hardlink", + "sha256": "3b2f81fe21d181c499c59a256c8e1968455d6689d269aa85373bfb6af41da3bf", + "size_in_bytes": 13936 + }, + { + "_path": "Lib/__future__.py", + "path_type": "hardlink", + "sha256": "981d4c398849f9ebcab72300d9c1fe288fd6d7f28957b3b3fa3a493a5836d95c", + "size_in_bytes": 5218 + }, + { + "_path": "Lib/__hello__.py", + "path_type": "hardlink", + "sha256": "a8ce70b199497950f0f06def93115a6814daf1f961934457f59046909901487f", + "size_in_bytes": 227 + }, + { + "_path": "Lib/__phello__/__init__.py", + "path_type": "hardlink", + "sha256": "56f7ed595e767c558ded05def14b682893105daf504500c3443b458ca2431bc6", + "size_in_bytes": 97 + }, + { + "_path": "Lib/__phello__/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c34d802d47e1854d05755573bf64665a0710f3db6e163b8b3d9bb951e16bb96a", + "size_in_bytes": 413 + }, + { + "_path": "Lib/__phello__/__pycache__/spam.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4ffecbe19f94f7206a206cd5a0d8775eadbcbd2087841cd0aa68ff5238921526", + "size_in_bytes": 409 + }, + { + "_path": "Lib/__phello__/ham/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "Lib/__phello__/ham/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d87ce74c427b153f72efbf7626e454dbf4cd4b5578f1ff4f368c6cbc268cc27c", + "size_in_bytes": 139 + }, + { + "_path": "Lib/__phello__/ham/__pycache__/eggs.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d7b8e6ccb4b26ea051cfb34cef8cf189031b8416c088b53beeec33383dd7e059", + "size_in_bytes": 135 + }, + { + "_path": "Lib/__phello__/ham/eggs.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "Lib/__phello__/spam.py", + "path_type": "hardlink", + "sha256": "56f7ed595e767c558ded05def14b682893105daf504500c3443b458ca2431bc6", + "size_in_bytes": 97 + }, + { + "_path": "Lib/__pycache__/__future__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "721189088677015eb4fdbeb516300a6e212af862015595c6c1840b3425f2b558", + "size_in_bytes": 4895 + }, + { + "_path": "Lib/__pycache__/__hello__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "09ec2f841a30c15e8577ff61460c01ee47e9fd6a3e330c381090c069a119c761", + "size_in_bytes": 1059 + }, + { + "_path": "Lib/__pycache__/_aix_support.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "14d4115919c6c88c11e50e01ad94581aa1bd919ca946be581095fce35f6d2e25", + "size_in_bytes": 4348 + }, + { + "_path": "Lib/__pycache__/_bootsubprocess.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7537d4da86e5dfd6e09669948ba6f558e4c9777761b451e257cdc0c96b26ea98", + "size_in_bytes": 4441 + }, + { + "_path": "Lib/__pycache__/_collections_abc.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "09115ed06351a1adca01bf1ecab0c433bbcf03176b8f0fb331b27859071ccb76", + "size_in_bytes": 51197 + }, + { + "_path": "Lib/__pycache__/_compat_pickle.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f7fc7c2be61fe31c511437dc7dc7d0291d63f20fcac7127eb5e6587ac2734f71", + "size_in_bytes": 7497 + }, + { + "_path": "Lib/__pycache__/_compression.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ec5562dec7c2fec5b5771e467bac9c68067af5c3e812d9022a201a58a6296fd1", + "size_in_bytes": 8031 + }, + { + "_path": "Lib/__pycache__/_markupbase.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4fc348ae40f3353f4e9e8f3c7beda77abe0498b5147990c655d5a652c598222f", + "size_in_bytes": 14063 + }, + { + "_path": "Lib/__pycache__/_osx_support.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e51298881a02de9be44f261cdd14a8cb6d6f53696e4e2259a07db1c61c81b051", + "size_in_bytes": 19907 + }, + { + "_path": "Lib/__pycache__/_py_abc.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9a72d57439ae92487c4d3de90d647993a1d411dd8165fad730192375f00e1952", + "size_in_bytes": 7859 + }, + { + "_path": "Lib/__pycache__/_pydecimal.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6f8df3c22694ea905e6dd2fc6b7dc55cace504468d081caf713392462c562b9e", + "size_in_bytes": 244242 + }, + { + "_path": "Lib/__pycache__/_pyio.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "bfc10f817d415fc7260eee9595f39d04927d57a167e67736edabeee74beb382c", + "size_in_bytes": 120120 + }, + { + "_path": "Lib/__pycache__/_sitebuiltins.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "364d4a724a9fa7c4f53ef23af34389bea96ca91cdfaf61986b115df2e308fa8c", + "size_in_bytes": 5405 + }, + { + "_path": "Lib/__pycache__/_strptime.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "97a152efcfc7dd1e2480677f3a63bc2b84255e903a0b1a32c16ad8463d9ee526", + "size_in_bytes": 27889 + }, + { + "_path": "Lib/__pycache__/_threading_local.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "91b04e18f42857084537890d4ea332a6bd8dcd7992c0bff4aef060c0df36c68c", + "size_in_bytes": 9186 + }, + { + "_path": "Lib/__pycache__/_weakrefset.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "fe4c66b55ba29109608081e4489ed99cb8fd6c487b80dbd0ef9db4df737e9c5a", + "size_in_bytes": 13121 + }, + { + "_path": "Lib/__pycache__/abc.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3e5e326c7b0c42520f89f4d99abbfe0cdc3c48d8a83486ddd889910af3e6069b", + "size_in_bytes": 9022 + }, + { + "_path": "Lib/__pycache__/aifc.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "905d5939f915eac9a19de602964a30bcf12988b30cee085a7e382d12cb70bae6", + "size_in_bytes": 45490 + }, + { + "_path": "Lib/__pycache__/antigravity.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f9bc218c6e8010c860511dfb76e796d57fba321b64b5285d52dfcbb184393cc0", + "size_in_bytes": 1238 + }, + { + "_path": "Lib/__pycache__/argparse.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "012c1612dad3c8806344acfff9d5756c3a44825d3b6e0323443022c230a4ba7e", + "size_in_bytes": 113964 + }, + { + "_path": "Lib/__pycache__/ast.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d50f41c4ad2e8ed2605206cb8c9799279340e2c9f57b5709ff11786a9d9e7280", + "size_in_bytes": 109645 + }, + { + "_path": "Lib/__pycache__/asynchat.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7ac4cd9a7ef6b5cae2592d3576d428ec1e5c1414cc36cff199ea73f625ee987c", + "size_in_bytes": 11868 + }, + { + "_path": "Lib/__pycache__/asyncore.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e70b86f86a4667bdcd191a8ae82409b6f7669a93d522dc25b3639610fad900c7", + "size_in_bytes": 28170 + }, + { + "_path": "Lib/__pycache__/base64.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4ce6d0834d2cfb600f500667b14b0a33edf3661f9f3b0d684d24d9d364f4357b", + "size_in_bytes": 28428 + }, + { + "_path": "Lib/__pycache__/bdb.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "bc5666812734ee26331bbf2721a9e254161299327416fdda194a5fd0a7e840fc", + "size_in_bytes": 38655 + }, + { + "_path": "Lib/__pycache__/bisect.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9e0ce5978cd8f648e615fe2f6760b3ea93ca975b32a465648348b5f6421dacab", + "size_in_bytes": 3682 + }, + { + "_path": "Lib/__pycache__/bz2.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0dc9858a57a8529dc495ea5cec72139329871e6fe978f6377b557ffd9c483135", + "size_in_bytes": 16144 + }, + { + "_path": "Lib/__pycache__/cProfile.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "51a939949da0c1c75e0118b9de46bde4e9d67d5084c355423fcd0a052d80107a", + "size_in_bytes": 9056 + }, + { + "_path": "Lib/__pycache__/calendar.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c504b780a97faf2b3da869e9388d623d6fd56c4596c82256134676d300f03ce6", + "size_in_bytes": 44722 + }, + { + "_path": "Lib/__pycache__/cgi.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "bf0f44b443065b90f2a20048ac83b14a12a65f55722a5e939cd099a4c8b635bc", + "size_in_bytes": 43843 + }, + { + "_path": "Lib/__pycache__/cgitb.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6eea317b9d157c002478bf9e246c7ca23fe7534a15a0584c91ce25933acbd554", + "size_in_bytes": 18863 + }, + { + "_path": "Lib/__pycache__/chunk.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "eb5d62226ab158c3189382cf6e35754e6b424a774d51479b17137f4948f3a406", + "size_in_bytes": 7408 + }, + { + "_path": "Lib/__pycache__/cmd.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2f4742cbd199d92dfba2740bc1a59517e80923c75ab6d30ce8bf9561280b9783", + "size_in_bytes": 20579 + }, + { + "_path": "Lib/__pycache__/code.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c2e610c9b1a556730311399cddec944c8372c6a8b359cc1d4c2e570071e5d1a5", + "size_in_bytes": 13883 + }, + { + "_path": "Lib/__pycache__/codecs.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "786ec8731f406f65dfcfd40e25a7c620a722dcd90cca8195e6697c7b11939018", + "size_in_bytes": 45226 + }, + { + "_path": "Lib/__pycache__/codeop.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a049e95f74703e6b07b6a51586119b8c1957e744e9f2d27453038cab2d1e5a95", + "size_in_bytes": 7712 + }, + { + "_path": "Lib/__pycache__/colorsys.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "22be491df2121fa2e42c16c05c78eb0fcc5e8934d018b9500befca26ceb33fff", + "size_in_bytes": 4933 + }, + { + "_path": "Lib/__pycache__/compileall.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "129f846bfd0c1ad1b6372ecd4ec03ddd7d9253b43a1ed345408453643e352ded", + "size_in_bytes": 21567 + }, + { + "_path": "Lib/__pycache__/configparser.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "90074dc69e655109f8799757c9e39b8d568ae1f6526f6769dbbc663c12f44265", + "size_in_bytes": 71789 + }, + { + "_path": "Lib/__pycache__/contextlib.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8e582d00cb2d4ed82bd4df9fa91072f6ca935dfa87a89cdf7d2d32bf05740257", + "size_in_bytes": 33051 + }, + { + "_path": "Lib/__pycache__/contextvars.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "44923faaec8ae4121a1d2f2b2652accf754b2b9e70a815073a092a10c9e77f00", + "size_in_bytes": 281 + }, + { + "_path": "Lib/__pycache__/copy.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ef2edfa392b17c83bd29d5969948684ecbbd096f66559b5cecec587b15692701", + "size_in_bytes": 11169 + }, + { + "_path": "Lib/__pycache__/copyreg.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "028b1690fb80bfff4722a918049eee29d5f3d9c0c236c85062967d2dd5cfa4d4", + "size_in_bytes": 8162 + }, + { + "_path": "Lib/__pycache__/crypt.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c76177b210d3fe37f23f2f1981dc13a8ab773740ea13d2f5a18911a269829cfe", + "size_in_bytes": 5820 + }, + { + "_path": "Lib/__pycache__/csv.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "41d1026a5ba38d35854997195175c96cd8c98c7a41f01385af22dbc3325d085f", + "size_in_bytes": 20038 + }, + { + "_path": "Lib/__pycache__/dataclasses.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "98b44e7452e24c93b313d6a2348fceffb878064b32e87f874b355f0f6ba983cf", + "size_in_bytes": 47207 + }, + { + "_path": "Lib/__pycache__/datetime.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "476e51851fd8081f1e64dcb3f4e2f976782658533305f989c2cb263dcd3154f9", + "size_in_bytes": 101318 + }, + { + "_path": "Lib/__pycache__/decimal.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8fdc589881b87afd56c2a946438751e1845dc8e39cafe86ba85c4c940d40e83b", + "size_in_bytes": 525 + }, + { + "_path": "Lib/__pycache__/difflib.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4b688fdc8e25d601f0968329db5f9e8df52e56c8f591b8a233b942e0a32ef40f", + "size_in_bytes": 81630 + }, + { + "_path": "Lib/__pycache__/dis.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7a54aecd297e5c2871b341966383181d1e4d0f5a612325ad4c1ab62c2d0d4a2e", + "size_in_bytes": 36663 + }, + { + "_path": "Lib/__pycache__/doctest.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "461bc3535c8ed973309a43a136f8e306833db99d58a3a4144eece5ee8280d289", + "size_in_bytes": 112988 + }, + { + "_path": "Lib/__pycache__/enum.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ed668ece17791c2f2e506de1f36e159e48df8d1479f757cd3823fc82747df11a", + "size_in_bytes": 87978 + }, + { + "_path": "Lib/__pycache__/filecmp.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "aaf38b17e42afb992fe4baca63df15698d1eedd2b88a7a5ef7e39e102b8abba1", + "size_in_bytes": 15692 + }, + { + "_path": "Lib/__pycache__/fileinput.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d05fb7f447ca46495c92ec32d1873cf57f94fcc705cf00993f5a04246ab9e72f", + "size_in_bytes": 21150 + }, + { + "_path": "Lib/__pycache__/fnmatch.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "20e96ff738b3cb6f0ce269d45be8142ad45244d9e726e6b09c89572f44a490c2", + "size_in_bytes": 7453 + }, + { + "_path": "Lib/__pycache__/fractions.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "411183d59f3364b0b8e63c7beda1048dcf967ed778d1414775c0adc909ca71d1", + "size_in_bytes": 29225 + }, + { + "_path": "Lib/__pycache__/ftplib.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f802c35a9e43be2b6b071f63adb6bf01aeabbb1580fc99820b726860b2202a1d", + "size_in_bytes": 47629 + }, + { + "_path": "Lib/__pycache__/functools.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c561193b128a7ed67790618e9254f38dcb5564ae82c3cfa747a7aebc9106e8d8", + "size_in_bytes": 46617 + }, + { + "_path": "Lib/__pycache__/genericpath.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "63181c1c3b04b331ceda7f3af15989524e66e4d6ce21890dd4bb95ba2dd5d831", + "size_in_bytes": 6820 + }, + { + "_path": "Lib/__pycache__/getopt.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1d0f658b7ba5d09be5e9e2f4da0ee123cabf388dd363ab1664c30ad454139614", + "size_in_bytes": 9714 + }, + { + "_path": "Lib/__pycache__/getpass.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "28e0f80bf48b1a25b458c98f7b5d52ebbf263275e211cf1d329fc5044d11ec6a", + "size_in_bytes": 7495 + }, + { + "_path": "Lib/__pycache__/gettext.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "411984a847e562d9fb36ef239a776db2f302ff91246679cbc223bfc7315b37f3", + "size_in_bytes": 24234 + }, + { + "_path": "Lib/__pycache__/glob.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "34712f46dba93039831ec527668cb912b048ea558b3e72404a1c5287a53fd2ae", + "size_in_bytes": 11191 + }, + { + "_path": "Lib/__pycache__/graphlib.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1d9e450d9dbf94bac8dc7fe0b4b2d2847164b9f57fedf389a13a2eb4611d726a", + "size_in_bytes": 11049 + }, + { + "_path": "Lib/__pycache__/gzip.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "21e26854f6db9038a8172228bec9ed01419a9b28313662cca319840abc808b19", + "size_in_bytes": 33701 + }, + { + "_path": "Lib/__pycache__/hashlib.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f7a0f11d07507597c4fa62f3b83409d19e89a6edc0f8f67228ffd699f639c2ca", + "size_in_bytes": 12320 + }, + { + "_path": "Lib/__pycache__/heapq.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "05583201923cc70287b1ac5af389ab0f0f85d8b8e26ac91b3c163f7461b307b7", + "size_in_bytes": 20558 + }, + { + "_path": "Lib/__pycache__/hmac.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "cedd09f6f031a7cd0588ecd43c88f67b7a5641dcaa82707b695d6d9917b956c1", + "size_in_bytes": 11453 + }, + { + "_path": "Lib/__pycache__/imaplib.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "eeb5d4d5f4bca2cd0601709fe49e90f94dc14b953c087bf26b9368100680f696", + "size_in_bytes": 69032 + }, + { + "_path": "Lib/__pycache__/imghdr.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0c4dd784cf262c37844a329a21a040aacd52060c3518b6a69970fb3ea2a33acf", + "size_in_bytes": 7823 + }, + { + "_path": "Lib/__pycache__/imp.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2c20012093742f7f9fa67e493ed21e95d24c9454c4b99787639ac895ecb303e3", + "size_in_bytes": 16442 + }, + { + "_path": "Lib/__pycache__/inspect.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "60b45ba8b19627c02b5c16f368d4e709c43bc6eb73d07c4f65db903201e75c62", + "size_in_bytes": 141630 + }, + { + "_path": "Lib/__pycache__/io.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3fc797c1c5f906f70b2bfa2ad1f7129ec5d3f69efa2ad8ffe1ff7f104d880635", + "size_in_bytes": 5020 + }, + { + "_path": "Lib/__pycache__/ipaddress.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f29f1cb40e52022bec775f74fdb0b3dfa4487ccb9dcfccfe004e7d1c9ecf5217", + "size_in_bytes": 99653 + }, + { + "_path": "Lib/__pycache__/keyword.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3ba1e75702618949ada69f4f589ef9ad0bbcd74b5962ef1c63c7f5cc642397c9", + "size_in_bytes": 1052 + }, + { + "_path": "Lib/__pycache__/linecache.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "69106ae2aff0a49fd8d648e14667840f5e0430446ccc4540c0dabcaac7df850f", + "size_in_bytes": 7428 + }, + { + "_path": "Lib/__pycache__/locale.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d674500de1cb0ca15fc956c0fd8a003d487e232374186f1328afc523e9323595", + "size_in_bytes": 64383 + }, + { + "_path": "Lib/__pycache__/lzma.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e15ac1d83bdc20f34737b10d90d08faf486aa9b112575d5037e4196b8ae0bf70", + "size_in_bytes": 16701 + }, + { + "_path": "Lib/__pycache__/mailbox.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8dde3a92619940f49cd2f659007b9b907f8ec01c61659e001b5e54bbba75e978", + "size_in_bytes": 124599 + }, + { + "_path": "Lib/__pycache__/mailcap.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "38ffbaf5a4137f9840b28f394dc229b169b9b5e7af820bbecfe5ab6ec414c3b0", + "size_in_bytes": 12767 + }, + { + "_path": "Lib/__pycache__/mimetypes.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9fdaa000c4cf94a411ec68a1c2afc1411eef3ea008880081b2fa2d47857c1c51", + "size_in_bytes": 26109 + }, + { + "_path": "Lib/__pycache__/modulefinder.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "857e48ca8e401f1245462210b9db9fa7c2e69f457f5713109ba0976ab20f07eb", + "size_in_bytes": 31002 + }, + { + "_path": "Lib/__pycache__/netrc.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e4cebac3b9ac7cb878e50daba6567a6b1bdcc894f1e6745d6c36d522f32e3df5", + "size_in_bytes": 9872 + }, + { + "_path": "Lib/__pycache__/nntplib.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1d5d61d413c7d6b809240ff42bdd128f5de663e09635a55bbdbdff0faa471237", + "size_in_bytes": 50144 + }, + { + "_path": "Lib/__pycache__/ntpath.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1946d8506669bfcc6d87d54d779439e9da86cafc24e14facd913637a63d89adb", + "size_in_bytes": 29373 + }, + { + "_path": "Lib/__pycache__/nturl2path.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e9f8f9f10aae44426d3f80ba6b6e5d25371ad52dfadfc98047a1f2004cced370", + "size_in_bytes": 3472 + }, + { + "_path": "Lib/__pycache__/numbers.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e8c77ef0a45d9269a065147ecd1db960959023b3607103e6e49c17da0a73502a", + "size_in_bytes": 15234 + }, + { + "_path": "Lib/__pycache__/opcode.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6b7c22963fc18b89a0103e879a08b6d72a6e54c2bc524f034ac694fd38cbbc99", + "size_in_bytes": 13836 + }, + { + "_path": "Lib/__pycache__/operator.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a9beb971cb7e37ded4780ae0df4fd21b536329ab6c1b79c9c883f9f6bdb4251e", + "size_in_bytes": 18743 + }, + { + "_path": "Lib/__pycache__/optparse.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4f02154d34e1f9368853f64e1cfcd75792c35ba118f4e9dbff60e626d7932f00", + "size_in_bytes": 73700 + }, + { + "_path": "Lib/__pycache__/os.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0fb3d2666f3ec9613d1dc76f47cc18bfc64e7dd629dccc81ead372f64c6a613b", + "size_in_bytes": 49008 + }, + { + "_path": "Lib/__pycache__/pathlib.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0592fd3d7545047b06f6b96da9a4b0a3d07a73c3bfd7438fb6e3d50f6a81e368", + "size_in_bytes": 67704 + }, + { + "_path": "Lib/__pycache__/pdb.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "17eb99f807167c8dbdaf93a2e41a443ea7474f06569e2004045c917ada1f66d2", + "size_in_bytes": 86792 + }, + { + "_path": "Lib/__pycache__/pickle.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ca77b69974c10c3bbe89d0ebb4c90d3830d6ef6dfe83b40aef4761e3f25577a1", + "size_in_bytes": 86878 + }, + { + "_path": "Lib/__pycache__/pickletools.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "048e5f03ac3e23e2464b7b24648b058bc061906b9c23c0d8b265800204a221eb", + "size_in_bytes": 86715 + }, + { + "_path": "Lib/__pycache__/pipes.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "85f14d678885735b9921675bb29db9c1bc41ab426035eda54c078b207744a5c7", + "size_in_bytes": 11950 + }, + { + "_path": "Lib/__pycache__/pkgutil.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ad00ce572dfa1cf9eff3639cd4bee4947e64c2d5cf434f78b6d14a67455e7997", + "size_in_bytes": 31562 + }, + { + "_path": "Lib/__pycache__/platform.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "117723c6120c44b770c03b6f1c64b23be6bb68e68f466a47ba7c7598df0d8ab9", + "size_in_bytes": 43971 + }, + { + "_path": "Lib/__pycache__/plistlib.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0313ab510e1f239e0af8ca9ac8be51a6e0948924aecfbdc8e076d8a219e075be", + "size_in_bytes": 46141 + }, + { + "_path": "Lib/__pycache__/poplib.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d377a871873f6caedbda83c6b8fe3e61c29e7694ca6319987d2bf83894034768", + "size_in_bytes": 20952 + }, + { + "_path": "Lib/__pycache__/posixpath.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "dfca54a4e714f35d74164603dab38d52f8b5416fdc9ca536a410db9ad70bf681", + "size_in_bytes": 20157 + }, + { + "_path": "Lib/__pycache__/pprint.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f845e91253bc6d4cac014b8797b1df31a286e968f6825426a2ab036f225a5c00", + "size_in_bytes": 33547 + }, + { + "_path": "Lib/__pycache__/profile.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "223c706be8916ecb9e0da6ffa74b713d57dadc9700b185bee311707897145800", + "size_in_bytes": 23938 + }, + { + "_path": "Lib/__pycache__/pstats.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f03641c5192459e443516af99256ee977f6d29709d3d3f4ac9e89bfe1f951bf3", + "size_in_bytes": 41851 + }, + { + "_path": "Lib/__pycache__/pty.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "65059d1aeda64e6f61c333fae405c5578e67a7baceda6c33df52f7d90dcc27d5", + "size_in_bytes": 8424 + }, + { + "_path": "Lib/__pycache__/py_compile.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b4e1a41a74e8433da7a9518be553518f529d7f52ed04bccf6e2a13f81999a9ce", + "size_in_bytes": 10758 + }, + { + "_path": "Lib/__pycache__/pyclbr.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f09fb15cf98a3667f4bacab95d9ef50b78fc2c5ac270d3d434db6fc015c8500d", + "size_in_bytes": 15862 + }, + { + "_path": "Lib/__pycache__/pydoc.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c9cc77de1875477b4c61e9cea806508acdbe4ca5aa6ca6e140a179e5cb92a696", + "size_in_bytes": 158289 + }, + { + "_path": "Lib/__pycache__/queue.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e11ec77931897a2b39cf7a0cf22d413bc66d0a26988f72d2ab76fedff1e2b948", + "size_in_bytes": 16437 + }, + { + "_path": "Lib/__pycache__/quopri.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "669b028503d7cb1a48bbe4ee317eff2e2d6ecb5f5773fce8c49ed7495b6c18c6", + "size_in_bytes": 10841 + }, + { + "_path": "Lib/__pycache__/random.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e9256227a1f898f07c753775558d17d03c2d315ccc6d4314fdafecd320b9ebce", + "size_in_bytes": 34508 + }, + { + "_path": "Lib/__pycache__/reprlib.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c6393c458326c9608ba7ee90e0cb807e915d139c64e7c77d4f334f4ab6aef702", + "size_in_bytes": 9662 + }, + { + "_path": "Lib/__pycache__/rlcompleter.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "30dc98258933a8185283d90ee2783a0ca0837832d7e1e492a71e9f52653dc75b", + "size_in_bytes": 8994 + }, + { + "_path": "Lib/__pycache__/runpy.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "46da22ed8f0a21f22819a37eb8b8becab8373ac7c6358a435f92fd76bbbc6a3c", + "size_in_bytes": 16100 + }, + { + "_path": "Lib/__pycache__/sched.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "495ae07cba9f92f81201b1ae7c6977fb5968ebd42562bbc8370474b1599075de", + "size_in_bytes": 8386 + }, + { + "_path": "Lib/__pycache__/secrets.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "12f0ef352f582a7bde4f8f04f5efcee9af5edd1ad893761480265447bb83b619", + "size_in_bytes": 2846 + }, + { + "_path": "Lib/__pycache__/selectors.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c2cd169375677b6c83e3d16042d093048663824b052450d9914464ac5403ffdb", + "size_in_bytes": 28523 + }, + { + "_path": "Lib/__pycache__/shelve.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1c0ff7c5e727723d80321317fba75db1dc5e3a936a0fb53093c2493da01bcbe9", + "size_in_bytes": 13857 + }, + { + "_path": "Lib/__pycache__/shlex.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b463c0671030edf8fdd38293ee91d7b64a6ad0a94595e0ac7322b73b4d49924b", + "size_in_bytes": 14687 + }, + { + "_path": "Lib/__pycache__/shutil.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4e17b693b823e2c3a5a2e01d2042e7bd24c9a19ee04f1fda954d0de2b7501260", + "size_in_bytes": 73228 + }, + { + "_path": "Lib/__pycache__/signal.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "57444d42c049eb1f905c84b9ee45517d245ccecc168c23f06a300322fcb48a8c", + "size_in_bytes": 5090 + }, + { + "_path": "Lib/__pycache__/site.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d0e42a3447d96ca869b7da2382468c150c60743292c4efe595405b06b00a6f12", + "size_in_bytes": 30457 + }, + { + "_path": "Lib/__pycache__/smtpd.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "56a09677b6a90d1d444e6ca3951c2267f230863d4394313a430a51d97010f3b1", + "size_in_bytes": 43649 + }, + { + "_path": "Lib/__pycache__/smtplib.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2e6e2bf0f63f07242c027987b5a4d00f7ea323c06e9fe191fee57939bb09fd3e", + "size_in_bytes": 54104 + }, + { + "_path": "Lib/__pycache__/sndhdr.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "81e6f80c331de99ce60fe7f5cd5ac3b446434d14b660636b310f639f46a63460", + "size_in_bytes": 12410 + }, + { + "_path": "Lib/__pycache__/socket.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4b6a4518ade133b0cf25289d236afe8ecadd2d22d3ad0de3d49823c44ebd9512", + "size_in_bytes": 45667 + }, + { + "_path": "Lib/__pycache__/socketserver.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "903a5a2e62be3f7027c96b75b0323cfe49add7859abb5fc3dabd52c1a631b6da", + "size_in_bytes": 37040 + }, + { + "_path": "Lib/__pycache__/sre_compile.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "dd70df7bcc4a4806c492005f3ed3e23fb815fed5408e3007b585136a85f907ea", + "size_in_bytes": 797 + }, + { + "_path": "Lib/__pycache__/sre_constants.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "359deab115702636433d2af5c3f96fbadc5b0dc3a23b5282061d78e73de51659", + "size_in_bytes": 800 + }, + { + "_path": "Lib/__pycache__/sre_parse.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b2041e047583c548a376833961c295f732ad92617e7d6166aedb23b4baff3a6a", + "size_in_bytes": 793 + }, + { + "_path": "Lib/__pycache__/ssl.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2199e7ffebe8815c0452549bce0f2e9f453fc12c3aa19b01c4e11cd1c5aa7587", + "size_in_bytes": 73585 + }, + { + "_path": "Lib/__pycache__/stat.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6850dc0b31edd41e2a15bb9fc14d483fbdf2ab2e6bd2839cd02f18b9742bc9c1", + "size_in_bytes": 5522 + }, + { + "_path": "Lib/__pycache__/statistics.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "84ad7154c62b09c413e0cca4b88e1786c451df127026585c2f2d69320e244e7d", + "size_in_bytes": 58387 + }, + { + "_path": "Lib/__pycache__/string.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5df228270ef7e2279af42690db3448fe9b43ec30cc566e9db6490d1d5dd64c7e", + "size_in_bytes": 12622 + }, + { + "_path": "Lib/__pycache__/stringprep.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6b94914e1431b6ae2772c052a73d1181fed8340726c8aa6b8a7c434766afa10f", + "size_in_bytes": 26511 + }, + { + "_path": "Lib/__pycache__/struct.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5189c5ec56dc62d4bf1c019cff7ce0c2ccba02f74093ad4d9c5ca4d7f06b7050", + "size_in_bytes": 364 + }, + { + "_path": "Lib/__pycache__/subprocess.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5e2f498936724b062713968019616fb5fd6bf5e8d0b5810d6f8846ade777342b", + "size_in_bytes": 84793 + }, + { + "_path": "Lib/__pycache__/sunau.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b046429662335a592ef303cb5802fb744331c93d54b302cbdecb2bed2785c876", + "size_in_bytes": 26988 + }, + { + "_path": "Lib/__pycache__/symtable.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "952ddc35b98933d645dcb0ba73d64a6574f961bd20433042b276154da6a15c22", + "size_in_bytes": 19491 + }, + { + "_path": "Lib/__pycache__/sysconfig.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5966944103577763a11f745350d845e5a0bb3cdd75799924ab454580c59b84a8", + "size_in_bytes": 31810 + }, + { + "_path": "Lib/__pycache__/tabnanny.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4b0148dd77b25daf92b7454612037cc361ea0bdb1004df67a2e68d78c315ebec", + "size_in_bytes": 12932 + }, + { + "_path": "Lib/__pycache__/tarfile.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f31068333dc3e1df730ce8b04035533ab5576cdfea977e09c71a086ec7328f18", + "size_in_bytes": 134960 + }, + { + "_path": "Lib/__pycache__/telnetlib.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2a7e0dbf267a5429519a0ec611847f5e625a7a27feb0a9c7d3d2f85bc4f9ea52", + "size_in_bytes": 31063 + }, + { + "_path": "Lib/__pycache__/tempfile.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0cfb2dcdf99087244dc5190089f1ed82458b146b230de0d57b13965f864b3c5c", + "size_in_bytes": 42142 + }, + { + "_path": "Lib/__pycache__/textwrap.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7997f9bbe5632687c85c422e15ed5623fa6687dfc9b815f3ee6d52aaef311adf", + "size_in_bytes": 19579 + }, + { + "_path": "Lib/__pycache__/this.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f2d60da10361707c4b1ebbcd1a613fa7d19544bbfbf1519b41529ad2fc5bdf88", + "size_in_bytes": 1580 + }, + { + "_path": "Lib/__pycache__/threading.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "25cbfb70916a2622685b84a27de8e0aac59f5d4b769e877c61e61d00bec0e858", + "size_in_bytes": 70295 + }, + { + "_path": "Lib/__pycache__/timeit.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a341c2be3fda8f38d66d145466847c6b60ee31c130359b760afbdb81e5f08caa", + "size_in_bytes": 16436 + }, + { + "_path": "Lib/__pycache__/token.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0604e86a9cce705b50342cdc435d312784d1093e7bbc06f2d275e575c454bf9a", + "size_in_bytes": 3707 + }, + { + "_path": "Lib/__pycache__/tokenize.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9e59c78ec6b324e12eb7d9adf1a837ac0bf7366d5f36522bb7613e9211a718ea", + "size_in_bytes": 30342 + }, + { + "_path": "Lib/__pycache__/trace.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a054c48cba3821eebc9a684056d54eb1c3bc02191d5363fcc0061689b14d3c18", + "size_in_bytes": 35946 + }, + { + "_path": "Lib/__pycache__/traceback.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0dd460b439bebe39f1e665d380ed5f1c41d03516286060e32a2ed29cc7dc234c", + "size_in_bytes": 48705 + }, + { + "_path": "Lib/__pycache__/tracemalloc.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3d3ab76fd35e2c24bfc6060ed40093b915faeb8a27f3ef85ccc6210133246cf7", + "size_in_bytes": 29068 + }, + { + "_path": "Lib/__pycache__/tty.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6b2069b00e367a42cd428755fd506d13f89ac3fd35f578137dc7737dec4bf2ba", + "size_in_bytes": 2009 + }, + { + "_path": "Lib/__pycache__/turtle.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "42519357a970703d79eeeb12fd2b2476d9fa679736c8ee8ca52ad743c049e846", + "size_in_bytes": 193412 + }, + { + "_path": "Lib/__pycache__/types.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "fdbc0d7569fe9c189f2ea38778803175e35c80b535634404005822a9cb315813", + "size_in_bytes": 14803 + }, + { + "_path": "Lib/__pycache__/typing.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7f4a52cd3844a1938c17ebff7b8a5db5aec27e13dd09618e45cd764938ace2b8", + "size_in_bytes": 161639 + }, + { + "_path": "Lib/__pycache__/uu.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8989763abe992862d035fc8420d0492a35e3f37c3cc67c239e72f5c9c83f17b5", + "size_in_bytes": 8779 + }, + { + "_path": "Lib/__pycache__/uuid.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "350f2b6ec2d14a3328d47f957748ea6cc35e3e7f48beba9004a94fde84b4707b", + "size_in_bytes": 33051 + }, + { + "_path": "Lib/__pycache__/warnings.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "87820a8b9c464f7345429e92c56d40491bafe66162031ed22ec88136b907b22b", + "size_in_bytes": 25045 + }, + { + "_path": "Lib/__pycache__/wave.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a901dece50f4fb3ab619232edcd103e2887545c81c803bb9c70428d2cfa12338", + "size_in_bytes": 32320 + }, + { + "_path": "Lib/__pycache__/weakref.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8e97e23331c7267a3cce1319cb14533ecae94999c917342445d2e9228ad5d7d4", + "size_in_bytes": 34941 + }, + { + "_path": "Lib/__pycache__/webbrowser.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ed5d17eb62d924e3c15fd1173ff4dd3db57fc869a53d8dd8524e517c67af4446", + "size_in_bytes": 32804 + }, + { + "_path": "Lib/__pycache__/xdrlib.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c0ba3382f8c92f59082dc5dbd1b0b549dd1b6b2efbc682c4ebf99ae496cc9ce8", + "size_in_bytes": 13126 + }, + { + "_path": "Lib/__pycache__/zipapp.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f030a66e27f33f011a7f5deaa19b3e59e4df62968ee7d2af8427021013826769", + "size_in_bytes": 11523 + }, + { + "_path": "Lib/__pycache__/zipfile.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "42a55be255858ecbc75f7adb4557a8ca4f2545c409bbc5718d214381b82796ee", + "size_in_bytes": 119857 + }, + { + "_path": "Lib/__pycache__/zipimport.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f0ed88c635a381b816dd3d06ee662703272491d43c80d2d7c9490e44b3bd6898", + "size_in_bytes": 29771 + }, + { + "_path": "Lib/_aix_support.py", + "path_type": "hardlink", + "sha256": "78790b6fd80cd62f8a6e49d79ec2b5921c6176d0dd41d1309c9cdbd0049c4071", + "size_in_bytes": 3389 + }, + { + "_path": "Lib/_bootsubprocess.py", + "path_type": "hardlink", + "sha256": "dd8afc4a86131491a4f05078b307aae5eef19d6a26e7d9ffbfe2ebabbd6b5b6a", + "size_in_bytes": 2675 + }, + { + "_path": "Lib/_collections_abc.py", + "path_type": "hardlink", + "sha256": "ec646ef7e27aae261adef3c57b9d18822c6526b3e9562dabb9f3cb4e6803066c", + "size_in_bytes": 30193 + }, + { + "_path": "Lib/_compat_pickle.py", + "path_type": "hardlink", + "sha256": "12c8356a3d40bd0a336f13d7c6e2bed50d5c1a876563766a3175a6b328b5855e", + "size_in_bytes": 8761 + }, + { + "_path": "Lib/_compression.py", + "path_type": "hardlink", + "sha256": "3ad5d60627477a60939ee44fc1bb3a05dbe8fb52f0f75039b8f5d8f1a278b981", + "size_in_bytes": 5681 + }, + { + "_path": "Lib/_markupbase.py", + "path_type": "hardlink", + "sha256": "cb14dd6f2e2439eb70b806cd49d19911363d424c2b6b9f4b73c9c08022d47030", + "size_in_bytes": 14653 + }, + { + "_path": "Lib/_osx_support.py", + "path_type": "hardlink", + "sha256": "363d3240acbba18a270bd3161f1ddb478f8492dc14fc451b2dc314db5c5ee09c", + "size_in_bytes": 22023 + }, + { + "_path": "Lib/_py_abc.py", + "path_type": "hardlink", + "sha256": "f9c6fe3dd9b51bd7d93f867356e9d362600c924febfd903ee1c6e298860dca92", + "size_in_bytes": 6189 + }, + { + "_path": "Lib/_pydecimal.py", + "path_type": "hardlink", + "sha256": "14cf1bf7ead78a0beb578f19ebc4ec82f542e0879f5b77d327f01abf74591586", + "size_in_bytes": 229202 + }, + { + "_path": "Lib/_pyio.py", + "path_type": "hardlink", + "sha256": "e04305281ca9b2abec0d325e26e21efcd1dde1ee076da22de29d25087465dd89", + "size_in_bytes": 94193 + }, + { + "_path": "Lib/_sitebuiltins.py", + "path_type": "hardlink", + "sha256": "b9388bc1d6d12ed6be12da420ab1feca40f99c0e33ec315d92b1e01cb69b25bc", + "size_in_bytes": 3128 + }, + { + "_path": "Lib/_strptime.py", + "path_type": "hardlink", + "sha256": "d132241724bde0b494a2fcbb6500d4cecf603e79dd662908c452b83904536a01", + "size_in_bytes": 25175 + }, + { + "_path": "Lib/_threading_local.py", + "path_type": "hardlink", + "sha256": "e1bf3dae66d0bfa63c8bb8a1d10c611203c35c636f7f5191fd56105788ef29cb", + "size_in_bytes": 7220 + }, + { + "_path": "Lib/_weakrefset.py", + "path_type": "hardlink", + "sha256": "91895a451d06e9f521a1171b31b9b19bc9740f35af00d4fa106338ab7167c9ac", + "size_in_bytes": 5893 + }, + { + "_path": "Lib/abc.py", + "path_type": "hardlink", + "sha256": "e558702a95cdce3febd289da021715d2b92bc43995b8a1bc58dfa1c3d8010287", + "size_in_bytes": 6538 + }, + { + "_path": "Lib/aifc.py", + "path_type": "hardlink", + "sha256": "e027e8a33567890ad7f84fea3be423cc0f6e49a33a31bbf279c2d0f64b6f8345", + "size_in_bytes": 34211 + }, + { + "_path": "Lib/antigravity.py", + "path_type": "hardlink", + "sha256": "8a5ee63e1b79ba2733e7ff4290b6eefea60e7f3a1ccb6bb519535aaf92b44967", + "size_in_bytes": 500 + }, + { + "_path": "Lib/argparse.py", + "path_type": "hardlink", + "sha256": "e878677e158d0bc0fb5119e0df74d94236f3653777bc9f2ea3fee49c167fe001", + "size_in_bytes": 100283 + }, + { + "_path": "Lib/ast.py", + "path_type": "hardlink", + "sha256": "c513073798bdbf3cdef09327d0d2d381a53213a13a4ba3f02729695327539406", + "size_in_bytes": 61444 + }, + { + "_path": "Lib/asynchat.py", + "path_type": "hardlink", + "sha256": "63fe1a2fd717d09ad462ca87adf57d8963c67a58e18c40340d5c9e39390ccf94", + "size_in_bytes": 11570 + }, + { + "_path": "Lib/asyncio/__init__.py", + "path_type": "hardlink", + "sha256": "d70b5f90b186ae41464b740f0ee1f2c2ab2dcf02f1403e749edc48002ba27426", + "size_in_bytes": 1188 + }, + { + "_path": "Lib/asyncio/__main__.py", + "path_type": "hardlink", + "sha256": "318f003efb1ad1cc2c3107a3f0e21d6e9a32f8599b8b0ad66d80b03d9e7bcc21", + "size_in_bytes": 3379 + }, + { + "_path": "Lib/asyncio/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f88c8e9b74ce96ac7ecfc36be5e858e1b3fda17079f793835b28e23e26591644", + "size_in_bytes": 1326 + }, + { + "_path": "Lib/asyncio/__pycache__/__main__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "86a583883eb7028f2526eabfca9d3cd1c36b6e6333171bf314e5ee2ee7c04d98", + "size_in_bytes": 5997 + }, + { + "_path": "Lib/asyncio/__pycache__/base_events.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3fe2c4a399c54958329e486be2fa1ae4320dc66305809b4b0ac5499a04dc7016", + "size_in_bytes": 91187 + }, + { + "_path": "Lib/asyncio/__pycache__/base_futures.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2d332bbfdc60a6ba3a833e350e59e8ecd0c817d49752d6c9074eab7d5eb4c42b", + "size_in_bytes": 3370 + }, + { + "_path": "Lib/asyncio/__pycache__/base_subprocess.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b1c629f2e41d8277ab2a459ca54adca35f83fa2ea8421a892a914396803c9f0e", + "size_in_bytes": 16685 + }, + { + "_path": "Lib/asyncio/__pycache__/base_tasks.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ce73751b0fbcdc03ac421b5ef7a09cf58f474368386df9f79a51ca4022e5a2c6", + "size_in_bytes": 4158 + }, + { + "_path": "Lib/asyncio/__pycache__/constants.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "64b434daae545010f20e1e4b7e12bd04050b3250c656645655da6533bfe05279", + "size_in_bytes": 945 + }, + { + "_path": "Lib/asyncio/__pycache__/coroutines.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "23d18c7bb087a743f1fe640bc3ae38fd71fa2bdb07fedd834038973a9226640a", + "size_in_bytes": 3979 + }, + { + "_path": "Lib/asyncio/__pycache__/events.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "bd12f74d1fe4e6cbdbd035c9fae7cbb6e099ab172356c125bfde3dd7d784e09b", + "size_in_bytes": 37773 + }, + { + "_path": "Lib/asyncio/__pycache__/exceptions.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e662e5d3e64cc8253a629750dfc15603485b876da3d69f8cd01fe17c4807016e", + "size_in_bytes": 3625 + }, + { + "_path": "Lib/asyncio/__pycache__/format_helpers.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "509760541796b088324932fa3d9cd15f5425636a5a833bc87c80dd361581aa8e", + "size_in_bytes": 4113 + }, + { + "_path": "Lib/asyncio/__pycache__/futures.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f9a4bc818c0438f0aa4a6169a22043dc4d458545ac6f49429f8ee11437ae15e3", + "size_in_bytes": 18486 + }, + { + "_path": "Lib/asyncio/__pycache__/locks.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "edbe7dfead69a60b0fd169d3643614dfc4e11546a78c40e68f0d527bb39dca4e", + "size_in_bytes": 29189 + }, + { + "_path": "Lib/asyncio/__pycache__/log.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f98bb12e5b25a101a9db51249775a530fdfacc7f93dfacbf4e6d0077645aea63", + "size_in_bytes": 276 + }, + { + "_path": "Lib/asyncio/__pycache__/mixins.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "20efdf74f3d953e2c6bc0548483e6f42c636dd3c3207a629f89ce26ef1da2ced", + "size_in_bytes": 1178 + }, + { + "_path": "Lib/asyncio/__pycache__/proactor_events.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "472cb4ffce319efb59e8b82468669e5b15bc2aecc3c870ad999ef9e1e914915a", + "size_in_bytes": 47723 + }, + { + "_path": "Lib/asyncio/__pycache__/protocols.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f53afd4d9ada31222162000636c89b6ff107e32b878a29f43ce8f201c495eb69", + "size_in_bytes": 9427 + }, + { + "_path": "Lib/asyncio/__pycache__/queues.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3ea46fd2b8bb3b73da24c69e51f7cb0f531507d3b65b2d3382967a4603ec50f0", + "size_in_bytes": 12808 + }, + { + "_path": "Lib/asyncio/__pycache__/runners.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c5a0fb3f1d453f097a492ad84c2946fffd5256403aaee4074e4215cf0a83b664", + "size_in_bytes": 10215 + }, + { + "_path": "Lib/asyncio/__pycache__/selector_events.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9d03d8cb81a3157749126cc70ea48131f6d7db764465bf315a769b7077367d21", + "size_in_bytes": 64174 + }, + { + "_path": "Lib/asyncio/__pycache__/sslproto.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8192c503cfb0fefeff26395f9493dc7c0d90745315dee14f36b9aaed5b47b8d6", + "size_in_bytes": 43494 + }, + { + "_path": "Lib/asyncio/__pycache__/staggered.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "83b1b6c0c8d4907d3d2e4863fa700391b4bd42273cf5d5371f150b951220b8a4", + "size_in_bytes": 6618 + }, + { + "_path": "Lib/asyncio/__pycache__/streams.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f2a552115175276a9b0539c91b9b88709bc2289f85197ac63263620a3816de2a", + "size_in_bytes": 34972 + }, + { + "_path": "Lib/asyncio/__pycache__/subprocess.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3aafffe5ef3220a2e260859f7d61edb6eb2baccb26e1a5f3ce2a6623d3644606", + "size_in_bytes": 12644 + }, + { + "_path": "Lib/asyncio/__pycache__/taskgroups.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "69d44f54b4fabec78523676e2be8c5b1ea9a104b852236ae6a0a75884243b187", + "size_in_bytes": 8073 + }, + { + "_path": "Lib/asyncio/__pycache__/tasks.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "944e1e1b9cb3fbc58dac87ec6bae6c5dc95611cb85f8eb47ab248841b0195901", + "size_in_bytes": 40987 + }, + { + "_path": "Lib/asyncio/__pycache__/threads.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ab60218661a19206e957b4e52468b2c53821e1fa6766ac87eebfc069abc47dbc", + "size_in_bytes": 1275 + }, + { + "_path": "Lib/asyncio/__pycache__/timeouts.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "aaa34d8f171365461a7e26afa4e3744e814168dd9acd6fb7726046c358bdc34b", + "size_in_bytes": 7972 + }, + { + "_path": "Lib/asyncio/__pycache__/transports.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d4edc0ab6ea4fc5d644f95b38d7e97c0a38052ba0505fbce486638dababc5651", + "size_in_bytes": 15151 + }, + { + "_path": "Lib/asyncio/__pycache__/trsock.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d027a0a0ff06702b6696563e75042d6ecfd4bcfc04593399432615f5a4a4a937", + "size_in_bytes": 5366 + }, + { + "_path": "Lib/asyncio/__pycache__/unix_events.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1a8dd98b91e56e55a165f48bd166fdbd22cd6870bce5fbc700985560358c628a", + "size_in_bytes": 73306 + }, + { + "_path": "Lib/asyncio/__pycache__/windows_events.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4e4c8cf56b9e9727a8885d518ed979ede2a4217d653e0e5b9217518f5bb5b6f8", + "size_in_bytes": 47005 + }, + { + "_path": "Lib/asyncio/__pycache__/windows_utils.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "583c87779bb2261edf2b03041e04d06151c5a72db109d591790399bf48d4e5a9", + "size_in_bytes": 7738 + }, + { + "_path": "Lib/asyncio/base_events.py", + "path_type": "hardlink", + "sha256": "cc9ac9cf0cea307701991c275fda4d972228f6d174451ffa116800fb0fb856ca", + "size_in_bytes": 75384 + }, + { + "_path": "Lib/asyncio/base_futures.py", + "path_type": "hardlink", + "sha256": "385a1fd5e8688f1f79e0fdfea8c27d7ca6dd78a770f0bd9a438863628a7589fb", + "size_in_bytes": 2004 + }, + { + "_path": "Lib/asyncio/base_subprocess.py", + "path_type": "hardlink", + "sha256": "d69ba8f97bf8c89564cadce49427574ddb98103a5db6f04b98798240332e7adf", + "size_in_bytes": 8869 + }, + { + "_path": "Lib/asyncio/base_tasks.py", + "path_type": "hardlink", + "sha256": "70f6b21a2371eaa8e7a3beab9700cd1920329b02708975ae6c9450dc77d64502", + "size_in_bytes": 2644 + }, + { + "_path": "Lib/asyncio/constants.py", + "path_type": "hardlink", + "sha256": "7c2efc8c6c767227f25c5c14b7e1e6ff0237b78879ba8d6587d44ed1c360ed30", + "size_in_bytes": 1326 + }, + { + "_path": "Lib/asyncio/coroutines.py", + "path_type": "hardlink", + "sha256": "8b60928d13116c28bbd2e1df0a34a6cc87c3416d89c31291677ed63f77b54580", + "size_in_bytes": 3400 + }, + { + "_path": "Lib/asyncio/events.py", + "path_type": "hardlink", + "sha256": "7276ed5173080703d41a4a9e54d73b45fe159d8f67d86c196b2ce1eb82d7d983", + "size_in_bytes": 28641 + }, + { + "_path": "Lib/asyncio/exceptions.py", + "path_type": "hardlink", + "sha256": "a5971f88be14cd1417d59adf539ae48c5d818f95362a4e0eb00017e3690ab37b", + "size_in_bytes": 1752 + }, + { + "_path": "Lib/asyncio/format_helpers.py", + "path_type": "hardlink", + "sha256": "6377b672b3f4ba8b6f0f7a5f0ea00cde24c8cddc0ca764e3329f302763477f59", + "size_in_bytes": 2404 + }, + { + "_path": "Lib/asyncio/futures.py", + "path_type": "hardlink", + "sha256": "a1b23b2d0a1333a27115676a934157057b3007306957f005100e1ff27276baed", + "size_in_bytes": 14212 + }, + { + "_path": "Lib/asyncio/locks.py", + "path_type": "hardlink", + "sha256": "3c8d4862ec147ca51c6a18a160ff2c954ecf90ac2348a3ec0bc4907216a11eb9", + "size_in_bytes": 19014 + }, + { + "_path": "Lib/asyncio/log.py", + "path_type": "hardlink", + "sha256": "80e4cc3ded4b138baba486519e7444801a23d6ac35f229d336a407a96af7e8d2", + "size_in_bytes": 124 + }, + { + "_path": "Lib/asyncio/mixins.py", + "path_type": "hardlink", + "sha256": "8f4a3e16eca845ebfba422550cbcee7340ec8166d2bff6b750a8ed0de6b9ae3c", + "size_in_bytes": 481 + }, + { + "_path": "Lib/asyncio/proactor_events.py", + "path_type": "hardlink", + "sha256": "ba8ef5e12f850cfdf0757dadbedcaf15e00c7dbda5663f61c2ec9e5358e51c04", + "size_in_bytes": 33264 + }, + { + "_path": "Lib/asyncio/protocols.py", + "path_type": "hardlink", + "sha256": "1d1b49988c338b4ef06e30f9e92d9db2e00080c341f0a3f573bb8312deb8aff6", + "size_in_bytes": 6957 + }, + { + "_path": "Lib/asyncio/queues.py", + "path_type": "hardlink", + "sha256": "8f020744ebd1f557dcb051a1530b504447660df906c2127a94bbcc8450ea7ef9", + "size_in_bytes": 7974 + }, + { + "_path": "Lib/asyncio/runners.py", + "path_type": "hardlink", + "sha256": "0f11dcd59cd7f9e24a092d55dd1e7037288f3a524da53e882114b11326de21dd", + "size_in_bytes": 6842 + }, + { + "_path": "Lib/asyncio/selector_events.py", + "path_type": "hardlink", + "sha256": "c7859582a5b505f0ab2bb6e5f0d17f4475b58598f56c5166e2edf3b766e8cc68", + "size_in_bytes": 45400 + }, + { + "_path": "Lib/asyncio/sslproto.py", + "path_type": "hardlink", + "sha256": "c747273038c3d27d0447f84eace19faf6c0e2730a0aa89639f9a40af41b5d180", + "size_in_bytes": 31739 + }, + { + "_path": "Lib/asyncio/staggered.py", + "path_type": "hardlink", + "sha256": "ff289bdc20a50ad9620393479d785bc653e71c2e3298f53ab27907cd136498e9", + "size_in_bytes": 5992 + }, + { + "_path": "Lib/asyncio/streams.py", + "path_type": "hardlink", + "sha256": "995c45d23a1335a529ba62d690e282f7639c7f1cf48eed9efdb5b02e606c69a3", + "size_in_bytes": 27503 + }, + { + "_path": "Lib/asyncio/subprocess.py", + "path_type": "hardlink", + "sha256": "027198037c8735a75231f660fbb51b626b4e83ccde40b0eb872a60bb4fdac2b4", + "size_in_bytes": 7682 + }, + { + "_path": "Lib/asyncio/taskgroups.py", + "path_type": "hardlink", + "sha256": "553c0ce39014fff454bdd4454bd53c6599890375b5fdd528ac19334c9221b650", + "size_in_bytes": 8471 + }, + { + "_path": "Lib/asyncio/tasks.py", + "path_type": "hardlink", + "sha256": "e88c1a5e5ddd4fff195ad3d086fb774f9fda4956d3b1711f403576804a4ba5c7", + "size_in_bytes": 34433 + }, + { + "_path": "Lib/asyncio/threads.py", + "path_type": "hardlink", + "sha256": "39d37295383641565f0c08bd992e2f661dc8051eb17e890b834fce96bde0910e", + "size_in_bytes": 790 + }, + { + "_path": "Lib/asyncio/timeouts.py", + "path_type": "hardlink", + "sha256": "3e40ca0dca3e54776579797837cd4936d73d04aae09fe0cf83ce1e5449d00163", + "size_in_bytes": 5321 + }, + { + "_path": "Lib/asyncio/transports.py", + "path_type": "hardlink", + "sha256": "940108bc133de399f38928cad3274f463096168d8a3ee5148f2478d3cb636f1c", + "size_in_bytes": 10722 + }, + { + "_path": "Lib/asyncio/trsock.py", + "path_type": "hardlink", + "sha256": "c0eac37debcc51b702b808f6b7ed3e417343f5ff5f57125dad600a27eb082328", + "size_in_bytes": 2475 + }, + { + "_path": "Lib/asyncio/unix_events.py", + "path_type": "hardlink", + "sha256": "a68a39b8ac56468a005d86c708e66e13d6d163f9c787b4fe70442bb2f8c1f198", + "size_in_bytes": 51915 + }, + { + "_path": "Lib/asyncio/windows_events.py", + "path_type": "hardlink", + "sha256": "419611038ad585a4dc27bd75d052763344c82ad45da3cf35c35284c4dd0b0a78", + "size_in_bytes": 34691 + }, + { + "_path": "Lib/asyncio/windows_utils.py", + "path_type": "hardlink", + "sha256": "e6fcffefa2521666bc2aed0f5caf8e862c1c1014ad12d2ab5fbce09c2df9c6f0", + "size_in_bytes": 5060 + }, + { + "_path": "Lib/asyncore.py", + "path_type": "hardlink", + "sha256": "0dc49691ced7a3d7c67eb42f1319d1a93f7fae9cec65712a38cfaeee26fefffb", + "size_in_bytes": 20310 + }, + { + "_path": "Lib/base64.py", + "path_type": "hardlink", + "sha256": "7de2ffc30db7b791f482ee8e6cba30a7b69452324d466231f29395be00154b4b", + "size_in_bytes": 21028 + }, + { + "_path": "Lib/bdb.py", + "path_type": "hardlink", + "sha256": "314d8bf11b4824d47471ad25dab64bda895e39673fb744e88e7f622a3dd374f2", + "size_in_bytes": 32463 + }, + { + "_path": "Lib/bisect.py", + "path_type": "hardlink", + "sha256": "e5b2ff166f48a06e70ae831d8c9b47283fcd0c254306eee12d3dae9c55e11526", + "size_in_bytes": 3135 + }, + { + "_path": "Lib/bz2.py", + "path_type": "hardlink", + "sha256": "76ab3252924e71e859d7d90e8d3db13b6554975cfcac0fdadced4de7f8779330", + "size_in_bytes": 11847 + }, + { + "_path": "Lib/cProfile.py", + "path_type": "hardlink", + "sha256": "0a97cf92d0e3efd2e08c2f9b0f0fb8e52a2b26978550804d8e59435201f3fa84", + "size_in_bytes": 6346 + }, + { + "_path": "Lib/calendar.py", + "path_type": "hardlink", + "sha256": "15903bacf6416869a58abff7d1680e16f26e9bd0186ad0562a0668d05f076fd9", + "size_in_bytes": 24731 + }, + { + "_path": "Lib/cgi.py", + "path_type": "hardlink", + "sha256": "f132666784c29a3e275f50596f87bb8abc388a94fcdb70be130000e01a9a6b78", + "size_in_bytes": 34420 + }, + { + "_path": "Lib/cgitb.py", + "path_type": "hardlink", + "sha256": "401f791a56480b5b53e207d71a904e6352c5e7fc3f7cc9124c75bd1c59a5c011", + "size_in_bytes": 12421 + }, + { + "_path": "Lib/chunk.py", + "path_type": "hardlink", + "sha256": "4817eb94eeb8835c3325433f68f17e0ebbf7c96065ecf6aba3af7852f9a5314b", + "size_in_bytes": 5500 + }, + { + "_path": "Lib/cmd.py", + "path_type": "hardlink", + "sha256": "fb82a8c4e44e5b559c88d516d79051534cec69a463df97defe05ac8a261f0a0d", + "size_in_bytes": 14873 + }, + { + "_path": "Lib/code.py", + "path_type": "hardlink", + "sha256": "266841655656d5b2370e80addcdb959f5173142d5e3778b489e734802447c5e8", + "size_in_bytes": 10622 + }, + { + "_path": "Lib/codecs.py", + "path_type": "hardlink", + "sha256": "f16a81d14e7f73931ecf9f9f2e17c10bc0ca29bbe38b0243f6919b70882fcfea", + "size_in_bytes": 37150 + }, + { + "_path": "Lib/codeop.py", + "path_type": "hardlink", + "sha256": "353e35188867d3efb0d384ac4aacf36005037662632c2d4e0c5483f63f795eaa", + "size_in_bytes": 5907 + }, + { + "_path": "Lib/collections/__init__.py", + "path_type": "hardlink", + "sha256": "64b09e7062bb7f41e080900d414988c289624aea0ee6ca4037f1e317a11374ee", + "size_in_bytes": 52018 + }, + { + "_path": "Lib/collections/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "54cacebb0fb590f1b97763efc2c1d8bfbfc1beb631ddfc296ee3822c763dc50d", + "size_in_bytes": 78199 + }, + { + "_path": "Lib/collections/__pycache__/abc.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b967dc7ec7840b3489bbeb3d12e615e3bd12e56e964d179fe4416d15bdb94eef", + "size_in_bytes": 278 + }, + { + "_path": "Lib/collections/abc.py", + "path_type": "hardlink", + "sha256": "9cb4208f99128a0489b6c8e6c61637617dd7d4250c59e065491957eda084dd10", + "size_in_bytes": 119 + }, + { + "_path": "Lib/colorsys.py", + "path_type": "hardlink", + "sha256": "d9800f8e81d46e63ca6f2e7d6ac5f344d85afb92c3cf6d103b5f977f1ad66ac2", + "size_in_bytes": 4062 + }, + { + "_path": "Lib/compileall.py", + "path_type": "hardlink", + "sha256": "859a2743805b0570286bd71d2296becc335bfba4277073b87c8b9ec3dc308a98", + "size_in_bytes": 20252 + }, + { + "_path": "Lib/concurrent/__init__.py", + "path_type": "hardlink", + "sha256": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8", + "size_in_bytes": 38 + }, + { + "_path": "Lib/concurrent/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "fafdca7e7677eba5c7d35f11a9048860219e2469fb79803f30a1f6146aa0060a", + "size_in_bytes": 135 + }, + { + "_path": "Lib/concurrent/futures/__init__.py", + "path_type": "hardlink", + "sha256": "9bcec785db3eddc6d462883957ba6d3ff4370501fece505101444bae542883e8", + "size_in_bytes": 1558 + }, + { + "_path": "Lib/concurrent/futures/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "28b287505224c6288a5a48e61501e35900e5100402f2b59d8c933a87aa414b71", + "size_in_bytes": 1441 + }, + { + "_path": "Lib/concurrent/futures/__pycache__/_base.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b60a74fe0593ea348650971d66e815d7b8b6bccd63a6fb6821f18e9215c81c0f", + "size_in_bytes": 37234 + }, + { + "_path": "Lib/concurrent/futures/__pycache__/process.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c8d1d7205ed5eaf0eab7d317e690bb8bd02c2b1bf11e30fd3331fe6f5bf1b704", + "size_in_bytes": 38075 + }, + { + "_path": "Lib/concurrent/futures/__pycache__/thread.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "443d36bbdb2c278c1be972269ae2b5979238af1f1d95147d61906334314b717c", + "size_in_bytes": 11054 + }, + { + "_path": "Lib/concurrent/futures/_base.py", + "path_type": "hardlink", + "sha256": "8c6d5f09f7c535d40fa1c30ebfcb35e0601c2abf32286a82cf151af7ddf72473", + "size_in_bytes": 22833 + }, + { + "_path": "Lib/concurrent/futures/process.py", + "path_type": "hardlink", + "sha256": "2869b759c29c3192b7bc057b354994640274b9daabb1b04eaa0d5611e67a1eeb", + "size_in_bytes": 35479 + }, + { + "_path": "Lib/concurrent/futures/thread.py", + "path_type": "hardlink", + "sha256": "b06f8899881193efc72cfc3ebf2836dce4e668b3856ad35f4016616d643a519e", + "size_in_bytes": 8771 + }, + { + "_path": "Lib/configparser.py", + "path_type": "hardlink", + "sha256": "230b09836340e7c66765f14c36de250f3f67fe427849c6dca6714db65abb5a49", + "size_in_bytes": 55660 + }, + { + "_path": "Lib/contextlib.py", + "path_type": "hardlink", + "sha256": "d732c045bc7450997f97b2f79cfdb1546b68d2655e89ab3170f3b19b3930d83c", + "size_in_bytes": 27414 + }, + { + "_path": "Lib/contextvars.py", + "path_type": "hardlink", + "sha256": "5ed260be8d1f4fe92261b7810b4bb1e8539c42093d7493f677d076e1a87f459a", + "size_in_bytes": 129 + }, + { + "_path": "Lib/copy.py", + "path_type": "hardlink", + "sha256": "27dcfc53a4b9d4fbc3d90c74e549eb6eca9301524d6d2fbff9a6589cf51b6fd5", + "size_in_bytes": 8681 + }, + { + "_path": "Lib/copyreg.py", + "path_type": "hardlink", + "sha256": "5499e1be7ba52d4715a911ae65ef2d703db9379d21fff2a07fad8877c318e070", + "size_in_bytes": 7677 + }, + { + "_path": "Lib/crypt.py", + "path_type": "hardlink", + "sha256": "208df2ff33c19056345dcf5474abef1a58da799e2f3bab09d1d28b77ad3c623d", + "size_in_bytes": 3913 + }, + { + "_path": "Lib/csv.py", + "path_type": "hardlink", + "sha256": "6c68a5186e3b85e6e267a7ef96479327a45ae2b40bf5e9f2017e4b2282b3f5b1", + "size_in_bytes": 16030 + }, + { + "_path": "Lib/ctypes/__init__.py", + "path_type": "hardlink", + "sha256": "608671c6b49e5e027e3348fcf492718c33f69f919d99f4ff170522c40bd4c550", + "size_in_bytes": 17844 + }, + { + "_path": "Lib/ctypes/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8ba7f1c143daa2b1d4204749f52d17c67bd0de73d167dad4e9c93d0eb0ec810b", + "size_in_bytes": 26783 + }, + { + "_path": "Lib/ctypes/__pycache__/_aix.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0ed655f0108f869b34e34ce9752d9af0bed53bbe6f37fc7e1ee33e398fe7a550", + "size_in_bytes": 13199 + }, + { + "_path": "Lib/ctypes/__pycache__/_endian.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c519e5806c3de80b1f19e1eeda6677c3bef5d479bf306d8fe005ed31efab03f8", + "size_in_bytes": 3988 + }, + { + "_path": "Lib/ctypes/__pycache__/util.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6da208e8bdae84d3d23c965862aff7254f8cc6b784cc4aeb5e60d6899e464459", + "size_in_bytes": 19734 + }, + { + "_path": "Lib/ctypes/__pycache__/wintypes.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "99f59d00f56825daadd402f1cca6cd4cfd369d787c9ebe7af76a84773e667303", + "size_in_bytes": 8415 + }, + { + "_path": "Lib/ctypes/_aix.py", + "path_type": "hardlink", + "sha256": "3aaaa326d9c45e115d87e9e52874b1acd766cb4c578cecad667177d50849034c", + "size_in_bytes": 12575 + }, + { + "_path": "Lib/ctypes/_endian.py", + "path_type": "hardlink", + "sha256": "38dc998ee2d180a64d4fe561b79287b19850df405f48fe72dede7a65d71de844", + "size_in_bytes": 2536 + }, + { + "_path": "Lib/ctypes/macholib/README.ctypes", + "path_type": "hardlink", + "sha256": "dc29d1da83b6a0a09a41647e4111eee878ed079c2d6b54a98fd6d8b88dd581f2", + "size_in_bytes": 296 + }, + { + "_path": "Lib/ctypes/macholib/__init__.py", + "path_type": "hardlink", + "sha256": "1e77c01eec8f167ed10b754f153c0c743c8e5196ae9c81dffc08f129ab56dbfd", + "size_in_bytes": 154 + }, + { + "_path": "Lib/ctypes/macholib/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "517c4387e6bf61758bf9c8333d52584e8d606c4b5f3af7f9e59af49ae39a9d5a", + "size_in_bytes": 311 + }, + { + "_path": "Lib/ctypes/macholib/__pycache__/dyld.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b33035c01b8641c3d02d4a4f30f6cad084de0faf158e9e079138d512087baf50", + "size_in_bytes": 7836 + }, + { + "_path": "Lib/ctypes/macholib/__pycache__/dylib.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6977396edfe17d5c3f53b645647a7d2eadf13d178956158e1c561344cbf3995c", + "size_in_bytes": 1328 + }, + { + "_path": "Lib/ctypes/macholib/__pycache__/framework.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "18da335dda10eb729c56e5ac6b091674130206714cdf809f701f12511aa45fd5", + "size_in_bytes": 1458 + }, + { + "_path": "Lib/ctypes/macholib/dyld.py", + "path_type": "hardlink", + "sha256": "f43f287127958d63815859486720c9a703ed9dd2371261e74e88cf7d9c45a2cd", + "size_in_bytes": 5156 + }, + { + "_path": "Lib/ctypes/macholib/dylib.py", + "path_type": "hardlink", + "sha256": "f19ee056b18165cc6735efab0b4ca3508be9405b9646c38113316c15e8278a6f", + "size_in_bytes": 960 + }, + { + "_path": "Lib/ctypes/macholib/fetch_macholib", + "path_type": "hardlink", + "sha256": "a9f6faacdb1aa00ac2f68043cd445171de9639a732b861bd5e64090a2865ab23", + "size_in_bytes": 84 + }, + { + "_path": "Lib/ctypes/macholib/fetch_macholib.bat", + "path_type": "hardlink", + "sha256": "7497fbdbb98afca4ac455e3a057c59bcdebaf1280e25c94741dc301f05cb53e5", + "size_in_bytes": 75 + }, + { + "_path": "Lib/ctypes/macholib/framework.py", + "path_type": "hardlink", + "sha256": "302439e40d9cbdd61b8b7cffd0b7e1278a6811b635044ee366a36e0d991f62da", + "size_in_bytes": 1105 + }, + { + "_path": "Lib/ctypes/test/__init__.py", + "path_type": "hardlink", + "sha256": "02f18a8cc5caa4e9cc32a0767d767a6b5aa23b521d680413b41ff441ef80dbb6", + "size_in_bytes": 445 + }, + { + "_path": "Lib/ctypes/test/__main__.py", + "path_type": "hardlink", + "sha256": "3585b4340e0d39d24b3b462a52f70df216ed6a0838334e5108843ce6900210e6", + "size_in_bytes": 68 + }, + { + "_path": "Lib/ctypes/test/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e5456d1df473188be5a926c3d3cc25f9e51484ac0041a1de002cb889e8771444", + "size_in_bytes": 1059 + }, + { + "_path": "Lib/ctypes/test/__pycache__/__main__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6b3c45d313d2d1aa9ea5f00dba42e61aef7579cdec880dc57103f0dc27ffc916", + "size_in_bytes": 270 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_anon.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1a6f191b3f3f8523cdac4229c24aa7dc37b19b5d7a3246e3868654bfc1b86f29", + "size_in_bytes": 5511 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_array_in_pointer.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "04ce39bf55382093feb1acac5fe37f97211fb22208060f6e558abacfa3134144", + "size_in_bytes": 3536 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_arrays.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d2d5a4915bc2c95f9de5c444b7f97757d539d1b2cc5d4c15de777e65571479de", + "size_in_bytes": 19574 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_as_parameter.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c5ef014e4ad8ddbc561972cfeb79efa08d5c7ae967452d296a6c6cb616e46d38", + "size_in_bytes": 14894 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_bitfields.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d5ea6a0003573f5fe20ce4bf6203eeea392bc7716108063ea585110e56c7c05d", + "size_in_bytes": 22346 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_buffers.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "bc38fcfb0ab1a0a08b1813d3ad038177f1de9756b8b35f934a18ebf1d4dcd707", + "size_in_bytes": 6773 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_bytes.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1a0a5536f851e7166fbb43d238091498006fd60da783059d5b7c25dabdd7c38a", + "size_in_bytes": 5654 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_byteswap.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d6612edcc08a18179155715cc1d2531a1428224896a2cc68117621d8df8e666e", + "size_in_bytes": 24725 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_callbacks.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e9d91f083a961994f3110f13a04a011e41d59aa3785c35f4ba0f6da022a6d92b", + "size_in_bytes": 21506 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_cast.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a13dfb15fa65b49163058520cf3a10164ffbed3650caabc0d095575fe203f23a", + "size_in_bytes": 9083 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_cfuncs.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "32c269de8e5aec47952b0ddc488cc1f2fbc2da379649c577b69eabfaca396566", + "size_in_bytes": 19209 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_checkretval.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "86db638a34506a26a97ca5210990a0b7ddc71fd066bf5b6874b705fb17f5d80d", + "size_in_bytes": 2368 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_delattr.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3a30a4f4549df7fc4a0f729ff5a3f2b506b1d67ad949d0e18c9dec338306566f", + "size_in_bytes": 1730 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_errno.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f433d501281dbefccd1facee5868d21bc874ea74600fc3f2e13c5ba4a4b216fb", + "size_in_bytes": 4659 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_find.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "00296f0743b5b2f501f42867f3f6f4bd78fd7491edf76eda87d2cc8ee8244744", + "size_in_bytes": 9294 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_frombuffer.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4cf75c48593ef114e0d7405116a515a257d5a756f939787747d4d5685f54ee95", + "size_in_bytes": 14104 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_funcptr.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0305761b75e0ccaaa5e3ed8438929c103f8de50fa5e885904c2bef0f5713e536", + "size_in_bytes": 6780 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_functions.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "40a7b0d6e34913bd6d94a2bf0153a26aed94a4cf7faeef5d6c701a643c9578d1", + "size_in_bytes": 23826 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_incomplete.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e6f4cb3e7f82d244af3c0bde90617a62451a75c585ab19e822bf8666945f5c98", + "size_in_bytes": 1878 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_init.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "95216eee4cad8a40cad0b5b0d7e3667c0214ba0a2441cc64023f5747d4877548", + "size_in_bytes": 2496 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_internals.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0b61ec17f9457499c584019f1a502800900632edc1f37a4073320deda06c92f6", + "size_in_bytes": 5773 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_keeprefs.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d76ae388858f47ae7cab3b68e32a6eca35d59582a88d39e91ec57b4b024bfb3e", + "size_in_bytes": 8231 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_libc.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1a3439697abd27bddb57a002448c67399b52644b1df0251b695d2c0178a1fba7", + "size_in_bytes": 2697 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_loading.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "51804af5008d2d6ff6ad5cedc069b47c454a68deef9567c094b3ac08641ad27b", + "size_in_bytes": 10618 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_macholib.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "72a441eba2c865afca8889783a70548878aeb0715716c76a7cee68b1ff37b43f", + "size_in_bytes": 6153 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_memfunctions.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ea667349015467dc9991ff53a07da4731a4f5f0e71326bc0ee0d2436da1ea820", + "size_in_bytes": 6745 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_numbers.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "db02ef6436e76a7db67b26195438522904f0ef4b58f69cd8b803b5a633e71b32", + "size_in_bytes": 14120 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_objects.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "bfd2a8ef82309ae36e87ed831bc0d3bed7022bb0b67970a5d3f71133d9518ee6", + "size_in_bytes": 2417 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_parameters.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ee03d8e82daab3d029989e6ed73323960070c9a3bf79e57a3161a1e9bd785859", + "size_in_bytes": 23514 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_pep3118.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d986bab741f9b3e723cdd5c26873394b197458efb6680c878e16b0ec2b2cbbf9", + "size_in_bytes": 10366 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_pickling.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "88b338bed126e72d12aae5549e535323a6235490a72965b79d69e4d75fcfe758", + "size_in_bytes": 5522 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_pointers.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "fc822cda3d449d5b08c21a251d4968b066d949a7472924e19509fbc97a17eb36", + "size_in_bytes": 12898 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_prototypes.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7fd87fe10e35cd17377e42104367d4287d5b90141cba268152a759635d9712d6", + "size_in_bytes": 13752 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_python_api.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2163f5deae09c7d7693bc9ec1875f14983d1cb6bb4d7977a7a8e5e930e38a39e", + "size_in_bytes": 5474 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_random_things.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "02db0a6ee5bf0c34ce341a02658c7a1a9d15ccc16494483d257a002f73d289c8", + "size_in_bytes": 5785 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_refcounts.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0e867fa001ae25bf54fa85c54e4323f49f0bd0fcfdc24d8e5b1cb372e82e263b", + "size_in_bytes": 6194 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_repr.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0e28cafb961ba11289b7b8874af2f168f967278b2a2ddcd41cf6e63cd3e6a515", + "size_in_bytes": 2381 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_returnfuncptrs.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7a89d208c680df702daecae82cba6c3583101ef6ce42f4af28ca3bc5039aa511", + "size_in_bytes": 4965 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_simplesubclasses.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "73df5da688bc358ea33b515fbf097b7cace9564137be2cda0825dcca28055ffc", + "size_in_bytes": 3855 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_sizes.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "40e1a51120972624c77d718d4bf7423e791ac7cfaf01254b20c4bd71cd2f87b5", + "size_in_bytes": 2621 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_slicing.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8470e95527010f2d5e1f779bdd2b92b7ba796cc85ca2d27eb0228fe9084f6c94", + "size_in_bytes": 13780 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_stringptr.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6e9979c40df29c46b44bf6b8586537bb9a556484105668f39734215599ef74b6", + "size_in_bytes": 4383 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_strings.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3d54505c24bcb5c27f6638b5a78553062d3445db3e5ce314b8a7aec877807eec", + "size_in_bytes": 9082 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_struct_fields.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "fa2426239d629c4c580193f4fdefcea6d62336d4ffb696a9d1770cb6e49fea70", + "size_in_bytes": 8043 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_structures.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "700ee74ed1d5c028735cf08cff21efa212fdede99e54c1234f08004359fb5497", + "size_in_bytes": 62190 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_unaligned_structures.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "62ddb851a97da0a3b715e3ee272d6ff47f1c88afc1ff92fc851aaab550916d09", + "size_in_bytes": 2498 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_unicode.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "46bea76ed11f4ba312f4b18a410b531d0cd8e3cc876fcf2af8d256d848fd575a", + "size_in_bytes": 4998 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_values.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6e4da9b283f0c3acb58a808011aefcb8bace4d34d1546fb5977a53649d33cbd4", + "size_in_bytes": 6368 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_varsize_struct.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8df53b6c4232d692a4e81005f14e3c09da5f86da41462b28f123616259c8073c", + "size_in_bytes": 4152 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_win32.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "378f0e14a7e16e3279c59e014f5cc2f2aa98365e4f29818d496b1e7afaf5b3af", + "size_in_bytes": 10231 + }, + { + "_path": "Lib/ctypes/test/__pycache__/test_wintypes.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "480505cf944aa1879b786e122cbed2813f1ac6eb75f57da3e528775d806487af", + "size_in_bytes": 2516 + }, + { + "_path": "Lib/ctypes/test/test_anon.py", + "path_type": "hardlink", + "sha256": "a3433340dc3c9e058b312e079007e9475c72d4bf3e6fc1a2c1b058db8f289b51", + "size_in_bytes": 2540 + }, + { + "_path": "Lib/ctypes/test/test_array_in_pointer.py", + "path_type": "hardlink", + "sha256": "d8ac27a86f8a8f64d1b152635e6ecd0469ddbf5dadd29870a0f969538ec5cbbc", + "size_in_bytes": 1738 + }, + { + "_path": "Lib/ctypes/test/test_arrays.py", + "path_type": "hardlink", + "sha256": "ef36509ff0bfe7fa40b5c54530d363910836efd57ef223eafa22892d583d3cde", + "size_in_bytes": 7510 + }, + { + "_path": "Lib/ctypes/test/test_as_parameter.py", + "path_type": "hardlink", + "sha256": "3cc398698242fc89390a4c733853a13df54b4a6aaac338eafd749b6817e5503c", + "size_in_bytes": 7254 + }, + { + "_path": "Lib/ctypes/test/test_bitfields.py", + "path_type": "hardlink", + "sha256": "429bf3b0147217cfbb38bf2a3af976dc3ca4d098f035b2ecb392875debe9d3f7", + "size_in_bytes": 10355 + }, + { + "_path": "Lib/ctypes/test/test_buffers.py", + "path_type": "hardlink", + "sha256": "2822ad12a0057d5dbdd40981f066beae03c1ac0c6f5ab62daac73d53e438218c", + "size_in_bytes": 2611 + }, + { + "_path": "Lib/ctypes/test/test_bytes.py", + "path_type": "hardlink", + "sha256": "09236782d5a0add20328f237ec3c077100029d197aebd224fe4f740c5a8ca6c2", + "size_in_bytes": 1987 + }, + { + "_path": "Lib/ctypes/test/test_byteswap.py", + "path_type": "hardlink", + "sha256": "17eb1541899cfedd2fe54f646e861219d3912f01476bc30f25bd517d8c8b0e43", + "size_in_bytes": 13405 + }, + { + "_path": "Lib/ctypes/test/test_callbacks.py", + "path_type": "hardlink", + "sha256": "f9c7ae72e42356cc46d04f8f940d2625addc9b7084f81df88afaa9b8b0a98f81", + "size_in_bytes": 10629 + }, + { + "_path": "Lib/ctypes/test/test_cast.py", + "path_type": "hardlink", + "sha256": "e274510261c11e92a65d216fe64a3dffc189e0160a61fb01832d919d24c67636", + "size_in_bytes": 3728 + }, + { + "_path": "Lib/ctypes/test/test_cfuncs.py", + "path_type": "hardlink", + "sha256": "179c039dc216126f1af2597c25b14e02c4020257c48052488e1935610250e4c2", + "size_in_bytes": 7872 + }, + { + "_path": "Lib/ctypes/test/test_checkretval.py", + "path_type": "hardlink", + "sha256": "2e67c91fbd2ee5085909cec073fa4c97b7b4cfc0655e6034f5a3fb5a9ef6425d", + "size_in_bytes": 968 + }, + { + "_path": "Lib/ctypes/test/test_delattr.py", + "path_type": "hardlink", + "sha256": "90df922b1ebfa25185ccf01b3d22b82365986e4f45cae5499700e7ce54a4f695", + "size_in_bytes": 533 + }, + { + "_path": "Lib/ctypes/test/test_errno.py", + "path_type": "hardlink", + "sha256": "76ca89b1f53e9174c99f1230ea2a1c52607565c7eff5a612a00e0fc117dde111", + "size_in_bytes": 2171 + }, + { + "_path": "Lib/ctypes/test/test_find.py", + "path_type": "hardlink", + "sha256": "06756b01386113d03607575da952edf4a8e525564cd2d2b888cb997f4e868ef8", + "size_in_bytes": 4538 + }, + { + "_path": "Lib/ctypes/test/test_frombuffer.py", + "path_type": "hardlink", + "sha256": "d04ea0d55ac445635b331a4fccef38e9424e788495c360fe1da317c4f7b6a096", + "size_in_bytes": 5215 + }, + { + "_path": "Lib/ctypes/test/test_funcptr.py", + "path_type": "hardlink", + "sha256": "b41f2fdd13b3f4d8548a2f0b7e5d561c2e49f86e4df8107acb6a6b2ef421460f", + "size_in_bytes": 4026 + }, + { + "_path": "Lib/ctypes/test/test_functions.py", + "path_type": "hardlink", + "sha256": "0c337b50eb4af556e38471e33baae2c4b1fa1cf139d99eafe2ab83a30186d635", + "size_in_bytes": 12315 + }, + { + "_path": "Lib/ctypes/test/test_incomplete.py", + "path_type": "hardlink", + "sha256": "c66cb5a68165fd7e158d573adf12c2672d086d4b4e15515aaba654a45855f7c4", + "size_in_bytes": 1023 + }, + { + "_path": "Lib/ctypes/test/test_init.py", + "path_type": "hardlink", + "sha256": "1a23fe2e684f4fca33991b0b65e02a5959d045b59906bf3e2557a7f777f1def3", + "size_in_bytes": 1039 + }, + { + "_path": "Lib/ctypes/test/test_internals.py", + "path_type": "hardlink", + "sha256": "dc891b5d617d2a261527acfc1749ff8c402601f8bdc90f486ab6bfed45a0371f", + "size_in_bytes": 2631 + }, + { + "_path": "Lib/ctypes/test/test_keeprefs.py", + "path_type": "hardlink", + "sha256": "17ebefa675796e8d7fb222955be13e8f1f430ec9f33117dc1fce6809376f0807", + "size_in_bytes": 3260 + }, + { + "_path": "Lib/ctypes/test/test_libc.py", + "path_type": "hardlink", + "sha256": "f2694dc3211773272d31fdd1f0c27bf31e09adf9a7fd9ac42e4264e5bc26b3b3", + "size_in_bytes": 1005 + }, + { + "_path": "Lib/ctypes/test/test_loading.py", + "path_type": "hardlink", + "sha256": "68f54a8965d254a46bd3f03e08e4b8ceeeb930613402357182c9fddc12bc6d11", + "size_in_bytes": 7271 + }, + { + "_path": "Lib/ctypes/test/test_macholib.py", + "path_type": "hardlink", + "sha256": "8f1fc4ef9cfa4ad7dedb5560aa6437d210f15bdd6fe1b548358dae2177e46866", + "size_in_bytes": 4559 + }, + { + "_path": "Lib/ctypes/test/test_memfunctions.py", + "path_type": "hardlink", + "sha256": "a723bfe187ec350b1c8d3cf1f8e7df3ca83a274b513b472a1833df6adf0a5420", + "size_in_bytes": 3293 + }, + { + "_path": "Lib/ctypes/test/test_numbers.py", + "path_type": "hardlink", + "sha256": "fc62b6913a5f53038c69fdcefc7b7f6b5adba12de9f92fb094590167c377e945", + "size_in_bytes": 7265 + }, + { + "_path": "Lib/ctypes/test/test_objects.py", + "path_type": "hardlink", + "sha256": "b67b1cdcd568480e515eae06293d0d71dae3d2e4f0ad612cbe439673a84c164b", + "size_in_bytes": 1677 + }, + { + "_path": "Lib/ctypes/test/test_parameters.py", + "path_type": "hardlink", + "sha256": "4614acd04478abfca4d4d685413cff7897571461f90d68f4c0ef60e4b8376a85", + "size_in_bytes": 11066 + }, + { + "_path": "Lib/ctypes/test/test_pep3118.py", + "path_type": "hardlink", + "sha256": "1e6bbf69f91736b21b68b66c5edc609fd32a364fe0c7ec32b0072c97d44dd0e8", + "size_in_bytes": 8681 + }, + { + "_path": "Lib/ctypes/test/test_pickling.py", + "path_type": "hardlink", + "sha256": "dac8e7f56da15fa162371b43c851d70844922c97c6d9908f5ad0fc3586aa4cd8", + "size_in_bytes": 2218 + }, + { + "_path": "Lib/ctypes/test/test_pointers.py", + "path_type": "hardlink", + "sha256": "a82abf64174a8a572271a3e85d7cf31317aff8036928d7503ee5c786ffbcd1fc", + "size_in_bytes": 7239 + }, + { + "_path": "Lib/ctypes/test/test_prototypes.py", + "path_type": "hardlink", + "sha256": "bfdfb53c8cbae9a464105c4a3f38389c7721c9d1fd0333103b86e7c8071c9db2", + "size_in_bytes": 6845 + }, + { + "_path": "Lib/ctypes/test/test_python_api.py", + "path_type": "hardlink", + "sha256": "363cf3a39d434bb1fdecfe4d8e872db161e5b11e5262eb8ae66a0acdc73fb720", + "size_in_bytes": 2768 + }, + { + "_path": "Lib/ctypes/test/test_random_things.py", + "path_type": "hardlink", + "sha256": "0368da32f76a4c106cbeba3c92456947fbc68d1b012bc3762db1b5f9399e7be6", + "size_in_bytes": 2836 + }, + { + "_path": "Lib/ctypes/test/test_refcounts.py", + "path_type": "hardlink", + "sha256": "6b83ffa7aabe4a8a0b3fe98cbc1f6aaa31253b24f8db4e58304fdccf26ce85a5", + "size_in_bytes": 3138 + }, + { + "_path": "Lib/ctypes/test/test_repr.py", + "path_type": "hardlink", + "sha256": "a89661e8555d05531985619fa54a16eccda0e15e50bc11dcc6ee9df9b3c590cd", + "size_in_bytes": 842 + }, + { + "_path": "Lib/ctypes/test/test_returnfuncptrs.py", + "path_type": "hardlink", + "sha256": "c2f3c65d439622b1f44ba6cb54a14bfb9bb9fec4a1ca47a930f067c307f32481", + "size_in_bytes": 2893 + }, + { + "_path": "Lib/ctypes/test/test_simplesubclasses.py", + "path_type": "hardlink", + "sha256": "a1f30fe454d29ec7d61e9aff7c02bca3072ab2dede632a98e0d68985b025d402", + "size_in_bytes": 1289 + }, + { + "_path": "Lib/ctypes/test/test_sizes.py", + "path_type": "hardlink", + "sha256": "ebebf011281a5c1fb7f76ccc40aad2da2aafdc96e6360e8c5f5e62d0c56d11bd", + "size_in_bytes": 804 + }, + { + "_path": "Lib/ctypes/test/test_slicing.py", + "path_type": "hardlink", + "sha256": "f743c7b22a0dc8b4927a6d6ddba218bbe5e954f0d9f7089fdc4e00d6378a1c2d", + "size_in_bytes": 6025 + }, + { + "_path": "Lib/ctypes/test/test_stringptr.py", + "path_type": "hardlink", + "sha256": "76c576c3fab33e040af706bfa799e42fd67fd82457af7627ebcf642a42b83b54", + "size_in_bytes": 2598 + }, + { + "_path": "Lib/ctypes/test/test_strings.py", + "path_type": "hardlink", + "sha256": "af1b542db2d36f2c39f053cd14e5f1b1253f220c0ff75869ea2382a75bcd2d4a", + "size_in_bytes": 4390 + }, + { + "_path": "Lib/ctypes/test/test_struct_fields.py", + "path_type": "hardlink", + "sha256": "95a245420d9e20c76a8278426bffa63062a73de8257629a0b4f419bbc3fe0b53", + "size_in_bytes": 3151 + }, + { + "_path": "Lib/ctypes/test/test_structures.py", + "path_type": "hardlink", + "sha256": "7c952bfa8db305cdca1047e22c74594123daf686ba22a898776cefc947a0a56f", + "size_in_bytes": 31688 + }, + { + "_path": "Lib/ctypes/test/test_unaligned_structures.py", + "path_type": "hardlink", + "sha256": "0c15a8e79b9fe5edfb0df4be28827dc628a32a9dc948297e16dbf183583bd453", + "size_in_bytes": 1140 + }, + { + "_path": "Lib/ctypes/test/test_unicode.py", + "path_type": "hardlink", + "sha256": "0d385d2cc2fa54d7063531169cc49c4105aa1463e54e298afcbc2f9ddb8f2675", + "size_in_bytes": 1997 + }, + { + "_path": "Lib/ctypes/test/test_values.py", + "path_type": "hardlink", + "sha256": "ee04846c7ef611bdf1c21cf9ac9ccf44fe55f4757c32db0c18ff0deeb58d6f6e", + "size_in_bytes": 4126 + }, + { + "_path": "Lib/ctypes/test/test_varsize_struct.py", + "path_type": "hardlink", + "sha256": "c7d463aa0ee94baa8aab42a1e7c53a9b5547110fffd1a85c30acc0a952bcb216", + "size_in_bytes": 1842 + }, + { + "_path": "Lib/ctypes/test/test_win32.py", + "path_type": "hardlink", + "sha256": "05490ad5f19e2919a1dedda2a7ddb4a77389cf78f56293c97fc1343724690ac2", + "size_in_bytes": 5027 + }, + { + "_path": "Lib/ctypes/test/test_wintypes.py", + "path_type": "hardlink", + "sha256": "d535399195f0b6383004f5dfd3bc309b4ff2f249f6cb99080189f7d7e55c4ef5", + "size_in_bytes": 1397 + }, + { + "_path": "Lib/ctypes/util.py", + "path_type": "hardlink", + "sha256": "3aea57d2573b9c35893a16ef85074cbb3472b749309a0098cdde20be71f8a8c2", + "size_in_bytes": 14964 + }, + { + "_path": "Lib/ctypes/wintypes.py", + "path_type": "hardlink", + "sha256": "c8f29e6cb1b05223e423391242f671381546130acae1fd7baafb65ba849f2a00", + "size_in_bytes": 5628 + }, + { + "_path": "Lib/curses/__init__.py", + "path_type": "hardlink", + "sha256": "d8730e360dd00ec046bdd85cae41fe83c907c6ae3716a964158fce8f31ab28b0", + "size_in_bytes": 3369 + }, + { + "_path": "Lib/curses/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "230b811adeed0100c601130599f49770af8f38257ac3fff8471b17f893c540d9", + "size_in_bytes": 3214 + }, + { + "_path": "Lib/curses/__pycache__/ascii.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6ecdde7bc9fa27f3876cf86e00d6ffb894c2b71721a31b20f1b5116d17532ca4", + "size_in_bytes": 5755 + }, + { + "_path": "Lib/curses/__pycache__/has_key.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2cae91193ea693fcd2dd4ed4efd4a3423c412d00788f464a1e30e36fe8c80e7f", + "size_in_bytes": 8689 + }, + { + "_path": "Lib/curses/__pycache__/panel.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "17094079e066618dd823486a4e98bfdc57a9a97756b51c85a417421bdcb13dba", + "size_in_bytes": 244 + }, + { + "_path": "Lib/curses/__pycache__/textpad.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f9c89445cb96cf7766388540eabc16a7ae5c6f695e18596214a4260133f9cf03", + "size_in_bytes": 12149 + }, + { + "_path": "Lib/curses/ascii.py", + "path_type": "hardlink", + "sha256": "cf0137c2143c5e5bea2ccd25bfc61f3a274c5d8fdab3bc4c2c7329412ce7b656", + "size_in_bytes": 2547 + }, + { + "_path": "Lib/curses/has_key.py", + "path_type": "hardlink", + "sha256": "15a052812d9ae80124bb25b3f5b9ffae38e2b03073774e163abf3d773140cfb3", + "size_in_bytes": 5634 + }, + { + "_path": "Lib/curses/panel.py", + "path_type": "hardlink", + "sha256": "13ef404a30da1825a612ca3e453db88c305d45deef4441c4c9e2ef7ee0ef50c7", + "size_in_bytes": 87 + }, + { + "_path": "Lib/curses/textpad.py", + "path_type": "hardlink", + "sha256": "bbc4634b3396bb6aa89f186206b9e236047e443ffd727116f45b537f4dce0759", + "size_in_bytes": 7657 + }, + { + "_path": "Lib/dataclasses.py", + "path_type": "hardlink", + "sha256": "77a41ea9eb35d959781087b72ef5b452218b57b9d8f2d28688d45a40ca7f8a09", + "size_in_bytes": 58472 + }, + { + "_path": "Lib/datetime.py", + "path_type": "hardlink", + "sha256": "cc9bcb0f1c2f44e1a6cd51882979e113e973c2e65ed84b9aaedabb48d47aa356", + "size_in_bytes": 91832 + }, + { + "_path": "Lib/dbm/__init__.py", + "path_type": "hardlink", + "sha256": "389407b292f30c38a334599d2546ca1fea316b038a5252f985bbccfce6c8453b", + "size_in_bytes": 5882 + }, + { + "_path": "Lib/dbm/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "337e12ef36e8a0e9d01f3a29f41f36600b08e3161c5114a23c9645ae725e795c", + "size_in_bytes": 6948 + }, + { + "_path": "Lib/dbm/__pycache__/dumb.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a05e581525e05546af99cba7a08708b36a4f7313830a880bbac66a95ce5e920a", + "size_in_bytes": 14790 + }, + { + "_path": "Lib/dbm/__pycache__/gnu.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "be3c2d8735119e282a034f97850daa94516c347220c6b41725f24348e21a9370", + "size_in_bytes": 218 + }, + { + "_path": "Lib/dbm/__pycache__/ndbm.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c2f5204dcd45f47175c7624cf4e40bd916b99a2240c11234a816a05eec7b81a4", + "size_in_bytes": 217 + }, + { + "_path": "Lib/dbm/dumb.py", + "path_type": "hardlink", + "sha256": "c99202d9eb4e25a023715a1b804c886fdb7d9f957730959bb071a57d607443b5", + "size_in_bytes": 11594 + }, + { + "_path": "Lib/dbm/gnu.py", + "path_type": "hardlink", + "sha256": "36cd4904f50e00c4df4ad9d450b3970e150957425f47c00cf979ba73eff49778", + "size_in_bytes": 72 + }, + { + "_path": "Lib/dbm/ndbm.py", + "path_type": "hardlink", + "sha256": "1bcc2d9b2fad1901f3421a174eeecb5b8ccc6763283b87bbe0705b404c71904b", + "size_in_bytes": 70 + }, + { + "_path": "Lib/decimal.py", + "path_type": "hardlink", + "sha256": "000c00bad31d126b054c6ec7f3e02b27c0f9a4d579f987d3c4f879cee1bacb81", + "size_in_bytes": 320 + }, + { + "_path": "Lib/difflib.py", + "path_type": "hardlink", + "sha256": "0c6afc23568d55b3e9ac914f9c5361e3033e778aa5b58d3cc82835fc5c638679", + "size_in_bytes": 83308 + }, + { + "_path": "Lib/dis.py", + "path_type": "hardlink", + "sha256": "2e8d70c8cd2f4ce1fab5574f4a5ee81f5572d929da00067d14e6f6582356d240", + "size_in_bytes": 28906 + }, + { + "_path": "Lib/distutils/README", + "path_type": "hardlink", + "sha256": "8d19071886238eda514e96a7ab1c17d6d8c26ae628c4ddbc8ecc5329fd9d8000", + "size_in_bytes": 244 + }, + { + "_path": "Lib/distutils/__init__.py", + "path_type": "hardlink", + "sha256": "50c33f1d73f224a50a07f64e29a5e71b86b105a2e61873e7f47dc28a6baa7680", + "size_in_bytes": 541 + }, + { + "_path": "Lib/distutils/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "76207cf207f89756b5f0deecbb52f5dfebb0d6f8791a2a8af90947167789ca3e", + "size_in_bytes": 789 + }, + { + "_path": "Lib/distutils/__pycache__/_msvccompiler.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "31075fea36f9047aee40fb7473e0ac8d874f46edbf6eb4a064dfc18f4ec93cff", + "size_in_bytes": 24648 + }, + { + "_path": "Lib/distutils/__pycache__/archive_util.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "956c15fc6e84e60e94ad721c7f5328c6ea8d4292590b3408a133e674526f9829", + "size_in_bytes": 10632 + }, + { + "_path": "Lib/distutils/__pycache__/bcppcompiler.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d2934e77b5105cca6b1c7819557999dfb62d00902ab31e513e39737928cd39e2", + "size_in_bytes": 13025 + }, + { + "_path": "Lib/distutils/__pycache__/ccompiler.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d99f1bf30a9c5466833784ce06acbb324dde075ff83ed0129f0e77e77ac141d6", + "size_in_bytes": 44579 + }, + { + "_path": "Lib/distutils/__pycache__/cmd.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1e11b5d15080720e41e7dc73559841b600d2d96d30c4562f2f1e26ccee25f33b", + "size_in_bytes": 18765 + }, + { + "_path": "Lib/distutils/__pycache__/config.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "aac6eb308a4ba79a4a9a10212c041c653405554b9e878132d2e0025ca50346b0", + "size_in_bytes": 6351 + }, + { + "_path": "Lib/distutils/__pycache__/core.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "773636432b17363d045fc7ab1ed6170f6bfe28426bbb85d0f1c6040980cdc394", + "size_in_bytes": 9021 + }, + { + "_path": "Lib/distutils/__pycache__/cygwinccompiler.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "77f7f8ebc76550cf8a4f76704c41a6a26cb38abce7ea42d461ebef54df58ed54", + "size_in_bytes": 14179 + }, + { + "_path": "Lib/distutils/__pycache__/debug.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "210552b71f0786148ed741f7a8f3ff9c5334b3f0a1c2429dd68ddf3a6cabd191", + "size_in_bytes": 260 + }, + { + "_path": "Lib/distutils/__pycache__/dep_util.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7b1862afa6aec2781eef8318ebd40c1c8526098ffda5c0572508969f769bbcce", + "size_in_bytes": 3935 + }, + { + "_path": "Lib/distutils/__pycache__/dir_util.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0867376c559b786e561a164accaac074fcefc1a686326db43816a47a0c9b2420", + "size_in_bytes": 10002 + }, + { + "_path": "Lib/distutils/__pycache__/dist.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "29477de5606fcae3d3ffd9c4175109570443e68846b7b0758c75f78a346b577d", + "size_in_bytes": 54712 + }, + { + "_path": "Lib/distutils/__pycache__/errors.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d9dd05cb1fa0619be39d2f0ed33ea47f25b8d7e59fae412f2cdaf69abb34f844", + "size_in_bytes": 6723 + }, + { + "_path": "Lib/distutils/__pycache__/extension.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1c08650d79180b09660390770aa33373fa6ae41524d6370a92c0e0fde5ba6224", + "size_in_bytes": 10123 + }, + { + "_path": "Lib/distutils/__pycache__/fancy_getopt.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7403628bb592de2ce059844152a3d485b389ab207e80540496546dcbe9be18b1", + "size_in_bytes": 17077 + }, + { + "_path": "Lib/distutils/__pycache__/file_util.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f8da9a751091f95feeab624cd96cdc50e1897081237c0b6aeb0e42cbe239de3a", + "size_in_bytes": 10344 + }, + { + "_path": "Lib/distutils/__pycache__/filelist.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c5a678d5ef8265b6b3c54fc68a17d5e914219d2e2421de0d4a745239dfdf670c", + "size_in_bytes": 16139 + }, + { + "_path": "Lib/distutils/__pycache__/log.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "30eb72dd11b04f7c96688ddd5a4e63a95e76e0d2bceded9dee20f1f9ffbe946f", + "size_in_bytes": 3868 + }, + { + "_path": "Lib/distutils/__pycache__/msvc9compiler.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d240dd7d9720d46fea79ca7c1bea380f06853fda79d9c21649ecd7f3df0f1798", + "size_in_bytes": 33132 + }, + { + "_path": "Lib/distutils/__pycache__/msvccompiler.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "cfdf62aae4cfd3d6074327544d5ce03873eda289b6d3cbeaf7926b0b1418dac1", + "size_in_bytes": 26616 + }, + { + "_path": "Lib/distutils/__pycache__/spawn.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7d972eb5199d424400725486234abd39be4c457dedd8cf6864eddcedd93626d6", + "size_in_bytes": 5577 + }, + { + "_path": "Lib/distutils/__pycache__/sysconfig.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "12a711b6bbf18bb47d5232a5e54e0707ec37c574a2a6ac8563c7e5563725c363", + "size_in_bytes": 12236 + }, + { + "_path": "Lib/distutils/__pycache__/text_file.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9490398cdb03c213855e44bb1ccc816ce4612bd87cd24011978cf429043a54fa", + "size_in_bytes": 11474 + }, + { + "_path": "Lib/distutils/__pycache__/unixccompiler.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3666d6e4934d2d506e9711be81b6fd3578f2be5a30a9fbbcd1bb152c58a0322c", + "size_in_bytes": 12749 + }, + { + "_path": "Lib/distutils/__pycache__/util.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7ed516123d59c5f5a05ecc7ccab3f663a0c7acaf55baa6077ee1d4d78ec306d0", + "size_in_bytes": 24645 + }, + { + "_path": "Lib/distutils/__pycache__/version.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0c465460b74326d24ce524f6b9515a2482085b1d9f8bcb4b1e0868eaca8c974e", + "size_in_bytes": 10339 + }, + { + "_path": "Lib/distutils/__pycache__/versionpredicate.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9ce3166b252d45c6b09af952d936e22749f905d1ac5bc552589b7eb8303c469b", + "size_in_bytes": 7189 + }, + { + "_path": "Lib/distutils/_msvccompiler.py", + "path_type": "hardlink", + "sha256": "21c14c94e6015f56b8c28abd8c8f628f33efbdb808a4a26b0deeb31f2d4ca17a", + "size_in_bytes": 20404 + }, + { + "_path": "Lib/distutils/archive_util.py", + "path_type": "hardlink", + "sha256": "a96fae886c187b14ef2b97be8927a5ff7d43b21c7e0aa4da9cd3caeac9f07fdf", + "size_in_bytes": 8572 + }, + { + "_path": "Lib/distutils/bcppcompiler.py", + "path_type": "hardlink", + "sha256": "3890d5a425265fa1fcbffee5575ce27d5d5f731f760abd9d862521ebdf3d5092", + "size_in_bytes": 14894 + }, + { + "_path": "Lib/distutils/ccompiler.py", + "path_type": "hardlink", + "sha256": "194146bc2645bafe0d34d90d6837958779de804b21178b3e1a3da651bbbccffb", + "size_in_bytes": 47418 + }, + { + "_path": "Lib/distutils/cmd.py", + "path_type": "hardlink", + "sha256": "79ca3a2c0194b686cbb8f69fba19a02a09304512ff598f0a27861e0c21e9725b", + "size_in_bytes": 18079 + }, + { + "_path": "Lib/distutils/command/__init__.py", + "path_type": "hardlink", + "sha256": "f0bcde9801fad1d064fee42c8ccbe36eb121cba7b6e4415c40c3ec144217ee37", + "size_in_bytes": 771 + }, + { + "_path": "Lib/distutils/command/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9b99c0a0e1c68c6bbe1e047750d030ab1856090c958751ac1a25ee76bb4b7e3a", + "size_in_bytes": 480 + }, + { + "_path": "Lib/distutils/command/__pycache__/bdist.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6cc63754d8f29161c6fdbe22fae1b9ac658a488210e4fc8f425076736a4a9879", + "size_in_bytes": 5369 + }, + { + "_path": "Lib/distutils/command/__pycache__/bdist_dumb.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "64cace9d54087a8f088c7acce35cf578041028e86d93b655eea745bba4885ab1", + "size_in_bytes": 5673 + }, + { + "_path": "Lib/distutils/command/__pycache__/bdist_rpm.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a0e76bc201f4ffda1fb07d942a5b1528c0d1103d9eb537909a533bf318d65c0f", + "size_in_bytes": 23121 + }, + { + "_path": "Lib/distutils/command/__pycache__/build.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0649ca040c2d3a763e4fd55ba71a815b8c3011d89512fc05e651e0516988f5bb", + "size_in_bytes": 5995 + }, + { + "_path": "Lib/distutils/command/__pycache__/build_clib.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "41076f5b1627ed42b22e832ee5c59ea745cf6eb5ef3a615e7ba900f3eb0bbbd9", + "size_in_bytes": 7748 + }, + { + "_path": "Lib/distutils/command/__pycache__/build_ext.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9def3722a680aed5aa1543c2e4d91f54e6a88d953def8f239fa23184a17173dd", + "size_in_bytes": 30274 + }, + { + "_path": "Lib/distutils/command/__pycache__/build_py.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2d6bce4ab8ccf196e33e27f55f64b8a5279d446c99c3c935c0a4f5007a902e5c", + "size_in_bytes": 19016 + }, + { + "_path": "Lib/distutils/command/__pycache__/build_scripts.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0036a7027253e93cda169a5d88664c34b9d53b9a458ce9c52e3104e1f6601f5a", + "size_in_bytes": 7671 + }, + { + "_path": "Lib/distutils/command/__pycache__/check.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9c7ff7e62b49fb0f7678316440c95c095c8597ef6669557bcab268aad105fc16", + "size_in_bytes": 7875 + }, + { + "_path": "Lib/distutils/command/__pycache__/clean.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "560ae707e8eb169bdc7b398fa6d3c871fd2c1f0763bc6ae7ef86d17763501343", + "size_in_bytes": 3177 + }, + { + "_path": "Lib/distutils/command/__pycache__/config.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8c39f6bc63dfe98223b224f80af5d97c372e6d54cf068d79fe678afb0d4a41f7", + "size_in_bytes": 16184 + }, + { + "_path": "Lib/distutils/command/__pycache__/install.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ce58d9272fcd8cbf2e8c0577f7025c0410b75f328200ab7df2e6ddd749a1236d", + "size_in_bytes": 24231 + }, + { + "_path": "Lib/distutils/command/__pycache__/install_data.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "23317f1a441fb562f72bcedb77d7241a9f712c11bcb1b8f840b2739123eee955", + "size_in_bytes": 3714 + }, + { + "_path": "Lib/distutils/command/__pycache__/install_egg_info.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ad336df534eca3f65e0cc39fa22a4b0c0e1fc0252974f99afcaa304fd1c5fe75", + "size_in_bytes": 4877 + }, + { + "_path": "Lib/distutils/command/__pycache__/install_headers.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e6cce217b82b6b4819da6f1dd57b6f6bbafc0fb4c4aac46e65ff70559ad14ac6", + "size_in_bytes": 2300 + }, + { + "_path": "Lib/distutils/command/__pycache__/install_lib.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0dab6fd2f21bca3d484ab99b0c15bf7e95e359276e4521e8873b73cf0f6ff557", + "size_in_bytes": 8641 + }, + { + "_path": "Lib/distutils/command/__pycache__/install_scripts.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c6e2aa920e09052fc14d6018baf79cdf781441b22e918ae6d3a6a959a7332eab", + "size_in_bytes": 3095 + }, + { + "_path": "Lib/distutils/command/__pycache__/register.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e04cc1a7c58c44150cc8ae18fdf20dd3475fa04c1f147ba40fe2c9c1918042e2", + "size_in_bytes": 15594 + }, + { + "_path": "Lib/distutils/command/__pycache__/sdist.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c7bcabd713e676b68fd70a0a7c9d5b17fce4b00bfa8dbfb1daafb3c748d78c1a", + "size_in_bytes": 23788 + }, + { + "_path": "Lib/distutils/command/__pycache__/upload.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "57b88d12fb14e0c09820bde3fb380213c7a03c050b031483717abdcda8426519", + "size_in_bytes": 10355 + }, + { + "_path": "Lib/distutils/command/bdist.py", + "path_type": "hardlink", + "sha256": "09340ddbef8938d6eed6ddff61f570f1f98c586690cd4f7600f97d626e50f58e", + "size_in_bytes": 5333 + }, + { + "_path": "Lib/distutils/command/bdist_dumb.py", + "path_type": "hardlink", + "sha256": "053babf63708a69c8fecf89abe37ec93b623125aafc5e60eda7a54c8f3ce7a47", + "size_in_bytes": 4913 + }, + { + "_path": "Lib/distutils/command/bdist_rpm.py", + "path_type": "hardlink", + "sha256": "8233b0db61a10d26dcab46ddab6e5c4dbfa7e875969b46d284b41a77f9a42789", + "size_in_bytes": 21537 + }, + { + "_path": "Lib/distutils/command/build.py", + "path_type": "hardlink", + "sha256": "d753724765005336a5ae44d9da98740401c55850b68ed4ac37b808685f8d0b4f", + "size_in_bytes": 5767 + }, + { + "_path": "Lib/distutils/command/build_clib.py", + "path_type": "hardlink", + "sha256": "6e05531e1dbc78b400d86930ebc6a602977f8fba90057e0c4c8fb34ef00afc9e", + "size_in_bytes": 8022 + }, + { + "_path": "Lib/distutils/command/build_ext.py", + "path_type": "hardlink", + "sha256": "b55d5e1bbd431e3f7d42f60be8777a3e761b1221a88c4551c2778d2fa858978e", + "size_in_bytes": 31627 + }, + { + "_path": "Lib/distutils/command/build_py.py", + "path_type": "hardlink", + "sha256": "4bf365c3885913c3e7220a97e4e14c766b7e19298e84f410e1fda3af5b819e85", + "size_in_bytes": 17190 + }, + { + "_path": "Lib/distutils/command/build_scripts.py", + "path_type": "hardlink", + "sha256": "68ac9c2493f1dcb7d9d5cbd981225ac670f62e7bd1339589fbcc64a5d81c2ec2", + "size_in_bytes": 6232 + }, + { + "_path": "Lib/distutils/command/check.py", + "path_type": "hardlink", + "sha256": "81b7e76e7fb8cc716fa4c3dadb0c2e54269d6e1765f61361f0e86a2e790fd6ea", + "size_in_bytes": 5890 + }, + { + "_path": "Lib/distutils/command/clean.py", + "path_type": "hardlink", + "sha256": "d930ade3baeee2165933445f55f5188f96dba6272918b3f8421c398c1b6fa7d9", + "size_in_bytes": 2776 + }, + { + "_path": "Lib/distutils/command/command_template", + "path_type": "hardlink", + "sha256": "7c1c707cd6ad3872515cf3fc9d8dd1a3f7cc08e3eb71813ed427499b256a8751", + "size_in_bytes": 633 + }, + { + "_path": "Lib/distutils/command/config.py", + "path_type": "hardlink", + "sha256": "d9a4e3c30dcfc23301f3e6626c27b83fb07ea86d61335827feb257632c51cfa7", + "size_in_bytes": 13117 + }, + { + "_path": "Lib/distutils/command/install.py", + "path_type": "hardlink", + "sha256": "32b5cd24c6aafcdd73a2835e99f3bdf8c4f53d04de0011b3cb04f786ae60b994", + "size_in_bytes": 28242 + }, + { + "_path": "Lib/distutils/command/install_data.py", + "path_type": "hardlink", + "sha256": "62118e0308778093ea17b7a6e57034ae6a51e36cf56cb87cd28a049730f252f9", + "size_in_bytes": 2822 + }, + { + "_path": "Lib/distutils/command/install_egg_info.py", + "path_type": "hardlink", + "sha256": "d245b496254c79a7648d7d197117cca6d2857a7d3b1b0ea0cb0d551d3e4a2307", + "size_in_bytes": 2603 + }, + { + "_path": "Lib/distutils/command/install_headers.py", + "path_type": "hardlink", + "sha256": "5d0ea27646c80dfaf59635c23b39ee55432f385a47067e9c2b45b3f6020cd9be", + "size_in_bytes": 1298 + }, + { + "_path": "Lib/distutils/command/install_lib.py", + "path_type": "hardlink", + "sha256": "f40a1f47e30ef6502d8f0c2eba40a9b5ea4e68910a3195b65478b2479854ec70", + "size_in_bytes": 8397 + }, + { + "_path": "Lib/distutils/command/install_scripts.py", + "path_type": "hardlink", + "sha256": "fc22d4790c06251718da48a4edaccf327e4876d0c2ae359d52f675921946e9c9", + "size_in_bytes": 2017 + }, + { + "_path": "Lib/distutils/command/register.py", + "path_type": "hardlink", + "sha256": "da36aaf7debcaedda9b91543071d476cd897bf6eee3a4f22744ff894f7ffdd53", + "size_in_bytes": 11712 + }, + { + "_path": "Lib/distutils/command/sdist.py", + "path_type": "hardlink", + "sha256": "aa8b498c03b3ca1263ab6fa80c89a3345aceb5a4a778414325307eb04935c275", + "size_in_bytes": 19005 + }, + { + "_path": "Lib/distutils/command/upload.py", + "path_type": "hardlink", + "sha256": "ed9475fb90f3ef73d98f8f1f40b8637de2767c9c4fca95975b0a2c55164e5b8c", + "size_in_bytes": 7621 + }, + { + "_path": "Lib/distutils/config.py", + "path_type": "hardlink", + "sha256": "941556d79cb5491449fd8241f32bf37c0ab574b331a2e9c8156fe2bb8a0fdb87", + "size_in_bytes": 4951 + }, + { + "_path": "Lib/distutils/core.py", + "path_type": "hardlink", + "sha256": "8db74e92938ad3dc62fb9eaf861c2f9f77d87612dbe4324ef2adcad5f9d0cf44", + "size_in_bytes": 8876 + }, + { + "_path": "Lib/distutils/cygwinccompiler.py", + "path_type": "hardlink", + "sha256": "b75a16168b3210efd52a6b79b47f386da4ea3d86644caaa929a31a1bc25d1f0c", + "size_in_bytes": 16480 + }, + { + "_path": "Lib/distutils/debug.py", + "path_type": "hardlink", + "sha256": "37a32b4c0a8aea5f52564ead5b0791d74f0f33c3a5eea3657f257e9c770b86c6", + "size_in_bytes": 139 + }, + { + "_path": "Lib/distutils/dep_util.py", + "path_type": "hardlink", + "sha256": "1ae47d230fe3cd9464c9e989e475fcac1ff0446c642017019b5aa1e78afbce19", + "size_in_bytes": 3491 + }, + { + "_path": "Lib/distutils/dir_util.py", + "path_type": "hardlink", + "sha256": "5308413944dc57ae464f071ee123ee4d747c67cab72d811c9adb6a7066f46d8a", + "size_in_bytes": 7778 + }, + { + "_path": "Lib/distutils/dist.py", + "path_type": "hardlink", + "sha256": "1e797f81633e34c7993030ac4047b0cd43e49739d40dd03ef262d5c7dd7b17d2", + "size_in_bytes": 50385 + }, + { + "_path": "Lib/distutils/errors.py", + "path_type": "hardlink", + "sha256": "62bead29919dcc1a0d8b9def06d8aad1427ffd7d390a6c5275026a3966b0e926", + "size_in_bytes": 3577 + }, + { + "_path": "Lib/distutils/extension.py", + "path_type": "hardlink", + "sha256": "cfb99f8b891f9e933544d4b0d25a59569e71bbd79320d61ba64e953e6a6f5a58", + "size_in_bytes": 10529 + }, + { + "_path": "Lib/distutils/fancy_getopt.py", + "path_type": "hardlink", + "sha256": "38fc69d82c478b5629fddd43f09c56e147aaf5f0bbd6d7a040569a7e1e7c1865", + "size_in_bytes": 17784 + }, + { + "_path": "Lib/distutils/file_util.py", + "path_type": "hardlink", + "sha256": "d2152a7c8b4dff1d83562851d0c1dd03828231508e3bc568072685a7f6ba3038", + "size_in_bytes": 8148 + }, + { + "_path": "Lib/distutils/filelist.py", + "path_type": "hardlink", + "sha256": "f1b471873a7616c6a81d3ed3b8a0f842372e87f07d3b0ff14edfe1b5926f3764", + "size_in_bytes": 12832 + }, + { + "_path": "Lib/distutils/log.py", + "path_type": "hardlink", + "sha256": "8560667540b62bddbb41c56fdd110c5b71cc3dc97171c3d09e0c4b4ae517425d", + "size_in_bytes": 1969 + }, + { + "_path": "Lib/distutils/msvc9compiler.py", + "path_type": "hardlink", + "sha256": "33d3edc009158d1bf1353165440929e8403935776c16bfaa775f97466f8a8ac3", + "size_in_bytes": 30453 + }, + { + "_path": "Lib/distutils/msvccompiler.py", + "path_type": "hardlink", + "sha256": "4dae9b283df0b4606089d2e442c1f12932a106665701a69fbab64c1ef3181513", + "size_in_bytes": 23527 + }, + { + "_path": "Lib/distutils/spawn.py", + "path_type": "hardlink", + "sha256": "87336cdb85c2f6ecf2c67cd8a43903bf2cf884c218b1661dcc63a52ad96343e7", + "size_in_bytes": 4660 + }, + { + "_path": "Lib/distutils/sysconfig.py", + "path_type": "hardlink", + "sha256": "19956c0b27828e7184664afe1f6f71b92ca3d76b2050a9be2070c9e37807bed9", + "size_in_bytes": 12516 + }, + { + "_path": "Lib/distutils/tests/Setup.sample", + "path_type": "hardlink", + "sha256": "ff839230cf999711c05b9ee030a7e843376aa51190971fd597643508cea7dc74", + "size_in_bytes": 2249 + }, + { + "_path": "Lib/distutils/tests/__init__.py", + "path_type": "hardlink", + "sha256": "d7a73fb311324ec86803495836a5b8c0eb26f651d77fc6df3f2aba4486357ab7", + "size_in_bytes": 1069 + }, + { + "_path": "Lib/distutils/tests/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8ca0113e81b8c5001e07839176707a52e6fee8d8852d849c3c56994b04640f64", + "size_in_bytes": 1877 + }, + { + "_path": "Lib/distutils/tests/__pycache__/support.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "381b3d3bd1c7def0a73feb231aab7ef8041b52af9a9dd1b6076057870feb24f7", + "size_in_bytes": 12021 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_archive_util.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ddd8b1e68c1286abbc9a729422d2a1c1d9fae7e3e4c8a1de45d88309fde9ead8", + "size_in_bytes": 26939 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_bdist.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3ce3d4c6ec985e2ad7439cf21e2eec56da8037dbcc16076b8ed3b21564429445", + "size_in_bytes": 2679 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_bdist_dumb.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ed25939817a781c4308094a4ca4f2f3e1d9d6e4820121b91af26d95a07db9dad", + "size_in_bytes": 5192 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_bdist_rpm.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0afaa2799be9c6bf1ba995a9b040bfed999ffb3bc5c05f23c9d3034fd6bde065", + "size_in_bytes": 7609 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_build.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e51e84e1ba42a7ae2f49a69deae3a6bb81e21a774523788aaf0aaca36fb79585", + "size_in_bytes": 3203 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_build_clib.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "05cee6e7468f78c66c78d6868d952264733d8451912b9cbdf5bde73a2f16d8ad", + "size_in_bytes": 7836 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_build_ext.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "542429711c76af808961c5042cf41d68b58155e250830dce913b927493483433", + "size_in_bytes": 29128 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_build_py.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f66f04b696b1548069e723b4ea9c5f69656159102f7e97c9ae4643dcfd4b1177", + "size_in_bytes": 11164 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_build_scripts.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ca19c1aae7c42444c9e79306ba19db5670f1594db579b072d94ba24f2533723b", + "size_in_bytes": 6043 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_check.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d80ab13642a85799f69a404a225e4e7474113c64a8aeaa81a1ce4332610c1af8", + "size_in_bytes": 7410 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_clean.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "846d246165523592fbd0416102822e5074378f3702ec8e898ccb7fa82ed46cd0", + "size_in_bytes": 2508 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_cmd.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e9e70f215158561000c2c0bb95cb22f4f10d8e1e9ec30c076a35e5070f2cfd78", + "size_in_bytes": 7523 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_config.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "37caa15e68d588cf71ea5fee7183fbfb072c31614ff855e5729cee59202f126d", + "size_in_bytes": 6808 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_config_cmd.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "127885b8fd9b9cab17cdd7217db3a26b3296ffc845d7317d0ef791df31b7dd5c", + "size_in_bytes": 6913 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_core.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "86d5806867a6d103a65a2c6603267c6cee9dfe6b01044a5a72639cb3adc079cc", + "size_in_bytes": 7819 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_cygwinccompiler.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "641b123f949d133052a2d98b1541e49536f47c6074508b398a8a5ce11ced4363", + "size_in_bytes": 7935 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_dep_util.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "094a4810a47d19fad399d1cade315f31fced8efa4be84c6b5d10a8c3b0e8aeca", + "size_in_bytes": 4882 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_dir_util.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9f8d3cbaef81e5f0b93dc2ab64abb36a8a8f3b396125a9d9569df487a8c972db", + "size_in_bytes": 10077 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_dist.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "fd9c9719b367ddd5a2d0b0a771c4b4bd9568818be4f79cc33177f038aab657de", + "size_in_bytes": 32033 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_extension.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f7dde9289e12e10b548e0c3964dea4e4734b56556558b3d4f0cd551a6be0f783", + "size_in_bytes": 4023 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_file_util.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "bf972ebbea30556f430a2786135c77e621c505dff4f76e75f4d53c0663b65781", + "size_in_bytes": 10735 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_filelist.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "989d9c8e23b5215191ddace9afbe38c80874085d2d88749ad4a370975cd7d75f", + "size_in_bytes": 18434 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_install.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "72b4ad0ece8d1b5e8ce9ef3080ed68747de83057dbe48f20c589c2b2ef12b973", + "size_in_bytes": 15838 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_install_data.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5015bf663b3d8aa16074fce136638506c0ff86bf354e7aa6f3e76d7ab4434128", + "size_in_bytes": 4970 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_install_headers.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9b9eac5fee138b747fb583341dc05f4432ce436893fab56c9de7b02b55e91363", + "size_in_bytes": 2223 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_install_lib.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "504996a9a363d04d616db0655da60a603df6181e505f92cfe2300e8b56da2e16", + "size_in_bytes": 6934 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_install_scripts.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ddfe7ed03b1c0d03fa28c18082f9411c1dc68ff1160b56be8ec459fcddfbd293", + "size_in_bytes": 4261 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_log.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "26ff221fb369d603ae78f2da3acda417c4a18e5c53d9ba9a602b64cf86c99e99", + "size_in_bytes": 3190 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_msvc9compiler.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5cf0f1cc0f4e9a2d04b357f032e00157a87468b1903557e91a6cfdf6b7f1a402", + "size_in_bytes": 7863 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_msvccompiler.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6e2e04084ce2291cc62f30cfb6b68870fc8d8fed2e9c3cb9b96d467cbd3c7baa", + "size_in_bytes": 4155 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_register.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "49b698b7c7465b2019e241a76aa0e1adef907bd6c989a65695c72c4730f215a5", + "size_in_bytes": 15555 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_sdist.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9508b92c77af8db5a8a7b2d2f4b06ff003dbd1863f5422a8bc71a5f16495e963", + "size_in_bytes": 27769 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_spawn.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "14ce25c2a75d2e1d5a3205f007659bfc1e0bef1a159333dc8917d223198de712", + "size_in_bytes": 9444 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_sysconfig.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7f12a431980b1f5cb0cd0a9071a3c3059b56eb0f92514ee5700330e5ea42e4b4", + "size_in_bytes": 16130 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_text_file.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "834d84ec5c1a5b13fdc8f9145cbff33b90a8c68a7d51add35dedf1106393ad12", + "size_in_bytes": 4179 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_unixccompiler.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4989cb0cf568f02da84120efb93698babcb1ce039ba95436655a54420f8a08c9", + "size_in_bytes": 8385 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_upload.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b40d80fc5cd1ec96959a803418febe453b8efc5f7659a32623c561b928da7c6d", + "size_in_bytes": 12300 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_util.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2e25ec8cf2a2cdeba038e0acac05643c4a8409cb4b3b10e00f4394383bc5e0ab", + "size_in_bytes": 17292 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_version.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "875786e937d168f823aa3e9ecb85c91365c39cf756b1ccbf0f267aa3c64b0a7f", + "size_in_bytes": 4326 + }, + { + "_path": "Lib/distutils/tests/__pycache__/test_versionpredicate.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "47f867209d9ff4e658c6cd7f52c0d2c22fbadef8be3799cf06debe5e282032e6", + "size_in_bytes": 755 + }, + { + "_path": "Lib/distutils/tests/includetest.rst", + "path_type": "hardlink", + "sha256": "1a766ccac6850b0424118733e2b086803921e0829f98ad0719be671a5da4263c", + "size_in_bytes": 25 + }, + { + "_path": "Lib/distutils/tests/support.py", + "path_type": "hardlink", + "sha256": "f7649fe69f9eae66781747a72550c3743a197608ca6b37d5607930570a804384", + "size_in_bytes": 6490 + }, + { + "_path": "Lib/distutils/tests/test_archive_util.py", + "path_type": "hardlink", + "sha256": "c6ee7c94ed90325f391899fb7c8d384c3710f16d8433c836c6f3155b821aabbd", + "size_in_bytes": 14280 + }, + { + "_path": "Lib/distutils/tests/test_bdist.py", + "path_type": "hardlink", + "sha256": "48a3bc44ce7f1ee96b9512236a940903d916b0556583ff7c325e78b2046a32df", + "size_in_bytes": 1536 + }, + { + "_path": "Lib/distutils/tests/test_bdist_dumb.py", + "path_type": "hardlink", + "sha256": "ea1688b5a617891f446f562b853c9e21c734af9e90ada74f29a5ad99f8534a46", + "size_in_bytes": 2788 + }, + { + "_path": "Lib/distutils/tests/test_bdist_rpm.py", + "path_type": "hardlink", + "sha256": "398dd4cb89e1165a26560c398e9b1e02556642bdec69e857bd80ab73a46f98b4", + "size_in_bytes": 5208 + }, + { + "_path": "Lib/distutils/tests/test_build.py", + "path_type": "hardlink", + "sha256": "af0bdca3ec537bfb43f1e8e5e3615ba01a67c908b156b2a58fcb2a422e68a146", + "size_in_bytes": 1925 + }, + { + "_path": "Lib/distutils/tests/test_build_clib.py", + "path_type": "hardlink", + "sha256": "877302073d1dcf478e943016cebe0466645fa739e5d2d8bbc8e180d8182f9a42", + "size_in_bytes": 4876 + }, + { + "_path": "Lib/distutils/tests/test_build_ext.py", + "path_type": "hardlink", + "sha256": "c0b6d8c36c52290099faa520667dfd54cdef243ba7e906ee1ae8b2d0bac4a1e6", + "size_in_bytes": 20700 + }, + { + "_path": "Lib/distutils/tests/test_build_py.py", + "path_type": "hardlink", + "sha256": "4d6af717c108af133de24799fc966b5dad4b13b2bb4439aa7da7b532c15d6423", + "size_in_bytes": 6319 + }, + { + "_path": "Lib/distutils/tests/test_build_scripts.py", + "path_type": "hardlink", + "sha256": "2765139f7cba3941390ab92c6421e6363c47cdc5eaab207bca4fd1268a3145f3", + "size_in_bytes": 3473 + }, + { + "_path": "Lib/distutils/tests/test_check.py", + "path_type": "hardlink", + "sha256": "2e63a330b269219bb5b570b4f4b34fb89cbc1f8d4166becf390bc03aa705d0b4", + "size_in_bytes": 5598 + }, + { + "_path": "Lib/distutils/tests/test_clean.py", + "path_type": "hardlink", + "sha256": "d404e3645f256f7e42ea6f26a1ef8f68795b44b5bbc929b279cd50317220c22c", + "size_in_bytes": 1328 + }, + { + "_path": "Lib/distutils/tests/test_cmd.py", + "path_type": "hardlink", + "sha256": "eb46ee5fca289f6d70c2772ed0d88aa1609a41959e17238107b122f018dc5f04", + "size_in_bytes": 3744 + }, + { + "_path": "Lib/distutils/tests/test_config.py", + "path_type": "hardlink", + "sha256": "225627acf67e0b06702c169e641334b2d82652b77f81fdb5cb31ab5e7b2870e5", + "size_in_bytes": 3771 + }, + { + "_path": "Lib/distutils/tests/test_config_cmd.py", + "path_type": "hardlink", + "sha256": "355f66eb9848788c3c43d7945bc61c834b2b0d5a1968d7df90f87749a07ccafe", + "size_in_bytes": 3165 + }, + { + "_path": "Lib/distutils/tests/test_core.py", + "path_type": "hardlink", + "sha256": "1c217017067411a4995eab5acb7caf6171ca5fb9a8ea0ff3d837e38b07d08aa3", + "size_in_bytes": 3992 + }, + { + "_path": "Lib/distutils/tests/test_cygwinccompiler.py", + "path_type": "hardlink", + "sha256": "746b5c518b3fbd20e5565c62b511b9d6c83a78e6f71bf292ea9f2d5bb5803522", + "size_in_bytes": 5513 + }, + { + "_path": "Lib/distutils/tests/test_dep_util.py", + "path_type": "hardlink", + "sha256": "6afe6786f553c28204287b5cad74dbee496c64afbfb8543fbe568de358ab288a", + "size_in_bytes": 2705 + }, + { + "_path": "Lib/distutils/tests/test_dir_util.py", + "path_type": "hardlink", + "sha256": "35fae97d151c1e15b918e7ae063ded2de9f5813eea69a55c3f385c8961822fd3", + "size_in_bytes": 4696 + }, + { + "_path": "Lib/distutils/tests/test_dist.py", + "path_type": "hardlink", + "sha256": "148982302c49fdb330615330a140cd7527a9f3ded01f9ca3922df39e898dabe9", + "size_in_bytes": 18904 + }, + { + "_path": "Lib/distutils/tests/test_extension.py", + "path_type": "hardlink", + "sha256": "cdea6a3ff43e6fcc993f4a1335ee4aa96f13795d3b24ff3265611f8836669d68", + "size_in_bytes": 2691 + }, + { + "_path": "Lib/distutils/tests/test_file_util.py", + "path_type": "hardlink", + "sha256": "ba6bbb298c8d61aeada89ccfade63299640776f918b8274115d927ea22bb894c", + "size_in_bytes": 4464 + }, + { + "_path": "Lib/distutils/tests/test_filelist.py", + "path_type": "hardlink", + "sha256": "ac86a59410a864059eb4e088d78e996af4b958b8b892b2173cad0e7fd2f67492", + "size_in_bytes": 11294 + }, + { + "_path": "Lib/distutils/tests/test_install.py", + "path_type": "hardlink", + "sha256": "2311388a057cbd4c313482584ce232cabe6cbcef12d21ada8ff9a4aa645c707c", + "size_in_bytes": 8941 + }, + { + "_path": "Lib/distutils/tests/test_install_data.py", + "path_type": "hardlink", + "sha256": "c9e2bcc7941da7fd191ad777fd7b7a20f61ebd37a0b69e32e671b989b5711988", + "size_in_bytes": 2458 + }, + { + "_path": "Lib/distutils/tests/test_install_headers.py", + "path_type": "hardlink", + "sha256": "6d4cf40c06e4019f23bea216bdb32b07917f9c1be815be17ee152065e0d80e00", + "size_in_bytes": 1116 + }, + { + "_path": "Lib/distutils/tests/test_install_lib.py", + "path_type": "hardlink", + "sha256": "f17e8c96eef37c54faa7ec4d06398f716204f8880acf9da45369f2d3ac276185", + "size_in_bytes": 3955 + }, + { + "_path": "Lib/distutils/tests/test_install_scripts.py", + "path_type": "hardlink", + "sha256": "5a36d500cd869fc4383a7ef05859f0ab4e70412d18fb2550298554fef5d331f3", + "size_in_bytes": 2503 + }, + { + "_path": "Lib/distutils/tests/test_log.py", + "path_type": "hardlink", + "sha256": "a42872cba658f77fdc0ccca23c2b7277b7085aba2b5e5cdcc38e3c5770af1346", + "size_in_bytes": 1781 + }, + { + "_path": "Lib/distutils/tests/test_msvc9compiler.py", + "path_type": "hardlink", + "sha256": "3a65d8dd112d4f865a8c78249b0ce40288e7bc1c175b64eee6febd906e4acd9f", + "size_in_bytes": 5917 + }, + { + "_path": "Lib/distutils/tests/test_msvccompiler.py", + "path_type": "hardlink", + "sha256": "340b5687c31473630b4088b08d8de05aad1909697d5fb24a817e9467a316105b", + "size_in_bytes": 2725 + }, + { + "_path": "Lib/distutils/tests/test_register.py", + "path_type": "hardlink", + "sha256": "af136f8ed7223b9bab0e214a5dec96c7e8bceba6cc73d53dda458b2b87dd6808", + "size_in_bytes": 9860 + }, + { + "_path": "Lib/distutils/tests/test_sdist.py", + "path_type": "hardlink", + "sha256": "4cb8087c5d25cfa4413ab1f881c0ff47c164bedd68dd64c5f1d10d5a069e0660", + "size_in_bytes": 16998 + }, + { + "_path": "Lib/distutils/tests/test_spawn.py", + "path_type": "hardlink", + "sha256": "c3e7fa10c1b965afd92aaae1110fc626728dd693c9f7ed8bf32499ffcb454fb7", + "size_in_bytes": 5386 + }, + { + "_path": "Lib/distutils/tests/test_sysconfig.py", + "path_type": "hardlink", + "sha256": "24c60640cead65bcb9c79246b0bbb6c1f315f454db92e431fc1e19aeedb0fcde", + "size_in_bytes": 10555 + }, + { + "_path": "Lib/distutils/tests/test_text_file.py", + "path_type": "hardlink", + "sha256": "0d4ae2cc2b4ae020d61ee5309c0f477e73c7dbdcb99676cbfabdd7ac9d3b905e", + "size_in_bytes": 3320 + }, + { + "_path": "Lib/distutils/tests/test_unixccompiler.py", + "path_type": "hardlink", + "sha256": "deb364e2e094d6b256fb6006b4309fd9d3dc77113809fb815be0b05fd7ec4043", + "size_in_bytes": 4708 + }, + { + "_path": "Lib/distutils/tests/test_upload.py", + "path_type": "hardlink", + "sha256": "d094eeda8954fb1b99189996312733f7b4a1142c7dbac60b8e9d4700adcca157", + "size_in_bytes": 7023 + }, + { + "_path": "Lib/distutils/tests/test_util.py", + "path_type": "hardlink", + "sha256": "43d1867ccc7d8f8763732176b2afa8200e9ea9ec1469e56b497befd52b21dac0", + "size_in_bytes": 11609 + }, + { + "_path": "Lib/distutils/tests/test_version.py", + "path_type": "hardlink", + "sha256": "d21202dd00ba30b852258b4292e348a0c25de233272fd9d17bcd137ccc3a415f", + "size_in_bytes": 3335 + }, + { + "_path": "Lib/distutils/tests/test_versionpredicate.py", + "path_type": "hardlink", + "sha256": "388304a64c8721c2721b8d9f8561ab29f07c59e255bd40d3538c891d7599217c", + "size_in_bytes": 278 + }, + { + "_path": "Lib/distutils/text_file.py", + "path_type": "hardlink", + "sha256": "3ecb8025e59d289a0b495ffa37a229079fb43daf382b32d4b9c24c1516b3c372", + "size_in_bytes": 12483 + }, + { + "_path": "Lib/distutils/unixccompiler.py", + "path_type": "hardlink", + "sha256": "d712f8538752bbc8cf7c76e30b3e69c0a409d94fbf004732f6f6ea5c24f26780", + "size_in_bytes": 14855 + }, + { + "_path": "Lib/distutils/util.py", + "path_type": "hardlink", + "sha256": "5a759d80dc2bebdda1bc4461ddc9a335c378e3a25e4da20218cdce07686824ae", + "size_in_bytes": 21032 + }, + { + "_path": "Lib/distutils/version.py", + "path_type": "hardlink", + "sha256": "f0da203fa34f3d0a69dc450c65c4fd73310789af9e86a3e8f2ca68fdeec08145", + "size_in_bytes": 12514 + }, + { + "_path": "Lib/distutils/versionpredicate.py", + "path_type": "hardlink", + "sha256": "671a4403e4d0bfcf2651673a85eb543b8a92a80dac6bb8a98d9dd010ae5ebc39", + "size_in_bytes": 5133 + }, + { + "_path": "Lib/doctest.py", + "path_type": "hardlink", + "sha256": "83fa675e613f9082e127b94c0e7dfe6a4e7c46349c4094429039d0e5ba688b88", + "size_in_bytes": 106297 + }, + { + "_path": "Lib/email/__init__.py", + "path_type": "hardlink", + "sha256": "e4f46e3414c4602c9abb8b404a45e84412fc49dbe38a3d163f9575132dc7c93e", + "size_in_bytes": 1764 + }, + { + "_path": "Lib/email/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1ee51d5f5954378c9b8833bf41c04df058f27e80813bff1970e3fa012b9d5861", + "size_in_bytes": 2092 + }, + { + "_path": "Lib/email/__pycache__/_encoded_words.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c317e6fff5ce02c487589360eb8cc12e2dc7b12fdd7800b931b9e10305ca3f9e", + "size_in_bytes": 9099 + }, + { + "_path": "Lib/email/__pycache__/_header_value_parser.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "db15c3bfa31e5363b836e40fc49604d2a8e09945e055c11c8257cbeedbd5e269", + "size_in_bytes": 151615 + }, + { + "_path": "Lib/email/__pycache__/_parseaddr.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c8de9adeeb55d08580a2103390bbccd545b52d0bf97262f936c10e1539add8ec", + "size_in_bytes": 24282 + }, + { + "_path": "Lib/email/__pycache__/_policybase.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "32a443121ab96221f815a7cf54077cdad75ea70e1b67f9389de3097dc1bd79da", + "size_in_bytes": 19683 + }, + { + "_path": "Lib/email/__pycache__/base64mime.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e4acffe5ec0438c47f8ac50689679891fec36d5b37eac13a199a518f2ca24f32", + "size_in_bytes": 4333 + }, + { + "_path": "Lib/email/__pycache__/charset.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "253eefe65005d2f4ad987df91110a9fb93240c4dc5cce4d39c4b0828376f4432", + "size_in_bytes": 16003 + }, + { + "_path": "Lib/email/__pycache__/contentmanager.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8f09ada8d0c6a70a1eb56b61a15480a772763a2a877575dcb3f5e667944ca36b", + "size_in_bytes": 13812 + }, + { + "_path": "Lib/email/__pycache__/encoders.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b4acafab6780aa267e6ebc7b1fce371b242e01ef5c05158d439e3b2f69bb160f", + "size_in_bytes": 2368 + }, + { + "_path": "Lib/email/__pycache__/errors.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3cd340bdc2e0505a93e8f1650dd260b452f54800203d62f1a89893205af4e14f", + "size_in_bytes": 8646 + }, + { + "_path": "Lib/email/__pycache__/feedparser.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "eab1bb60adbd14ebaa898e7fb6abb0b72abda2ebbd715010d2746372c8b08416", + "size_in_bytes": 21475 + }, + { + "_path": "Lib/email/__pycache__/generator.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1d9427f40d9ec86ee3f08d9cd332a9d4eb16afff8c51442d5e714e75dd77af64", + "size_in_bytes": 22993 + }, + { + "_path": "Lib/email/__pycache__/header.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3e36d2b354336c12f4b7034f7fbea5a7fa8d1ec4f4505b6676bd9b0e9629c590", + "size_in_bytes": 26958 + }, + { + "_path": "Lib/email/__pycache__/headerregistry.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "61f2740348eaaf9b61c2c0b977fb91c253f64cf5fea69cf11de97c538c5a1edb", + "size_in_bytes": 33734 + }, + { + "_path": "Lib/email/__pycache__/iterators.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "be8f8b3cac3763a66f28debac332d1c13a606af7352eb42c469063980833bb5e", + "size_in_bytes": 3145 + }, + { + "_path": "Lib/email/__pycache__/message.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "29d4b6ed0b1bc7defe1e0d0bcb2bb851c0929105df95c545fe1b95400a7a658b", + "size_in_bytes": 59037 + }, + { + "_path": "Lib/email/__pycache__/parser.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "dc43f773326fe26696c2659fc37aa84464e679a99e57a8c3fa353e7e5b95654b", + "size_in_bytes": 7366 + }, + { + "_path": "Lib/email/__pycache__/policy.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ea4d5ba92bb1805530e1a745891da0f33afc30c1aef67e098a28723bd0b5c977", + "size_in_bytes": 12524 + }, + { + "_path": "Lib/email/__pycache__/quoprimime.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2959ad36483810859a206ac45cd050826c01ce8b974b87b08d9e58a8301f1bf9", + "size_in_bytes": 11219 + }, + { + "_path": "Lib/email/__pycache__/utils.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e9b6425f21a483d69e54f5bcf165fd68af28e402a9c7e1df32d81064c0e26fdf", + "size_in_bytes": 19293 + }, + { + "_path": "Lib/email/_encoded_words.py", + "path_type": "hardlink", + "sha256": "4178321600c0a19ca04cfe8542ce44487f339d15d89a473b58cea63c0b230217", + "size_in_bytes": 8541 + }, + { + "_path": "Lib/email/_header_value_parser.py", + "path_type": "hardlink", + "sha256": "a53e4b2177f50617804bf095832b95a11825641c4359266037ca7cd60d402764", + "size_in_bytes": 109186 + }, + { + "_path": "Lib/email/_parseaddr.py", + "path_type": "hardlink", + "sha256": "4308932872acbf4a674312a45a49b870e48026e3dfedc878ee2f512ddf2f30ba", + "size_in_bytes": 17821 + }, + { + "_path": "Lib/email/_policybase.py", + "path_type": "hardlink", + "sha256": "3db4bf3be5bdba13ab9a78ce30784c330d6dbc657b4e9142210dc8b264cfd424", + "size_in_bytes": 15534 + }, + { + "_path": "Lib/email/architecture.rst", + "path_type": "hardlink", + "sha256": "f2b2ba7497fd02d13abcfc2a98099283a94b09e8b4f2c1c822ecacde3bec3eae", + "size_in_bytes": 9561 + }, + { + "_path": "Lib/email/base64mime.py", + "path_type": "hardlink", + "sha256": "e2b4b87a5f42a8c5780e343f675513bbcc6abdd23fa14f8f1a7d4f7d72304770", + "size_in_bytes": 3551 + }, + { + "_path": "Lib/email/charset.py", + "path_type": "hardlink", + "sha256": "3ccb2e860390656664d271f08da8c0bae9a4297cc7e90be664d7c82d364e442f", + "size_in_bytes": 17118 + }, + { + "_path": "Lib/email/contentmanager.py", + "path_type": "hardlink", + "sha256": "2d81026aef17e4786b15d9ec0629304987e3f275a0fd0a421a81b4ed87234b2c", + "size_in_bytes": 10588 + }, + { + "_path": "Lib/email/encoders.py", + "path_type": "hardlink", + "sha256": "690b275529788cc48e8f541a2aef321dc31e92f75764ac7924896db72d8a9555", + "size_in_bytes": 1778 + }, + { + "_path": "Lib/email/errors.py", + "path_type": "hardlink", + "sha256": "dbfb4bbfc85e9d556d3385dc6356518846d8a122bc643b171ea61b6e8dc42c8b", + "size_in_bytes": 3814 + }, + { + "_path": "Lib/email/feedparser.py", + "path_type": "hardlink", + "sha256": "ca333e0462c96505d8c510f260192256306fa889c011c6f2eaa8d50c70503cce", + "size_in_bytes": 22802 + }, + { + "_path": "Lib/email/generator.py", + "path_type": "hardlink", + "sha256": "a6b9717c219dfaead225e191b5cd7293eab529433173604d2d00ddfb38fd5f76", + "size_in_bytes": 21402 + }, + { + "_path": "Lib/email/header.py", + "path_type": "hardlink", + "sha256": "4d9baa908ad5288dd8fad8cf20b3802ffac77ba1642727804a633b201c56e5ca", + "size_in_bytes": 24092 + }, + { + "_path": "Lib/email/headerregistry.py", + "path_type": "hardlink", + "sha256": "fada56c25b6a457c6a62af43f9f929bbc29424103ce65f40f114adb4fdf3d39f", + "size_in_bytes": 20819 + }, + { + "_path": "Lib/email/iterators.py", + "path_type": "hardlink", + "sha256": "1080a2d03779176d6d45f6ecd976dbe69f5579f7e4e83b75224c3f92fd258102", + "size_in_bytes": 2129 + }, + { + "_path": "Lib/email/message.py", + "path_type": "hardlink", + "sha256": "275f2d0a31e1331cd90014039c4c150fe5822c3e981638cc31d4973ee0fb27eb", + "size_in_bytes": 48210 + }, + { + "_path": "Lib/email/mime/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "Lib/email/mime/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a8de12c3cc9cd263344f5a395f66ac30db08cb3a373cc9a17d0b51aec3e749e1", + "size_in_bytes": 135 + }, + { + "_path": "Lib/email/mime/__pycache__/application.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a246bc570e8b35d5cd5a61c79d87594877ff40e037c3a81b24fff7f82ff256c7", + "size_in_bytes": 1807 + }, + { + "_path": "Lib/email/mime/__pycache__/audio.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "801b5565568ced58e2254bd8caf5c3d736021093d1bee820f82b7b1502145b3d", + "size_in_bytes": 3864 + }, + { + "_path": "Lib/email/mime/__pycache__/base.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "cf9b419da7a05e3b6e18d198542cc946e59fbfbd2b6392d1416fe040d273ee9c", + "size_in_bytes": 1380 + }, + { + "_path": "Lib/email/mime/__pycache__/image.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "aae8c4c7307c77ba47fa10442c35152422eb19cb4b0aa703389a319b34b4b457", + "size_in_bytes": 6554 + }, + { + "_path": "Lib/email/mime/__pycache__/message.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "57c46569294ea3b9406a7ae3e7a527535a831b1d5862b4966d1287859a3dfbd3", + "size_in_bytes": 1723 + }, + { + "_path": "Lib/email/mime/__pycache__/multipart.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "dac02e0645d907104f399a8dceb84c2121c5d5e7cacc574007d6dd29c2f5726b", + "size_in_bytes": 1855 + }, + { + "_path": "Lib/email/mime/__pycache__/nonmultipart.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3f7244e95463a7705d260ae2099ac3e288abb4787415e3513f6cb57d92fa0677", + "size_in_bytes": 970 + }, + { + "_path": "Lib/email/mime/__pycache__/text.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "199415ec22ec7f2d00fabd33e1e67da97ceb8e18e1dccbcb7c17e4316b1285e8", + "size_in_bytes": 1744 + }, + { + "_path": "Lib/email/mime/application.py", + "path_type": "hardlink", + "sha256": "b82a944ccba03e7e7eec46232e50ffe4ce2c32f4b0e26662e6bde30d533584ae", + "size_in_bytes": 1321 + }, + { + "_path": "Lib/email/mime/audio.py", + "path_type": "hardlink", + "sha256": "856263b25a3384a7450a1a0b9869fb897b84f893b2e7147c7e045ae50d132cd3", + "size_in_bytes": 3094 + }, + { + "_path": "Lib/email/mime/base.py", + "path_type": "hardlink", + "sha256": "9a7b36653b5657525a0aeeaa72d4a0b09f598e6edc29c139c2dc2612b7d29fb8", + "size_in_bytes": 914 + }, + { + "_path": "Lib/email/mime/image.py", + "path_type": "hardlink", + "sha256": "460be5b50cfcaab8e72a73f24f14ab062cedf1a40a775b8b0d80c13aed44bb5e", + "size_in_bytes": 3726 + }, + { + "_path": "Lib/email/mime/message.py", + "path_type": "hardlink", + "sha256": "30fccea73b874b5ddaccbd3c64936833749ff039f08d40524c1b0b25b8e8e2b8", + "size_in_bytes": 1315 + }, + { + "_path": "Lib/email/mime/multipart.py", + "path_type": "hardlink", + "sha256": "8bf2beca6de95d66f12968380a428d3bb0a28a8a6ea2078da521511e1ed80a38", + "size_in_bytes": 1619 + }, + { + "_path": "Lib/email/mime/nonmultipart.py", + "path_type": "hardlink", + "sha256": "4eb9ad32603d66fc9d55aebcc4d3cf759edd9e95a591d38690659afb2e57b050", + "size_in_bytes": 689 + }, + { + "_path": "Lib/email/mime/text.py", + "path_type": "hardlink", + "sha256": "dbf4775f89ab4335b2ebdcbc364699b400559d9cf50fa09266c4e6f113183cc2", + "size_in_bytes": 1435 + }, + { + "_path": "Lib/email/parser.py", + "path_type": "hardlink", + "sha256": "7a665bc106e9d4f6f8f2c8de53b2c1d5b97f5105cc7da638b82d731f6f9e354e", + "size_in_bytes": 5038 + }, + { + "_path": "Lib/email/policy.py", + "path_type": "hardlink", + "sha256": "56a2a90d973c06668f6f113d67f26cf348af10b33eece2a6b812e34da45258d8", + "size_in_bytes": 10519 + }, + { + "_path": "Lib/email/quoprimime.py", + "path_type": "hardlink", + "sha256": "77b454bd3ba3b5e3776be28ae3a0fd8de5d1e50d5b8ee10dd539c37c2bd68082", + "size_in_bytes": 9864 + }, + { + "_path": "Lib/email/utils.py", + "path_type": "hardlink", + "sha256": "014848ca9a7f3a747e0ae8e0814f5c5734301bea880d73618ea0fd61e53b0342", + "size_in_bytes": 17222 + }, + { + "_path": "Lib/encodings/__init__.py", + "path_type": "hardlink", + "sha256": "78c4744d407690f321565488710b5aaf6486b5afa8d185637aa1e7633ab59cd8", + "size_in_bytes": 5884 + }, + { + "_path": "Lib/encodings/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "fddd1f52253af0310100a63a6a7278605201936edaec03dbbe9c408052055f9d", + "size_in_bytes": 6441 + }, + { + "_path": "Lib/encodings/__pycache__/aliases.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "769079a8e93e8cb39f50357e0a8b65a2756b84ccfb9e8d691ca6f55c1b427cc6", + "size_in_bytes": 12631 + }, + { + "_path": "Lib/encodings/__pycache__/ascii.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4b079f0c261da8f5c543ba36ccf5f3c59fcbb35e02fc9810a60dac5b26295ed4", + "size_in_bytes": 2692 + }, + { + "_path": "Lib/encodings/__pycache__/base64_codec.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "66a951588d27cfd424879ad2c4e7d8dbf1b4553cac8ea3ba27f7dabdfc86bd81", + "size_in_bytes": 3305 + }, + { + "_path": "Lib/encodings/__pycache__/big5.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d085e1110fbbe73d9bb0874fc8d27cb6d6aa09fd017b7e9c1f4b597504124805", + "size_in_bytes": 2117 + }, + { + "_path": "Lib/encodings/__pycache__/big5hkscs.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5d3c9f35eeea8691c52bdc273fbf050e800af40e3817038c464e138f97dcd019", + "size_in_bytes": 2127 + }, + { + "_path": "Lib/encodings/__pycache__/bz2_codec.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5bc633c93dfca933fcb042932b71d2bbf8a02a449fb7138c68a83aadfd7081f3", + "size_in_bytes": 4829 + }, + { + "_path": "Lib/encodings/__pycache__/charmap.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "def57c9816155fac96a21036f8f0bd96ce25458407998c216cefa8a0864c6f05", + "size_in_bytes": 4103 + }, + { + "_path": "Lib/encodings/__pycache__/cp037.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e275b8677a83878c8f392b53a9c07a5a8ff15cc0f870807b266b6342f66c182b", + "size_in_bytes": 3368 + }, + { + "_path": "Lib/encodings/__pycache__/cp1006.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e85f493ec5fb855b580710606060316532c5dfc545ee5e5e23eee29c6b27160d", + "size_in_bytes": 3444 + }, + { + "_path": "Lib/encodings/__pycache__/cp1026.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "afa260679b04a8e6bcb933ac455b54c7ca24f7aa731da246c912b0a1b3dd358a", + "size_in_bytes": 3372 + }, + { + "_path": "Lib/encodings/__pycache__/cp1125.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d82cc8e48efbb0ad36ccd4a37e0bd936aac251231f8648cf50ae0615072a93d8", + "size_in_bytes": 14236 + }, + { + "_path": "Lib/encodings/__pycache__/cp1140.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4b037739fab15fceec773bb913bf5e75dc6ddeae4ee77b9d1d12d7be036ced0e", + "size_in_bytes": 3358 + }, + { + "_path": "Lib/encodings/__pycache__/cp1250.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9545f2c82c684eedfa863283b713e6c8877f2e189a61a60f7832dcabcfbdc465", + "size_in_bytes": 3395 + }, + { + "_path": "Lib/encodings/__pycache__/cp1251.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "faf0e172f3f8ab6c5f42fbc6606a61fbbcfe91addd8306899e455b041528e436", + "size_in_bytes": 3392 + }, + { + "_path": "Lib/encodings/__pycache__/cp1252.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "86c295c51ffe5a3cde1eff279001669a0b74714dbdd57a2f963f171684af74ec", + "size_in_bytes": 3395 + }, + { + "_path": "Lib/encodings/__pycache__/cp1253.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "50b10dcb6cd9dd35c1558ce282c14208406099921512b74286795dd612c9c034", + "size_in_bytes": 3408 + }, + { + "_path": "Lib/encodings/__pycache__/cp1254.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5a18521247e9d5af00751be168ea14d60d0e1aa07bd59e44dbb01634ebd51e3d", + "size_in_bytes": 3397 + }, + { + "_path": "Lib/encodings/__pycache__/cp1255.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2d3a9b807da3d7d0bc9b4655dfede99ac79268889c1c511c8a8d1dbc1c9d31b3", + "size_in_bytes": 3416 + }, + { + "_path": "Lib/encodings/__pycache__/cp1256.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "84367eb07e37db2a1cc93e93f371ad13c8539be5502e2100c7e130ed70dbd36d", + "size_in_bytes": 3394 + }, + { + "_path": "Lib/encodings/__pycache__/cp1257.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "48fc8a702d0a6531ad9e01f8f40d4c86189b337d1b3db837ef51a659dce47763", + "size_in_bytes": 3402 + }, + { + "_path": "Lib/encodings/__pycache__/cp1258.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "54494bf833d995017d023d67e8234a61e9f087c4766c85f5ea800e25fea0ffe4", + "size_in_bytes": 3400 + }, + { + "_path": "Lib/encodings/__pycache__/cp273.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "aef7e6231021559f3157f70c841d63a4395d06ee0398eef1741f9915720c9a3e", + "size_in_bytes": 3354 + }, + { + "_path": "Lib/encodings/__pycache__/cp424.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1da1506ef5f8eba2d313153680285a33390541ff627dede7209c1b61b280db0b", + "size_in_bytes": 3398 + }, + { + "_path": "Lib/encodings/__pycache__/cp437.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3f5302843601534a7b4790c6977170b41b8d4e19deea8c81dfbbc76b0e90750b", + "size_in_bytes": 13869 + }, + { + "_path": "Lib/encodings/__pycache__/cp500.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7a524c683c87ee36ec16abda07f8ba9161c5489b9c6221c7152204bc58d4fa3d", + "size_in_bytes": 3368 + }, + { + "_path": "Lib/encodings/__pycache__/cp720.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "bbce3a9d08cf64005145b17727cdd8258ba5370edde25ffb4e14b1c77ca408a2", + "size_in_bytes": 3465 + }, + { + "_path": "Lib/encodings/__pycache__/cp737.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "fbb00d7034382cdf9f53ee1a71c573e4cddef6e67b6c215953d680563208563e", + "size_in_bytes": 14271 + }, + { + "_path": "Lib/encodings/__pycache__/cp775.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d6ab6d1c788e601442f435e2cec7cfc961f09fc1d0d799e698c5397e6e7f4ea8", + "size_in_bytes": 13909 + }, + { + "_path": "Lib/encodings/__pycache__/cp850.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ce818f11d729969ad47658ae73b3be0fe95514f90bbf1470f6d3d2bc4c911034", + "size_in_bytes": 13450 + }, + { + "_path": "Lib/encodings/__pycache__/cp852.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b75beb1b294040631d2bd6af120395c3ab177c3253fd4acec4b803505bc17014", + "size_in_bytes": 13925 + }, + { + "_path": "Lib/encodings/__pycache__/cp855.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "444f2b586b9a14223b10e5d4ae12e2452b770a2fbfff26491dccb07485d59e9b", + "size_in_bytes": 14238 + }, + { + "_path": "Lib/encodings/__pycache__/cp856.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9998daf25370708af967b1f502b735fe798747bb9fd1c8edc8b242db995f4abe", + "size_in_bytes": 3430 + }, + { + "_path": "Lib/encodings/__pycache__/cp857.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "27925b58966b19d8f0d8e62b15a29e811bb3596ccd77c6555cf0330df5dcc484", + "size_in_bytes": 13245 + }, + { + "_path": "Lib/encodings/__pycache__/cp858.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "edc64bc69ae5e2b4226665dbdc652859726fcf4f373f5ffba3bffc9bbedf7917", + "size_in_bytes": 13420 + }, + { + "_path": "Lib/encodings/__pycache__/cp860.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6f65cb24f297ead331d5426f05d8392a2fe3abf59b106722bfcb84a3a0c4c5f6", + "size_in_bytes": 13840 + }, + { + "_path": "Lib/encodings/__pycache__/cp861.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "346dc1b471a96845e5e8d44812359881f6baca7b1badbd1160b4df226bfdc38d", + "size_in_bytes": 13865 + }, + { + "_path": "Lib/encodings/__pycache__/cp862.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1f7796c4c0cb26720da86327b236ce04c79b181700d6efd8e75e8e7f7a69bb00", + "size_in_bytes": 14098 + }, + { + "_path": "Lib/encodings/__pycache__/cp863.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "53d0e605b416ed61105a09e03885dd9a19e8d2d3d87cd3fb19e726921f08f478", + "size_in_bytes": 13861 + }, + { + "_path": "Lib/encodings/__pycache__/cp864.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5476d2085e438d580954c2ee2338b1c618aabb472b5c09267be3d975f819fe3e", + "size_in_bytes": 13900 + }, + { + "_path": "Lib/encodings/__pycache__/cp865.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a64d13a4fb01e194b3a2e39ac29c92e1ddf3c86536da102b180196a3bfcb29a2", + "size_in_bytes": 13865 + }, + { + "_path": "Lib/encodings/__pycache__/cp866.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7f036da697a7d4051b1b495313ef319cfbb02987d85efe266b854ded91854c6f", + "size_in_bytes": 14278 + }, + { + "_path": "Lib/encodings/__pycache__/cp869.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "773cdc6e21e5101ecf55c49d538ca8197bc86cce1b41970c81bac52739dda0b9", + "size_in_bytes": 13802 + }, + { + "_path": "Lib/encodings/__pycache__/cp874.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "150c9591c11e48008880a5810721502aaa6962007180ace970f008c9b1a95b75", + "size_in_bytes": 3496 + }, + { + "_path": "Lib/encodings/__pycache__/cp875.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5a3baf4d4eea94f683321bb9ad81ff7c73ea4561073f0fac3eccb7ab8340bc0f", + "size_in_bytes": 3365 + }, + { + "_path": "Lib/encodings/__pycache__/cp932.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ddfafa84e6b256bde7f9b672cea4fd6a16f40154c196866d8d98509361acb708", + "size_in_bytes": 2119 + }, + { + "_path": "Lib/encodings/__pycache__/cp949.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6d84386a50f045d9e6623ce294634e71215df98bbc1cd3790aba36df8b429aba", + "size_in_bytes": 2119 + }, + { + "_path": "Lib/encodings/__pycache__/cp950.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2d7b31f532c216a6e2dd48ca5c31fc3fa1030f41d74885975ef8fd492876d772", + "size_in_bytes": 2119 + }, + { + "_path": "Lib/encodings/__pycache__/euc_jis_2004.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c50fc572f87a9430ee4572506bf34e5f0293f6202205b3d23cb4bf3e55e7366d", + "size_in_bytes": 2133 + }, + { + "_path": "Lib/encodings/__pycache__/euc_jisx0213.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "28fa0ed01ed97a0e9eca190b41bfa86f94674b3e92bafc3c67ea1f47063956e0", + "size_in_bytes": 2133 + }, + { + "_path": "Lib/encodings/__pycache__/euc_jp.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0b753fab5cf47ca6823b95e4175d09dc1fde699220b8325091970f9107fa195c", + "size_in_bytes": 2121 + }, + { + "_path": "Lib/encodings/__pycache__/euc_kr.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9dd379fbc68a057486eed5fa5ea6f822e0c0af25d062a4cc89993515412b9f6a", + "size_in_bytes": 2121 + }, + { + "_path": "Lib/encodings/__pycache__/gb18030.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "84a6b15302046263e1c2b2d98862e4ac196a1f64c26016e6450e44b4f76f7026", + "size_in_bytes": 2123 + }, + { + "_path": "Lib/encodings/__pycache__/gb2312.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "14aed5965edb1a445040fe7c3266cd7b523cea3831f7b06350d02f02ec4698e6", + "size_in_bytes": 2121 + }, + { + "_path": "Lib/encodings/__pycache__/gbk.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1cd86f4d2f773cf4a6fa789dfdf57dcd8ed51d6f032c17be0351884cddf419b9", + "size_in_bytes": 2115 + }, + { + "_path": "Lib/encodings/__pycache__/hex_codec.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "845a4a5e6c4533778d34200a2df60ae68bc83385341fc50f4ae6404af5e4d7d5", + "size_in_bytes": 3292 + }, + { + "_path": "Lib/encodings/__pycache__/hp_roman8.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e3cadccd6c061a923654ba2f6526642bc21cfd27e617b910c2dc0b27f8105e4c", + "size_in_bytes": 3569 + }, + { + "_path": "Lib/encodings/__pycache__/hz.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "49e2c7d682741ccbb68cfb7bcb3827f3675b5c549ec666257f6d8bbad3ad4c94", + "size_in_bytes": 2113 + }, + { + "_path": "Lib/encodings/__pycache__/idna.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c54b283f0595cc46f2cd5ed4ad89ac504572a471014b8e46ffb90d526acf7a67", + "size_in_bytes": 11527 + }, + { + "_path": "Lib/encodings/__pycache__/iso2022_jp.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "44d37e9d0396dd8bf61b7465a9b007dd55ca05c0516d10f4aee9353796eee969", + "size_in_bytes": 2134 + }, + { + "_path": "Lib/encodings/__pycache__/iso2022_jp_1.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "df5a1cc027fcfbf90da1c24586b74badf95d142272f6635c9f7b093807f9914a", + "size_in_bytes": 2138 + }, + { + "_path": "Lib/encodings/__pycache__/iso2022_jp_2.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e39ca7b7618c58ad8658e06c33af283dea5df741d803d6a35db5cf76ec756d2c", + "size_in_bytes": 2138 + }, + { + "_path": "Lib/encodings/__pycache__/iso2022_jp_2004.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4b13213ca57a55e7fa6c14359655408aa4b8921bc445582963be18cd836924ec", + "size_in_bytes": 2145 + }, + { + "_path": "Lib/encodings/__pycache__/iso2022_jp_3.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f4f9feb53c6353f88d1b7a9c5c529e718978e5c6d5b3c2d4a3b4de96c955df25", + "size_in_bytes": 2138 + }, + { + "_path": "Lib/encodings/__pycache__/iso2022_jp_ext.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e90fdc43192a7fbb377c110d46b1c7922f4b5a2324dc880610a2bee4095bb27d", + "size_in_bytes": 2143 + }, + { + "_path": "Lib/encodings/__pycache__/iso2022_kr.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "edf14b411ad6af724b75e4bbadca0d510b7d2fd92d097cee43950c8c09510def", + "size_in_bytes": 2134 + }, + { + "_path": "Lib/encodings/__pycache__/iso8859_1.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "373ad247960b20e9f7d3966740d17c8ef1ecf8b5a07ead0d65628de408c77f0c", + "size_in_bytes": 3367 + }, + { + "_path": "Lib/encodings/__pycache__/iso8859_10.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4bbb1be48498e34df35772e946002fef3ea2877bf1418c1d0ece35e8e12fb5cd", + "size_in_bytes": 3372 + }, + { + "_path": "Lib/encodings/__pycache__/iso8859_11.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5095efd8d49fc9f665ccad24e3f7be02257742371403bf4817ccaa1eee8ed9b3", + "size_in_bytes": 3466 + }, + { + "_path": "Lib/encodings/__pycache__/iso8859_13.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7924ef7ca479f487e17fd18d4fca01863de5bcf5169975b3c86ac0437c2a9735", + "size_in_bytes": 3375 + }, + { + "_path": "Lib/encodings/__pycache__/iso8859_14.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "72a51173044e588c3746da63b4e19be35624b1fb3f59220114636c517620134d", + "size_in_bytes": 3393 + }, + { + "_path": "Lib/encodings/__pycache__/iso8859_15.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "95997594f849b0ae2fdf5cf02ef98d8661f9f0e6e2facb74f2a0e9e0c6ac5632", + "size_in_bytes": 3372 + }, + { + "_path": "Lib/encodings/__pycache__/iso8859_16.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c94d69093c65bdbbd290155133c5b7b7993bf14949d4fee3993b1492c58ac92f", + "size_in_bytes": 3374 + }, + { + "_path": "Lib/encodings/__pycache__/iso8859_2.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1191930cd353d532a007fcb476c86a85558efb3e5c814c12b30023c06b088dc4", + "size_in_bytes": 3367 + }, + { + "_path": "Lib/encodings/__pycache__/iso8859_3.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "884a35e5d31954d690a29bb64d43ec10d893e650aea7f8ecda2d4f55436edb63", + "size_in_bytes": 3374 + }, + { + "_path": "Lib/encodings/__pycache__/iso8859_4.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "99a629407077857ac51658436aab4ac4c239503a05486a20d3153326a01d42f3", + "size_in_bytes": 3367 + }, + { + "_path": "Lib/encodings/__pycache__/iso8859_5.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "853e2aed38d6b172869cd9914f8abc61101752b739479be3f868fde83b9e4653", + "size_in_bytes": 3368 + }, + { + "_path": "Lib/encodings/__pycache__/iso8859_6.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "07504842d46632afebfe1b22ecf5d5aec7f3f6eb6ae1e74110699b31817aa946", + "size_in_bytes": 3412 + }, + { + "_path": "Lib/encodings/__pycache__/iso8859_7.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "dee5126dbacdfd78660cae4572a09223fcceac89da0a70da963ca779dcd136a8", + "size_in_bytes": 3375 + }, + { + "_path": "Lib/encodings/__pycache__/iso8859_8.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "198f7b3af9cfa0cb093406ff42842e87c370e7f28900303d5d671ffb4d8023ac", + "size_in_bytes": 3406 + }, + { + "_path": "Lib/encodings/__pycache__/iso8859_9.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "599a2efc2e326c9f1c6a6870904da2e7c96f4e27bde4b89a0f53888b36cbebce", + "size_in_bytes": 3367 + }, + { + "_path": "Lib/encodings/__pycache__/johab.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4e6e62859672a4bb32d757376a386aebe9c023463bff43f6148ec4b0605ed8de", + "size_in_bytes": 2119 + }, + { + "_path": "Lib/encodings/__pycache__/koi8_r.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c3e24d2719e5d55abc93881f16d599d7c1a814d8424d82f017b0c426a8f2789a", + "size_in_bytes": 3419 + }, + { + "_path": "Lib/encodings/__pycache__/koi8_t.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9da1b3f043c3a29a216ab8e5bfbbe5812c0881c8ba700b2de42900585eef4f3b", + "size_in_bytes": 3330 + }, + { + "_path": "Lib/encodings/__pycache__/koi8_u.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "212411bb625e197c99c3048dfd9fb6ed6dc39d8b0cad90fd1682a9674690d3a9", + "size_in_bytes": 3405 + }, + { + "_path": "Lib/encodings/__pycache__/kz1048.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6c3d99e2bf29d0a606e264c2220a6292ccf6c217e118c2c2a25518d150fd5e4c", + "size_in_bytes": 3382 + }, + { + "_path": "Lib/encodings/__pycache__/latin_1.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7f64316b8d4e157501e8ddad953164dc73bc1b3d5ac820d8e1557c5685916286", + "size_in_bytes": 2704 + }, + { + "_path": "Lib/encodings/__pycache__/mac_arabic.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "14d0ab4a1ba58e70919389c68418edb81afacaac034c408b38c9f978667863ec", + "size_in_bytes": 13755 + }, + { + "_path": "Lib/encodings/__pycache__/mac_croatian.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "bd9ccceac7ab066ecbb32fefeba48dea9fabe67d480b10de9e6cddf95131c68a", + "size_in_bytes": 3414 + }, + { + "_path": "Lib/encodings/__pycache__/mac_cyrillic.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ac43df7a9d5cd6359486ac7f32e6d6c0d51e032f56d01c1e652264c980631c06", + "size_in_bytes": 3404 + }, + { + "_path": "Lib/encodings/__pycache__/mac_farsi.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9cb47b3dc4bddab383fa90967f49db279d10dbdeeb6b6a4cf9bf38ce66efe785", + "size_in_bytes": 3348 + }, + { + "_path": "Lib/encodings/__pycache__/mac_greek.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a3c77295727e012bb8cdc2b6a48243791e365a503698b8d6588e395fd91a795c", + "size_in_bytes": 3388 + }, + { + "_path": "Lib/encodings/__pycache__/mac_iceland.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6219fa7a16ff82c168040dd2234e0a8b19e976b016fcfac83f268fa9c9d75152", + "size_in_bytes": 3407 + }, + { + "_path": "Lib/encodings/__pycache__/mac_latin2.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4817245268aa553a6d18684485e8a75fdf81e9c266f1c30f320ae940bd20459c", + "size_in_bytes": 3548 + }, + { + "_path": "Lib/encodings/__pycache__/mac_roman.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "57f0d0819c8e1b3ec7f21b8d88d9ef63971a52a4b8308c7cdbd931bff1683a51", + "size_in_bytes": 3405 + }, + { + "_path": "Lib/encodings/__pycache__/mac_romanian.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "87c32ae9f0e6678a448401dadc9faec8c182860e3969d53eb20fe4c165bb6269", + "size_in_bytes": 3415 + }, + { + "_path": "Lib/encodings/__pycache__/mac_turkish.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "85b307401afeb58c22c8772fe14396996d58ce58c343aa338b765730e4d74f7d", + "size_in_bytes": 3408 + }, + { + "_path": "Lib/encodings/__pycache__/mbcs.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8e8da8d53e0bd5b626246efa065a8e36249d2319ce517b14d63de00afa33adca", + "size_in_bytes": 2340 + }, + { + "_path": "Lib/encodings/__pycache__/oem.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "54fa9caa2ea7492838150852325e0dd3055c782ada4bc23b775848c4c71ac57c", + "size_in_bytes": 2153 + }, + { + "_path": "Lib/encodings/__pycache__/palmos.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "880ad125ef91a1d6871701df8c29a7352a9daaa66ae171c993cd91179fb14fd7", + "size_in_bytes": 3395 + }, + { + "_path": "Lib/encodings/__pycache__/ptcp154.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6b10beca3000ab2d0355abcf933af6760fad549e437131b5b1e98d16d7f1f885", + "size_in_bytes": 3489 + }, + { + "_path": "Lib/encodings/__pycache__/punycode.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0724013ba9867bd436b7c94a6764832d1c95fa952b84c74f78420692acca37a6", + "size_in_bytes": 10744 + }, + { + "_path": "Lib/encodings/__pycache__/quopri_codec.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "495e5ffa7fb5cdabe6288b2d94f2dbc04c8b3bafc45efe602152c607aba995a9", + "size_in_bytes": 3596 + }, + { + "_path": "Lib/encodings/__pycache__/raw_unicode_escape.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6ee49eb9a4033cde4154bcc60b8cd8e86068796275a8fe719c1b4292e990dbad", + "size_in_bytes": 2834 + }, + { + "_path": "Lib/encodings/__pycache__/rot_13.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "cf8d5bed646e8cb44c058495537f8d8e940507ad970838f1eb6bfdfd805b1c05", + "size_in_bytes": 4816 + }, + { + "_path": "Lib/encodings/__pycache__/shift_jis.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b75ed96f8ee546a4937aea261255fc2784f7374559dafc65d14e72109ea78599", + "size_in_bytes": 2127 + }, + { + "_path": "Lib/encodings/__pycache__/shift_jis_2004.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e49132d099aa0a698aa8b0d1425f64ba09da34a1497823d8450ef4a2953b2265", + "size_in_bytes": 2138 + }, + { + "_path": "Lib/encodings/__pycache__/shift_jisx0213.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "31113b07ff6c2e9adc879528798a5088902ec03cc3d5a155e7cdd7c8f1b45ec2", + "size_in_bytes": 2138 + }, + { + "_path": "Lib/encodings/__pycache__/tis_620.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d03aa4b81603173b2957be82df8ee4e3d00ae9178230e05c98df171a43883bcf", + "size_in_bytes": 3457 + }, + { + "_path": "Lib/encodings/__pycache__/undefined.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4a438fd22ed66bf3b77e78f759e1531fd642cdd3c13c67f5e3d63b41f401a5a5", + "size_in_bytes": 2807 + }, + { + "_path": "Lib/encodings/__pycache__/unicode_escape.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "53084b0e06a45f8813a1c47e407e45bc6890c5b9a41e9e0a543fb59ab8499454", + "size_in_bytes": 2814 + }, + { + "_path": "Lib/encodings/__pycache__/utf_16.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a50a8b63d6b38101253d0e229fa646df35cb26af4f83fa8eade76fc2495e10d9", + "size_in_bytes": 8028 + }, + { + "_path": "Lib/encodings/__pycache__/utf_16_be.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e850180773246fee2b021c526057929487677ba83554692a424c782bab8d1647", + "size_in_bytes": 2320 + }, + { + "_path": "Lib/encodings/__pycache__/utf_16_le.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "201f6a003ede59c564ef311b685b9e8b9293c10cee47bb3c34676d166d88f438", + "size_in_bytes": 2320 + }, + { + "_path": "Lib/encodings/__pycache__/utf_32.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0ccbe2e8df970e3a7097c03d7aab13bd38c46f01178bee55e877ee58e08fb544", + "size_in_bytes": 7923 + }, + { + "_path": "Lib/encodings/__pycache__/utf_32_be.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "96efe7df4ae4603ddd6c4aa90c3a80d001c6d1ef32ad14a19dbb487a9a0a2a22", + "size_in_bytes": 2213 + }, + { + "_path": "Lib/encodings/__pycache__/utf_32_le.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a56141403ad1752d5e233a695e2fb436a95136ec75f9a33b0e0dc655e1943605", + "size_in_bytes": 2213 + }, + { + "_path": "Lib/encodings/__pycache__/utf_7.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b9a17a8996047d76af51ee3796c881da4d9156a2273b2a9598700a9f71e2954a", + "size_in_bytes": 2241 + }, + { + "_path": "Lib/encodings/__pycache__/utf_8.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "24be039e14671c404d522b8a09cc2a3e6f3bfff0ec7cb03b2c353b880ebdb8c9", + "size_in_bytes": 2300 + }, + { + "_path": "Lib/encodings/__pycache__/utf_8_sig.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e7176c29e8bdb580ba7043e27404c63aa9281148fadcf66048361359a678f75a", + "size_in_bytes": 7294 + }, + { + "_path": "Lib/encodings/__pycache__/uu_codec.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "60c9bd2bc05d08efb1f565de37e478081caef6da7e5a1a3433c454508f47c088", + "size_in_bytes": 5251 + }, + { + "_path": "Lib/encodings/__pycache__/zlib_codec.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "db24956d6102885ba7b31d1b90893e0b5824cfe22be1a44efdd307a34bfd8acb", + "size_in_bytes": 4726 + }, + { + "_path": "Lib/encodings/aliases.py", + "path_type": "hardlink", + "sha256": "6fdcc49ba23a0203ae6cf28e608f8e6297d7c4d77d52e651db3cb49b9564c6d2", + "size_in_bytes": 15677 + }, + { + "_path": "Lib/encodings/ascii.py", + "path_type": "hardlink", + "sha256": "578aa1173f7cc60dad2895071287fe6182bd14787b3fbf47a6c7983dfe3675e3", + "size_in_bytes": 1248 + }, + { + "_path": "Lib/encodings/base64_codec.py", + "path_type": "hardlink", + "sha256": "cf9ac7a464f541492486241d1b4bf33e37b45c6499275cc4d69c5a8e564e5976", + "size_in_bytes": 1533 + }, + { + "_path": "Lib/encodings/big5.py", + "path_type": "hardlink", + "sha256": "98fac6f86a20dd05da197e2058176ebfd47edee7074c3248f5f48fe0fb672d7c", + "size_in_bytes": 1019 + }, + { + "_path": "Lib/encodings/big5hkscs.py", + "path_type": "hardlink", + "sha256": "21d051a00fb5c6a86ba187e0c50e811d659ce00991fd5f5b408f71ebb2ef0f16", + "size_in_bytes": 1039 + }, + { + "_path": "Lib/encodings/bz2_codec.py", + "path_type": "hardlink", + "sha256": "1181a2a89102a2b1d2b2f1f4473236d5d1ececdd0be8fdaa498a3dbe21a185ab", + "size_in_bytes": 2249 + }, + { + "_path": "Lib/encodings/charmap.py", + "path_type": "hardlink", + "sha256": "1b8b5fdb36ce3becc62a6115ed904a17083949ec8aaef5a80f7078cec232f43b", + "size_in_bytes": 2084 + }, + { + "_path": "Lib/encodings/cp037.py", + "path_type": "hardlink", + "sha256": "fda6ca994d710e4e0c760e0204c29a4273fc0f14ebe3169306d2eb54c9953f58", + "size_in_bytes": 13121 + }, + { + "_path": "Lib/encodings/cp1006.py", + "path_type": "hardlink", + "sha256": "eaded38b427841bdf280e878f1e26da506e743eaa9429075332af60cce429473", + "size_in_bytes": 13568 + }, + { + "_path": "Lib/encodings/cp1026.py", + "path_type": "hardlink", + "sha256": "f5227237dd7ce5005b16a8e4d8342f0d193193c878e3cf35b9305d22b3b1aaf9", + "size_in_bytes": 13113 + }, + { + "_path": "Lib/encodings/cp1125.py", + "path_type": "hardlink", + "sha256": "f84c7d30ce222e6a50cff1a4c9737173411da108cbd2c9bb57c854480103c470", + "size_in_bytes": 34597 + }, + { + "_path": "Lib/encodings/cp1140.py", + "path_type": "hardlink", + "sha256": "3379d78b244aa905ffe1171a968caaf41b9a0154d1ddc76c05a2abaca2b289fd", + "size_in_bytes": 13105 + }, + { + "_path": "Lib/encodings/cp1250.py", + "path_type": "hardlink", + "sha256": "ebcec1adf9167863fb0bab29708c546300c80a77ef07838c9e0437a59e265970", + "size_in_bytes": 13686 + }, + { + "_path": "Lib/encodings/cp1251.py", + "path_type": "hardlink", + "sha256": "d57f8cfa34494c5acb6692ddb31f616ae2dd89a075d2af6d36b0b7ec2ffe7af1", + "size_in_bytes": 13361 + }, + { + "_path": "Lib/encodings/cp1252.py", + "path_type": "hardlink", + "sha256": "19aa5bee667f5fb387924a813aec9fa1dda47769d09e8483a748bdb202be6a84", + "size_in_bytes": 13511 + }, + { + "_path": "Lib/encodings/cp1253.py", + "path_type": "hardlink", + "sha256": "8c27696dcfb6894b378869bc89f113703fbd1e9b13a83934463d5999b055d1e8", + "size_in_bytes": 13094 + }, + { + "_path": "Lib/encodings/cp1254.py", + "path_type": "hardlink", + "sha256": "06517ec2f74f1c6562d0a1a500c48ba43f2e6e9d0c3d28356d747f274f1a4c8d", + "size_in_bytes": 13502 + }, + { + "_path": "Lib/encodings/cp1255.py", + "path_type": "hardlink", + "sha256": "54a1b5087578fa78e5bdd0afa6a9e80e8c5467c1e4226cf6e586cfe7a674a653", + "size_in_bytes": 12466 + }, + { + "_path": "Lib/encodings/cp1256.py", + "path_type": "hardlink", + "sha256": "ad3768ac2fef2a646b3301c20af705f4d4a1544f22fa8a84241bada27ab84133", + "size_in_bytes": 12814 + }, + { + "_path": "Lib/encodings/cp1257.py", + "path_type": "hardlink", + "sha256": "d9149d2925b3f719809ef2297e541461079f15c658af207a3e498be314ab2c6b", + "size_in_bytes": 13374 + }, + { + "_path": "Lib/encodings/cp1258.py", + "path_type": "hardlink", + "sha256": "672e05b51952a82c8dbd5603769195fcedf565e457bb86c0d5bae04955d04630", + "size_in_bytes": 13364 + }, + { + "_path": "Lib/encodings/cp273.py", + "path_type": "hardlink", + "sha256": "6c6aec3b213ea3aebc2c526dd4d121c95d4a25a2fc928a87cd80f8448988185f", + "size_in_bytes": 14132 + }, + { + "_path": "Lib/encodings/cp424.py", + "path_type": "hardlink", + "sha256": "30414c2186ea0802bbf3db034122ddec1f8a10061b97c50871e14b74ee36d0ca", + "size_in_bytes": 12055 + }, + { + "_path": "Lib/encodings/cp437.py", + "path_type": "hardlink", + "sha256": "5c2a5015cd36cf7f561269f33dec4c323093d3d88b0673969accdabdcb9ce2cb", + "size_in_bytes": 34564 + }, + { + "_path": "Lib/encodings/cp500.py", + "path_type": "hardlink", + "sha256": "630f503f9110d98ea3e1529f2f965ebc275a2f78d3de47f8e9b69d35589d764b", + "size_in_bytes": 13121 + }, + { + "_path": "Lib/encodings/cp720.py", + "path_type": "hardlink", + "sha256": "395496001271b92efe5df07fc0ae7c3410d1dd2bdfebbd3e4d8e806c8166beb0", + "size_in_bytes": 13686 + }, + { + "_path": "Lib/encodings/cp737.py", + "path_type": "hardlink", + "sha256": "be3ca1785a3970ec62310710eaf7de82932181b04d06fe4528f8adaba9fb8c4b", + "size_in_bytes": 34681 + }, + { + "_path": "Lib/encodings/cp775.py", + "path_type": "hardlink", + "sha256": "e0dba85b99329d7f16907e620adada06be5216abcb964406c827b569b2cf1aeb", + "size_in_bytes": 34476 + }, + { + "_path": "Lib/encodings/cp850.py", + "path_type": "hardlink", + "sha256": "257e29f235e2a8790dd68cee45668776648bab809ce8584f893cdd8fd007993c", + "size_in_bytes": 34105 + }, + { + "_path": "Lib/encodings/cp852.py", + "path_type": "hardlink", + "sha256": "cc6faaa9dc4a933127da0aaacd1dc7a44c09266051af56bfe3215ff228636b6b", + "size_in_bytes": 35002 + }, + { + "_path": "Lib/encodings/cp855.py", + "path_type": "hardlink", + "sha256": "7b25c61c9e8c47b218d3fbb801541a2861926ac712843d2113fff90e2074f5ba", + "size_in_bytes": 33850 + }, + { + "_path": "Lib/encodings/cp856.py", + "path_type": "hardlink", + "sha256": "2e52ec5cb1eafa6739b5569b0b98ee89df5f7358b84ccdc8da64e86f017d359f", + "size_in_bytes": 12423 + }, + { + "_path": "Lib/encodings/cp857.py", + "path_type": "hardlink", + "sha256": "8d1b769058bfccdb3c6c70c49a104f5081a2fcc9fad68f7b5eb3e4f67f0b33da", + "size_in_bytes": 33908 + }, + { + "_path": "Lib/encodings/cp858.py", + "path_type": "hardlink", + "sha256": "a24930c4a6ad0ff66dde9a69f2027e4b92c2c9c61dcda2992e940654c606577b", + "size_in_bytes": 34015 + }, + { + "_path": "Lib/encodings/cp860.py", + "path_type": "hardlink", + "sha256": "2dfae7e31d3d9aa3013cff44a4d7ad842f257ac63765a9998436701b629cd86a", + "size_in_bytes": 34681 + }, + { + "_path": "Lib/encodings/cp861.py", + "path_type": "hardlink", + "sha256": "701930d77a2177497586e99bc3fe60f2d4beffb645608f167c76874a72ff405e", + "size_in_bytes": 34633 + }, + { + "_path": "Lib/encodings/cp862.py", + "path_type": "hardlink", + "sha256": "15a2844b6ed9544c6400cf7299b42d0c2bef93c9bee70a9e89f66b8610ad6d6d", + "size_in_bytes": 33370 + }, + { + "_path": "Lib/encodings/cp863.py", + "path_type": "hardlink", + "sha256": "a3d57f61fce1b98fc81ea8e4ebebaf402fae40bbcdd35d4b8297b9bb49a79aa2", + "size_in_bytes": 34252 + }, + { + "_path": "Lib/encodings/cp864.py", + "path_type": "hardlink", + "sha256": "15ad8f1fdfdd842c7522241372e7eddda7df687e815692a89157c5f256f21a08", + "size_in_bytes": 33663 + }, + { + "_path": "Lib/encodings/cp865.py", + "path_type": "hardlink", + "sha256": "bdbaded987242ed2a8de7133ec2f61ddcc1c2e9de27816ab7cd0a4c678a3a907", + "size_in_bytes": 34618 + }, + { + "_path": "Lib/encodings/cp866.py", + "path_type": "hardlink", + "sha256": "9efcc8e85bbd1687272a0991f6d0429a4c06679db2d114b2ac95db27a70f9d13", + "size_in_bytes": 34396 + }, + { + "_path": "Lib/encodings/cp869.py", + "path_type": "hardlink", + "sha256": "52582d9fb769b24eac7154f18d7dae856588297d6da98f37fb5efd8da883826d", + "size_in_bytes": 32965 + }, + { + "_path": "Lib/encodings/cp874.py", + "path_type": "hardlink", + "sha256": "fe4752fa2e65741e08a563a31ff914fe71068942ce9c6f4070b1dfd7b25e5e7f", + "size_in_bytes": 12595 + }, + { + "_path": "Lib/encodings/cp875.py", + "path_type": "hardlink", + "sha256": "2fe72632015db2cba2bb4367055551da6fe22051b96d170c7b96fa271c46b257", + "size_in_bytes": 12854 + }, + { + "_path": "Lib/encodings/cp932.py", + "path_type": "hardlink", + "sha256": "99748e28113d2d49f5d666b49b78accd2c6e10a7852f7dd6dece9b5b71aa83c4", + "size_in_bytes": 1023 + }, + { + "_path": "Lib/encodings/cp949.py", + "path_type": "hardlink", + "sha256": "950a7d29467ce0590b4a1137830d43d88d8f20e4035dcaaa8b2a5c3c3f1de962", + "size_in_bytes": 1023 + }, + { + "_path": "Lib/encodings/cp950.py", + "path_type": "hardlink", + "sha256": "27811178b450731fc955b1247656a605d04e5ee98e0d585e4596b94b703a27f6", + "size_in_bytes": 1023 + }, + { + "_path": "Lib/encodings/euc_jis_2004.py", + "path_type": "hardlink", + "sha256": "9fa426cd9f17629f6320700ed18baa94839304cf1bcabbee7edb501747dc055d", + "size_in_bytes": 1051 + }, + { + "_path": "Lib/encodings/euc_jisx0213.py", + "path_type": "hardlink", + "sha256": "e28315910da20218dae8b7d5becd81de1e283dfd8b0415a4980d67065de73a0b", + "size_in_bytes": 1051 + }, + { + "_path": "Lib/encodings/euc_jp.py", + "path_type": "hardlink", + "sha256": "b453a439787b0efa031e43416a7d852a6be705c985e1200693eb96d87ea79cdc", + "size_in_bytes": 1027 + }, + { + "_path": "Lib/encodings/euc_kr.py", + "path_type": "hardlink", + "sha256": "633a1a5504bfad04b1ec9c96d44d4ebb3bb99066a218318e7d67d866e20887a6", + "size_in_bytes": 1027 + }, + { + "_path": "Lib/encodings/gb18030.py", + "path_type": "hardlink", + "sha256": "6c10b4dc49bc63724e539137ede6936304fcca1c97c28d16d89f381e10849521", + "size_in_bytes": 1031 + }, + { + "_path": "Lib/encodings/gb2312.py", + "path_type": "hardlink", + "sha256": "3d2d567d8d079b78f3f3b566ed52ad2f38af61bf832b7dc28858b0039a032d6b", + "size_in_bytes": 1027 + }, + { + "_path": "Lib/encodings/gbk.py", + "path_type": "hardlink", + "sha256": "eff9b8cbc9ad2ef2e10e96afa83d3db1f775ea044aed275b7a35574ae0d8645b", + "size_in_bytes": 1015 + }, + { + "_path": "Lib/encodings/hex_codec.py", + "path_type": "hardlink", + "sha256": "fc5f0a31b59efe990b86efb98936769f33dd91d912ce55b49a5a4cfc516cd047", + "size_in_bytes": 1508 + }, + { + "_path": "Lib/encodings/hp_roman8.py", + "path_type": "hardlink", + "sha256": "c43cce763d12e8f71a63dbc16641bd87147eaf5f9d9054ea856864b216b2735b", + "size_in_bytes": 13475 + }, + { + "_path": "Lib/encodings/hz.py", + "path_type": "hardlink", + "sha256": "025a9531e3046e52d3e039c0be04f9a5a74651d7683a13c7c7ebd4c7dfb5996a", + "size_in_bytes": 1011 + }, + { + "_path": "Lib/encodings/idna.py", + "path_type": "hardlink", + "sha256": "4fc5a79f53d60fd0576f94dfe8aa7677357d9ad95315ea220ba523f53c89229b", + "size_in_bytes": 9098 + }, + { + "_path": "Lib/encodings/iso2022_jp.py", + "path_type": "hardlink", + "sha256": "461a0e7f72eccb8b29f351c4e7926cfbda58e0edd6d0770bd82e0b36c5febe77", + "size_in_bytes": 1053 + }, + { + "_path": "Lib/encodings/iso2022_jp_1.py", + "path_type": "hardlink", + "sha256": "63bacad13a979a5519fcaa4f1e1e07b2c7415005167fac3a689408c7d886fabd", + "size_in_bytes": 1061 + }, + { + "_path": "Lib/encodings/iso2022_jp_2.py", + "path_type": "hardlink", + "sha256": "5d4248181548b0fc89a9f5ee9cf52ebecb235708ba87d47896ad14130884ef9f", + "size_in_bytes": 1061 + }, + { + "_path": "Lib/encodings/iso2022_jp_2004.py", + "path_type": "hardlink", + "sha256": "b4d1468bcd608b46f38cb0c6ef115510dcf9aa0f71e590792f407efc6e165164", + "size_in_bytes": 1073 + }, + { + "_path": "Lib/encodings/iso2022_jp_3.py", + "path_type": "hardlink", + "sha256": "3aceaa5661909de14e2861d864443b8472460ce39b99cce5c6965346d47aa5ac", + "size_in_bytes": 1061 + }, + { + "_path": "Lib/encodings/iso2022_jp_ext.py", + "path_type": "hardlink", + "sha256": "f4c9ed8f3031995faa224bcb10153d2b6144944477d1f27d1a6cc4a879fac34c", + "size_in_bytes": 1069 + }, + { + "_path": "Lib/encodings/iso2022_kr.py", + "path_type": "hardlink", + "sha256": "1c86362e17944f0bcf68db02f4995bdeea605867795fff7ab4079073f96705e4", + "size_in_bytes": 1053 + }, + { + "_path": "Lib/encodings/iso8859_1.py", + "path_type": "hardlink", + "sha256": "b5cebd515e057d670bf54e10b8a6f162ef3daa7f21b146aee3249160caf3c32d", + "size_in_bytes": 13176 + }, + { + "_path": "Lib/encodings/iso8859_10.py", + "path_type": "hardlink", + "sha256": "54c886b41819ebb7f4fb34b8dbae1c45f4fc0864f019ecd772676ccfac5fae7b", + "size_in_bytes": 13589 + }, + { + "_path": "Lib/encodings/iso8859_11.py", + "path_type": "hardlink", + "sha256": "ed5a964470a241b4da7a6cfb718e4149d09644933af38f0497602baab6e563ef", + "size_in_bytes": 12335 + }, + { + "_path": "Lib/encodings/iso8859_13.py", + "path_type": "hardlink", + "sha256": "7312237e8e5d201d920b4130f057cfdf1b0be9baafaa246826e6d93204fcc206", + "size_in_bytes": 13271 + }, + { + "_path": "Lib/encodings/iso8859_14.py", + "path_type": "hardlink", + "sha256": "82778b995a0ee87c5f1180fcc52900359eee15bd9a6e3a0e25f0d963e0b2a343", + "size_in_bytes": 13652 + }, + { + "_path": "Lib/encodings/iso8859_15.py", + "path_type": "hardlink", + "sha256": "01976a81811873dc9a0c79db9fc00d1c30103487f3c6bc3a6d81b4043cd48e02", + "size_in_bytes": 13212 + }, + { + "_path": "Lib/encodings/iso8859_16.py", + "path_type": "hardlink", + "sha256": "b5ac8f5a5d8f84c0f903b2b7c342184758d590d8bcf810d561f942fe5b372d66", + "size_in_bytes": 13557 + }, + { + "_path": "Lib/encodings/iso8859_2.py", + "path_type": "hardlink", + "sha256": "2b57cab6111cae9021505e3ae1b2adbbfc344ec48165fda322f6b069fbb18adc", + "size_in_bytes": 13404 + }, + { + "_path": "Lib/encodings/iso8859_3.py", + "path_type": "hardlink", + "sha256": "4ffdf89004bf0c5230caa7079f7ca3142fc112f8b923ddb2c7358369d2d3c242", + "size_in_bytes": 13089 + }, + { + "_path": "Lib/encodings/iso8859_4.py", + "path_type": "hardlink", + "sha256": "87bd130daa0eaef3e4cb465e10cffb2bcd194ff74097e0c186b4b8eb7be41ac5", + "size_in_bytes": 13376 + }, + { + "_path": "Lib/encodings/iso8859_5.py", + "path_type": "hardlink", + "sha256": "9961d96cc7b9fdf011ebcaaeaeca7b50b8670fadbd7b75fde66192f8c1f68f30", + "size_in_bytes": 13015 + }, + { + "_path": "Lib/encodings/iso8859_6.py", + "path_type": "hardlink", + "sha256": "4840e68014346517680f593ca22f67133c39ba7e46f34b9be62c980a728448c6", + "size_in_bytes": 10833 + }, + { + "_path": "Lib/encodings/iso8859_7.py", + "path_type": "hardlink", + "sha256": "b352eca3b819488f64fb3338fd93f39c1e30f32bb13f2f9c577925e58f2960e4", + "size_in_bytes": 12844 + }, + { + "_path": "Lib/encodings/iso8859_8.py", + "path_type": "hardlink", + "sha256": "4cf9e8a8bbe04accb1c1a80853efb19ae0772d18f81e270adefc1b2386cb368e", + "size_in_bytes": 11036 + }, + { + "_path": "Lib/encodings/iso8859_9.py", + "path_type": "hardlink", + "sha256": "84d9b15263e81685f7513c5ab45caf80b2f73c301c68e659f7162c1b1882d359", + "size_in_bytes": 13156 + }, + { + "_path": "Lib/encodings/johab.py", + "path_type": "hardlink", + "sha256": "9586615917afd3d848c1c4328656603b2834af6115f2aec932fccc935e1a60fb", + "size_in_bytes": 1023 + }, + { + "_path": "Lib/encodings/koi8_r.py", + "path_type": "hardlink", + "sha256": "4d4e353aee8039bb71e2145a6e68fe1e6833a1b4250b70ee0ac5ec70bbb8c51d", + "size_in_bytes": 13779 + }, + { + "_path": "Lib/encodings/koi8_t.py", + "path_type": "hardlink", + "sha256": "9c9043814abdbe7dc39ff98f3857d5d110a84c978ad2304158d810a4e9eacef1", + "size_in_bytes": 13193 + }, + { + "_path": "Lib/encodings/koi8_u.py", + "path_type": "hardlink", + "sha256": "d449f9858e357fa8c2edbd4b9fe739337e9f201cac3ded20f99bfcecd4970ff7", + "size_in_bytes": 13762 + }, + { + "_path": "Lib/encodings/kz1048.py", + "path_type": "hardlink", + "sha256": "76beb30e98a911f72f97609a2373782573c17c88a5fb3537db338aa382979ffc", + "size_in_bytes": 13723 + }, + { + "_path": "Lib/encodings/latin_1.py", + "path_type": "hardlink", + "sha256": "b75503e532a27c636477396c855209ff5f3036536d2a4bede0a576c89382b60c", + "size_in_bytes": 1264 + }, + { + "_path": "Lib/encodings/mac_arabic.py", + "path_type": "hardlink", + "sha256": "5eafd9a3136abfbd8ed52df9c90203c7a283e7429ed60502a87a02511e0fb777", + "size_in_bytes": 36467 + }, + { + "_path": "Lib/encodings/mac_croatian.py", + "path_type": "hardlink", + "sha256": "a880cd05c82a8d11a29c65ee86a396def3344465dd71441b0bb4a73826024953", + "size_in_bytes": 13633 + }, + { + "_path": "Lib/encodings/mac_cyrillic.py", + "path_type": "hardlink", + "sha256": "83616786a1c6308b03a0dc82536908d24d0974b2248d67393d613fe558cea4bd", + "size_in_bytes": 13454 + }, + { + "_path": "Lib/encodings/mac_farsi.py", + "path_type": "hardlink", + "sha256": "f5763c38fb4ab0423fafe2fdca34d6f9932ac7f1a74c0cd8109d60234c7dc624", + "size_in_bytes": 15170 + }, + { + "_path": "Lib/encodings/mac_greek.py", + "path_type": "hardlink", + "sha256": "63016a323ddf98cb3aa9cfa78f3bab4768bedbfe9a5262a36a5aecb13d291f6e", + "size_in_bytes": 13721 + }, + { + "_path": "Lib/encodings/mac_iceland.py", + "path_type": "hardlink", + "sha256": "753cc1ac635caa7e1b4630fbcebef8db8db332c098154a5b11f652912bf64f37", + "size_in_bytes": 13498 + }, + { + "_path": "Lib/encodings/mac_latin2.py", + "path_type": "hardlink", + "sha256": "31670da18ce8b5394cd53fe6bf216268e7e8eae4c0247532e420e2e103727d50", + "size_in_bytes": 14118 + }, + { + "_path": "Lib/encodings/mac_roman.py", + "path_type": "hardlink", + "sha256": "230367d96aef8e8d7f185b4acfb84923714f39ddbcbf9cf38a06bf6f5d621c22", + "size_in_bytes": 13480 + }, + { + "_path": "Lib/encodings/mac_romanian.py", + "path_type": "hardlink", + "sha256": "49630cf035c19e896a123ed6e5fee18b5e485123daf2f15da38bf727ff387bee", + "size_in_bytes": 13661 + }, + { + "_path": "Lib/encodings/mac_turkish.py", + "path_type": "hardlink", + "sha256": "99758a5cad2825cb3be3fa5d031e0821e4eba910a46f417fd890207b9b6be77b", + "size_in_bytes": 13513 + }, + { + "_path": "Lib/encodings/mbcs.py", + "path_type": "hardlink", + "sha256": "f6ed445ed537c9f856d8defe8b56505727737d0dc9348d0a877abedab4bdd864", + "size_in_bytes": 1211 + }, + { + "_path": "Lib/encodings/oem.py", + "path_type": "hardlink", + "sha256": "481656d3a35f792d0e5109e3f821e6dbfcf097163a19b0cdfcbff3b3db99292f", + "size_in_bytes": 1019 + }, + { + "_path": "Lib/encodings/palmos.py", + "path_type": "hardlink", + "sha256": "eccf7418adefcc2a59e9a07fc4e34363bd62f7e878d48c8a02730a8ed1c584c8", + "size_in_bytes": 13519 + }, + { + "_path": "Lib/encodings/ptcp154.py", + "path_type": "hardlink", + "sha256": "0eabcb2c287d335e86b71b0abe5718bd6ddc9aaee234f0f0f2363845d2926d8d", + "size_in_bytes": 14015 + }, + { + "_path": "Lib/encodings/punycode.py", + "path_type": "hardlink", + "sha256": "34edc8fb1c50e4d1cbaa1e008bb491cd7c12116c316e51974f333fe7b628eb7c", + "size_in_bytes": 6883 + }, + { + "_path": "Lib/encodings/quopri_codec.py", + "path_type": "hardlink", + "sha256": "502a213c34c05a94ed063ee03f47680bd6efbb35036e06fb4dc809bf398cfa64", + "size_in_bytes": 1525 + }, + { + "_path": "Lib/encodings/raw_unicode_escape.py", + "path_type": "hardlink", + "sha256": "fa6328486b8f5a5cbd10e377e80adb8cf94acbbe19c38b4e1bf708d831a80a3a", + "size_in_bytes": 1332 + }, + { + "_path": "Lib/encodings/rot_13.py", + "path_type": "hardlink", + "sha256": "14767f475acdc0bf48e6272280dd15b80efaecafb93c06be21136f83dd1ee7e4", + "size_in_bytes": 2448 + }, + { + "_path": "Lib/encodings/shift_jis.py", + "path_type": "hardlink", + "sha256": "ad4ac50ebf58294304e412cc0f1b12980988dd6edc414e4110029c0a1abbe966", + "size_in_bytes": 1039 + }, + { + "_path": "Lib/encodings/shift_jis_2004.py", + "path_type": "hardlink", + "sha256": "d21c5930f21063ea78fea3b0f76dfb8fd92858d2a4a200064a52126a43dd1a99", + "size_in_bytes": 1059 + }, + { + "_path": "Lib/encodings/shift_jisx0213.py", + "path_type": "hardlink", + "sha256": "2c8d0b93bb36edf31c1236b1b4d1c0008553868bd2fc9137570115b96b834f2e", + "size_in_bytes": 1059 + }, + { + "_path": "Lib/encodings/tis_620.py", + "path_type": "hardlink", + "sha256": "647c4719e2c1a7375105e15a89b377c66f6b699977dcabbb71d923a4607b7902", + "size_in_bytes": 12300 + }, + { + "_path": "Lib/encodings/undefined.py", + "path_type": "hardlink", + "sha256": "85bba5c5e1007cd8c1ade5c0214bcc825396d2bbd02054e62a9f162104748b64", + "size_in_bytes": 1299 + }, + { + "_path": "Lib/encodings/unicode_escape.py", + "path_type": "hardlink", + "sha256": "507e7ca8f18df639fd823d7cc23ce4028a3550ceefdfa40b3c76f81d1a94531d", + "size_in_bytes": 1304 + }, + { + "_path": "Lib/encodings/utf_16.py", + "path_type": "hardlink", + "sha256": "6c36257f7b8d214473560d195e71bccef0c69a53e1e52d2800b7a7890aad7e58", + "size_in_bytes": 5236 + }, + { + "_path": "Lib/encodings/utf_16_be.py", + "path_type": "hardlink", + "sha256": "3357196f3fa52433326a6626880e34964e00c5570aee50e9a0a0a7c6d86f6e4f", + "size_in_bytes": 1037 + }, + { + "_path": "Lib/encodings/utf_16_le.py", + "path_type": "hardlink", + "sha256": "3aedaf3eb49769282daef1eaedfd4fa1c31fe5eebeff67fe2307c89dc2e2fd80", + "size_in_bytes": 1037 + }, + { + "_path": "Lib/encodings/utf_32.py", + "path_type": "hardlink", + "sha256": "2072eece5f6026ad2d3549ab193a9e38894ea15ca9d5b3cd408fd6b116acc0c2", + "size_in_bytes": 5129 + }, + { + "_path": "Lib/encodings/utf_32_be.py", + "path_type": "hardlink", + "sha256": "cbba20e1f6d0879c7c4293446c371a9f79e7c90bf3c78a77a9b8fc72b18915dd", + "size_in_bytes": 930 + }, + { + "_path": "Lib/encodings/utf_32_le.py", + "path_type": "hardlink", + "sha256": "9134b91047d85b442898d59effe23e7e0cf4167ca341ae31119a731dbf880a7b", + "size_in_bytes": 930 + }, + { + "_path": "Lib/encodings/utf_7.py", + "path_type": "hardlink", + "sha256": "9ff32314f4f1fa074f206bbf7fdb851504e5313128636d73b4bf75b886e4a87d", + "size_in_bytes": 946 + }, + { + "_path": "Lib/encodings/utf_8.py", + "path_type": "hardlink", + "sha256": "ba0cac060269583523ca9506473a755203037c57d466a11aa89a30a5f6756f3d", + "size_in_bytes": 1005 + }, + { + "_path": "Lib/encodings/utf_8_sig.py", + "path_type": "hardlink", + "sha256": "1ef3da8d8aa08149e7f274dc64dbfce2155da812e5258ca8e8f832428d3b5c2d", + "size_in_bytes": 4133 + }, + { + "_path": "Lib/encodings/uu_codec.py", + "path_type": "hardlink", + "sha256": "45ba92000718abf85f158563c755205e100356ce1b4ab9444b4d0a3d21f061a3", + "size_in_bytes": 2851 + }, + { + "_path": "Lib/encodings/zlib_codec.py", + "path_type": "hardlink", + "sha256": "6ef01e8d3a5fe1cc52f7b5ae008df12f1dbce7304111bf8d4758f1bfc0115759", + "size_in_bytes": 2204 + }, + { + "_path": "Lib/ensurepip/__init__.py", + "path_type": "hardlink", + "sha256": "0f4e3b95882c914577a9045e27ac88f78d9a0a931a409d3d0287df1cd49e945a", + "size_in_bytes": 9651 + }, + { + "_path": "Lib/ensurepip/__main__.py", + "path_type": "hardlink", + "sha256": "ee735f518d0fc4dfec81f7aa3da1e052372ed4202c0da4eddd2587840beaecd7", + "size_in_bytes": 88 + }, + { + "_path": "Lib/ensurepip/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8c93197f5cbaed7caeda637c22461994c1a1b95b0d519152891468c0cc953ec1", + "size_in_bytes": 10732 + }, + { + "_path": "Lib/ensurepip/__pycache__/__main__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "97c1f547209cc802aa0effbb10cdaceb47a832aea82ff4bc9664ebcd8adc3095", + "size_in_bytes": 339 + }, + { + "_path": "Lib/ensurepip/__pycache__/_uninstall.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "11f47de80f8d8702005475b4e856db0b62cb319917a857448e03eba7053c09a2", + "size_in_bytes": 1438 + }, + { + "_path": "Lib/ensurepip/_bundled/pip-24.0-py3-none-any.whl", + "path_type": "hardlink", + "sha256": "ba0d021a166865d2265246961bec0152ff124de910c5cc39f1156ce3fa7c69dc", + "size_in_bytes": 2110226 + }, + { + "_path": "Lib/ensurepip/_bundled/setuptools-79.0.1-py3-none-any.whl", + "path_type": "hardlink", + "sha256": "e147c0549f27767ba362f9da434eab9c5dc0045d5304feb602a0af001089fc51", + "size_in_bytes": 1256281 + }, + { + "_path": "Lib/ensurepip/_uninstall.py", + "path_type": "hardlink", + "sha256": "3a6e95d01c45e2e47c05df3c81073b895c97c1eb0e5b90ab175d6d9263fc81f2", + "size_in_bytes": 808 + }, + { + "_path": "Lib/enum.py", + "path_type": "hardlink", + "sha256": "01addb65722daecee235caf6b345e4a910b1882aacc29e4fb846e0e0904043e6", + "size_in_bytes": 79583 + }, + { + "_path": "Lib/filecmp.py", + "path_type": "hardlink", + "sha256": "178f19895fdd43d5d3865b2bfe9ae7b665611a30d29cfc23d44f01417774851c", + "size_in_bytes": 10178 + }, + { + "_path": "Lib/fileinput.py", + "path_type": "hardlink", + "sha256": "b0cd2a3f01c96f594b6038e52bd83d489bfa081cc757103c70aab4e5b2c4fe1f", + "size_in_bytes": 15714 + }, + { + "_path": "Lib/fnmatch.py", + "path_type": "hardlink", + "sha256": "6683da36e47af523f3f41e18ad244d837783e19e98911cc0b7415dea81494ebc", + "size_in_bytes": 5999 + }, + { + "_path": "Lib/fractions.py", + "path_type": "hardlink", + "sha256": "d52a647a86a32e1905d38fe7a19cf200291f598dc4ed51273ac27f38723fb559", + "size_in_bytes": 28677 + }, + { + "_path": "Lib/ftplib.py", + "path_type": "hardlink", + "sha256": "34803cb5f29800e436584146de073ed78dc62b4ba199cb1d892b62e3d35e2144", + "size_in_bytes": 35815 + }, + { + "_path": "Lib/functools.py", + "path_type": "hardlink", + "sha256": "6d80018a3fa9fed44c5b78f881987ee3ab3fb1238b077b4e6dcb4b76da7db73b", + "size_in_bytes": 38413 + }, + { + "_path": "Lib/genericpath.py", + "path_type": "hardlink", + "sha256": "34497be8d2eb70df61e94cb2ee1938433145c977a56b36be37cc41a3a71d32c2", + "size_in_bytes": 5246 + }, + { + "_path": "Lib/getopt.py", + "path_type": "hardlink", + "sha256": "efafb88c7c978e96bd6c232b7fa10bf50cef5e7fb0fb7dc8e5bce44e19f8c92f", + "size_in_bytes": 7489 + }, + { + "_path": "Lib/getpass.py", + "path_type": "hardlink", + "sha256": "e74fd445337ff503223dd8aa4bdd7d04917067d00c796a10bedb7a1381a4960a", + "size_in_bytes": 5990 + }, + { + "_path": "Lib/gettext.py", + "path_type": "hardlink", + "sha256": "a5c249a522b6b8e3aa6f1b12a8bcc09508b99ad612b58d2fc973db27ea3b7cc3", + "size_in_bytes": 21320 + }, + { + "_path": "Lib/glob.py", + "path_type": "hardlink", + "sha256": "c9e5f9ae0752660ede63328a456f58f87c29500b31f58c1b813458b00fceb6d5", + "size_in_bytes": 8732 + }, + { + "_path": "Lib/graphlib.py", + "path_type": "hardlink", + "sha256": "7bd338c5a475d1101064603d3baa5507446d3c5e73f741f6d6e77c6204c1eb65", + "size_in_bytes": 9656 + }, + { + "_path": "Lib/gzip.py", + "path_type": "hardlink", + "sha256": "8e0a7f850ef481fea41e0de9b52b4a014573b58e500ae83b92e5888d7a061008", + "size_in_bytes": 24074 + }, + { + "_path": "Lib/hashlib.py", + "path_type": "hardlink", + "sha256": "e2bffb462e4d43e6637b9450e259e8ba2a56626ba3037d68aa1cee68b3f61d4a", + "size_in_bytes": 11765 + }, + { + "_path": "Lib/heapq.py", + "path_type": "hardlink", + "sha256": "6d43277e5c76fc0f073cd388fcff852d14d068f6bb6d4886c340f8b75a1229a9", + "size_in_bytes": 23024 + }, + { + "_path": "Lib/hmac.py", + "path_type": "hardlink", + "sha256": "7facd1330e5487ed995eda5c8619df0d3e32f69cb619f97662372fb76325746e", + "size_in_bytes": 7716 + }, + { + "_path": "Lib/html/__init__.py", + "path_type": "hardlink", + "sha256": "923d82d821e75e8d235392c10c145ab8587927b3faf9c952bbd48081eebd8522", + "size_in_bytes": 4775 + }, + { + "_path": "Lib/html/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2f5f3089ae7107247be7a4e6d2001899ace23a92c6ddc55d907aa95717831dce", + "size_in_bytes": 4791 + }, + { + "_path": "Lib/html/__pycache__/entities.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "66862e450fb77d005e0fbd9ac8ea8e7bded95cde8c8d04d2bff048a186d2a0bf", + "size_in_bytes": 99427 + }, + { + "_path": "Lib/html/__pycache__/parser.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "bf22a40ae6238a6544d3b002c392099b82d444929a888108f464d39c68763572", + "size_in_bytes": 23816 + }, + { + "_path": "Lib/html/entities.py", + "path_type": "hardlink", + "sha256": "282b7cdd567bbbf3d7d7ccd49fae1d3ebc7f7ab64058d781193620913773731b", + "size_in_bytes": 75383 + }, + { + "_path": "Lib/html/parser.py", + "path_type": "hardlink", + "sha256": "9f27e8d38ce42c0b34f39fb1686f9c5249209e52bfd7207875b6f1613accce85", + "size_in_bytes": 20850 + }, + { + "_path": "Lib/http/__init__.py", + "path_type": "hardlink", + "sha256": "fec3d2f335260c6da338cc45955b053e80039a9611ef2651519724f84def641c", + "size_in_bytes": 7913 + }, + { + "_path": "Lib/http/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3fa48f92808812944dad62f606fbae12a8eba1744001be3b010b4876e8c0143c", + "size_in_bytes": 8715 + }, + { + "_path": "Lib/http/__pycache__/client.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "be07f4da95ac34db347698027f91e1593a3ce38955c103e22193b2d421995a26", + "size_in_bytes": 62098 + }, + { + "_path": "Lib/http/__pycache__/cookiejar.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ac7fb4e9ace5b7413a35e3684d77a02fc2d4d59ef2b661baac9766b5e67df925", + "size_in_bytes": 88125 + }, + { + "_path": "Lib/http/__pycache__/cookies.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "344e156e06f968dc73f2705efba98b015e892dce303c13772325d0d7a5cb6333", + "size_in_bytes": 24013 + }, + { + "_path": "Lib/http/__pycache__/server.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "008820066b3fcfa5cd38dd073204449ff3a17a66153ee35eabd1bf0721283f4b", + "size_in_bytes": 60748 + }, + { + "_path": "Lib/http/client.py", + "path_type": "hardlink", + "sha256": "a6c48f3709b451fd3a11265e03b9750b9749684fb7321471d825cdde7f7ba806", + "size_in_bytes": 58284 + }, + { + "_path": "Lib/http/cookiejar.py", + "path_type": "hardlink", + "sha256": "9587a95edc194a19513e8a8fa9a942cd9fe6217489697ee998a7ae544fb9d603", + "size_in_bytes": 77517 + }, + { + "_path": "Lib/http/cookies.py", + "path_type": "hardlink", + "sha256": "9b73cfcda37f146b5302d63ab0852da67042adb52695699f61a3df764e1fc78c", + "size_in_bytes": 20743 + }, + { + "_path": "Lib/http/server.py", + "path_type": "hardlink", + "sha256": "44ff36aff5367692b887b5943280750af95beb227fe0ed47aebc4d269e13a916", + "size_in_bytes": 49150 + }, + { + "_path": "Lib/idlelib/CREDITS.txt", + "path_type": "hardlink", + "sha256": "33e6a36056667d40e26f195c14371567470f53324c3fec43aec29e09d7d2a60b", + "size_in_bytes": 2152 + }, + { + "_path": "Lib/idlelib/ChangeLog", + "path_type": "hardlink", + "sha256": "b7f42699e5e5a7c82ebdf2a2962946b7228c933ece0ea7c0d7789f21a7dd7e64", + "size_in_bytes": 56360 + }, + { + "_path": "Lib/idlelib/HISTORY.txt", + "path_type": "hardlink", + "sha256": "531067a78ad392f25631aba1d885f40786cf5f47854577162c9f90ff1f33164c", + "size_in_bytes": 10312 + }, + { + "_path": "Lib/idlelib/Icons/README.txt", + "path_type": "hardlink", + "sha256": "60399d6129e3e486ce6b437bbf614ff4838bd4e7f42d461c3e5467cf3b4fa272", + "size_in_bytes": 443 + }, + { + "_path": "Lib/idlelib/Icons/folder.gif", + "path_type": "hardlink", + "sha256": "7c98d566a13fd599d1c11a375f387fef69b6c595c4f18c5d88c188a860be0e55", + "size_in_bytes": 120 + }, + { + "_path": "Lib/idlelib/Icons/idle.ico", + "path_type": "hardlink", + "sha256": "7f13eeb5dca39d05e24b9eb069c6dcb2748633822d67288a8bf8b7e21cdddf55", + "size_in_bytes": 57746 + }, + { + "_path": "Lib/idlelib/Icons/idle_16.gif", + "path_type": "hardlink", + "sha256": "fe3af292b38660a8a58b1a8b4fa4240aa190602e7e9a700ea0536b3181fc968e", + "size_in_bytes": 634 + }, + { + "_path": "Lib/idlelib/Icons/idle_16.png", + "path_type": "hardlink", + "sha256": "78fb3fb0ec11f61bc6cf0947f3c3923aa18e1c6513684058ed0fa01ac858143e", + "size_in_bytes": 1031 + }, + { + "_path": "Lib/idlelib/Icons/idle_256.png", + "path_type": "hardlink", + "sha256": "3f517467d12e0e3ecf20f9bd68ce4bd18a2b8088f32308fd978fd80e87d3628b", + "size_in_bytes": 39205 + }, + { + "_path": "Lib/idlelib/Icons/idle_32.gif", + "path_type": "hardlink", + "sha256": "fe70991cfccd1267922e94d91e02e9a58d2d29fd3382a2f4975280b9023cb7b9", + "size_in_bytes": 1019 + }, + { + "_path": "Lib/idlelib/Icons/idle_32.png", + "path_type": "hardlink", + "sha256": "797cd05f1964d57c4c6c248ac7f7ea6a38019ada32a9ab7e6c28d060f87b03de", + "size_in_bytes": 2036 + }, + { + "_path": "Lib/idlelib/Icons/idle_48.gif", + "path_type": "hardlink", + "sha256": "37484901eb40eefa846308e1da3ff6f240ea98f769a2afc3cf4fdba00327ecbe", + "size_in_bytes": 1388 + }, + { + "_path": "Lib/idlelib/Icons/idle_48.png", + "path_type": "hardlink", + "sha256": "a09f433197c8870b12bb7859cc4c3fe2068908cb1ddbd4880ab0f6fee91b6c23", + "size_in_bytes": 3977 + }, + { + "_path": "Lib/idlelib/Icons/minusnode.gif", + "path_type": "hardlink", + "sha256": "efa5aa1d1e3439ab85425bd2aa3a25b9e6c21309e672690cfb32219e1eb7a7f3", + "size_in_bytes": 75 + }, + { + "_path": "Lib/idlelib/Icons/openfolder.gif", + "path_type": "hardlink", + "sha256": "9a59e2abf1840156e9db8f85a38822fd56ab79a139eb95ec86f1fba1bb87326b", + "size_in_bytes": 125 + }, + { + "_path": "Lib/idlelib/Icons/plusnode.gif", + "path_type": "hardlink", + "sha256": "6ace9e90a2bcb16d06c4d78837137f2c14bc26b3bd9f24b7b6afeadb689bdafb", + "size_in_bytes": 78 + }, + { + "_path": "Lib/idlelib/Icons/python.gif", + "path_type": "hardlink", + "sha256": "158c31382f8e5b41fded0c2aa9cc66a382928b003cdd8b5b0518836ad9c89377", + "size_in_bytes": 380 + }, + { + "_path": "Lib/idlelib/Icons/tk.gif", + "path_type": "hardlink", + "sha256": "7f16cb2e322891dbd9101302c09ffda0c2a3a72d053bb8c0927d507414c59cad", + "size_in_bytes": 72 + }, + { + "_path": "Lib/idlelib/NEWS2x.txt", + "path_type": "hardlink", + "sha256": "c89a3b513501ebace8e428aea68dce39d0af9f29196e08fc9ea49c99605e79e7", + "size_in_bytes": 27172 + }, + { + "_path": "Lib/idlelib/News3.txt", + "path_type": "hardlink", + "sha256": "ac8bf0e6cc500f17b0a3c784d1ea5939c19a9d5811435d05a90b392504b60dc5", + "size_in_bytes": 55422 + }, + { + "_path": "Lib/idlelib/README.txt", + "path_type": "hardlink", + "sha256": "4f2dc8ffdbfc7837b60edc32ac2f593a220f4abf0ea00cc477382ad8ecf8eb3d", + "size_in_bytes": 11653 + }, + { + "_path": "Lib/idlelib/TODO.txt", + "path_type": "hardlink", + "sha256": "f88e0fb30fa0ab5d0dc3030442ed92713f34170336c4dd2623723dc34829df89", + "size_in_bytes": 8478 + }, + { + "_path": "Lib/idlelib/__init__.py", + "path_type": "hardlink", + "sha256": "3f8058df4fec56eb20ff67ff84c86fd3d9697e2384c5a290ed696f6d3187aa45", + "size_in_bytes": 396 + }, + { + "_path": "Lib/idlelib/__main__.py", + "path_type": "hardlink", + "sha256": "f8f55514d26791588de02fe685af0ab129174b32ab93efa39faf6140b6795d9d", + "size_in_bytes": 159 + }, + { + "_path": "Lib/idlelib/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ce1b0cded9e2dd40755306a46b66fd2428f56b1c198af8be186fbcc94d4488e8", + "size_in_bytes": 514 + }, + { + "_path": "Lib/idlelib/__pycache__/__main__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "601ccf9f8c1d00e8a5324719f20e7b44dec7912fe5349d0b60fbe9d2d3f27b52", + "size_in_bytes": 342 + }, + { + "_path": "Lib/idlelib/__pycache__/autocomplete.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2848403f7123a3583a896644d816723d6b8c323eb3fb75215c6474a8ff31b82f", + "size_in_bytes": 12263 + }, + { + "_path": "Lib/idlelib/__pycache__/autocomplete_w.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e122a565c28eb98cff8dd8a12244c732b569d5219cf8101bcf63c6e22a60c4fa", + "size_in_bytes": 25484 + }, + { + "_path": "Lib/idlelib/__pycache__/autoexpand.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4b4d173d71131a995fe36147222cb25280b1bd1c40cba17a2ae2ee1b5c656612", + "size_in_bytes": 4859 + }, + { + "_path": "Lib/idlelib/__pycache__/browser.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4952f0164475d404c86f4a5c4d5cc32d140b1c263028f518aacf5f34c95e9d58", + "size_in_bytes": 14531 + }, + { + "_path": "Lib/idlelib/__pycache__/calltip.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "adafe4f31b5d61ef8b6af710769648fb255807f2cc205e114a04175012c59753", + "size_in_bytes": 9110 + }, + { + "_path": "Lib/idlelib/__pycache__/calltip_w.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5904031386e5bfa2c820689179b2184395edb364637b116f7b3241a2b633d055", + "size_in_bytes": 11333 + }, + { + "_path": "Lib/idlelib/__pycache__/codecontext.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "49dfe64ddb97fdeede586f05809f50191a1669a761b43122d0d453d2dd90c8a4", + "size_in_bytes": 14340 + }, + { + "_path": "Lib/idlelib/__pycache__/colorizer.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "778e37e367eaacbd47fc2a97e33f2b0b9eed1e26b05e86ac1b69e1cddaaed888", + "size_in_bytes": 19558 + }, + { + "_path": "Lib/idlelib/__pycache__/config.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "319ef49f47aa08d182c61131b7333974a387129b1f252236aa2fd98db54fb7e5", + "size_in_bytes": 45157 + }, + { + "_path": "Lib/idlelib/__pycache__/config_key.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1f27841a83328efe41b0ac5650e5495c63014355222a1cd5e1806bb2199f1e7e", + "size_in_bytes": 21849 + }, + { + "_path": "Lib/idlelib/__pycache__/configdialog.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e80541dcc4553053d98c781f7ac2a80a29cf012f4cd1bce67824439487714e46", + "size_in_bytes": 135910 + }, + { + "_path": "Lib/idlelib/__pycache__/debugger.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e09750c9d09b2564a522e1f3d23f4a879eaf3b1d7f56ecc0d79da78305af918f", + "size_in_bytes": 30146 + }, + { + "_path": "Lib/idlelib/__pycache__/debugger_r.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "cb8b2c88a8a6d19cbc18ac760c2a0ef4e661c49b09e846073e4b02b425096229", + "size_in_bytes": 20498 + }, + { + "_path": "Lib/idlelib/__pycache__/debugobj.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "689db56981ee704961850a7e40b4f377136e4951f7875186392e8194dc66f3ec", + "size_in_bytes": 8557 + }, + { + "_path": "Lib/idlelib/__pycache__/debugobj_r.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4ffc9e41799539a54fdaa0f195b675d414473f271089f93dcc9400d41fb44f42", + "size_in_bytes": 2937 + }, + { + "_path": "Lib/idlelib/__pycache__/delegator.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "32eeee8e663d3cbec3e76a6cac62ddfa6f230032e006cd458b40f393a5d44dfa", + "size_in_bytes": 1935 + }, + { + "_path": "Lib/idlelib/__pycache__/dynoption.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6a03f655a6df9eafb42593d9977c2ddbd4c2388be4592262bb3fbc6c00ddc775", + "size_in_bytes": 3755 + }, + { + "_path": "Lib/idlelib/__pycache__/editor.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "402ccb8c2c47b2435221478bc5e9542a657cd3984535e241f9de7b9acf530a25", + "size_in_bytes": 93441 + }, + { + "_path": "Lib/idlelib/__pycache__/filelist.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c62a8d1d17e4040f0eee477b4ffa2a654b36b52bd8f8fec616ca1e2d3c644bd9", + "size_in_bytes": 6180 + }, + { + "_path": "Lib/idlelib/__pycache__/format.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "60784aedd9f238be43bc215f2ac4d8472f2f659b995491fc7cf2e5bd9328907a", + "size_in_bytes": 23275 + }, + { + "_path": "Lib/idlelib/__pycache__/grep.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "aef457b8a3a5772ab7fac5574cd74ebec5a560f8aa39753151d90288ac2529cd", + "size_in_bytes": 12520 + }, + { + "_path": "Lib/idlelib/__pycache__/help.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7e1dec3530cafc2f5ab9f78b5480c28fc68965037d2ad4b5bc5238d38fcf98d0", + "size_in_bytes": 18094 + }, + { + "_path": "Lib/idlelib/__pycache__/help_about.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "438d68ded40b62bacabf353d35d929d208aaaf1a2671e5b6132a48c8961ced79", + "size_in_bytes": 13883 + }, + { + "_path": "Lib/idlelib/__pycache__/history.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2a9b665e12a6a9453151796fc46a0232c46e584f2e94bda864812e0e289b64f5", + "size_in_bytes": 5510 + }, + { + "_path": "Lib/idlelib/__pycache__/hyperparser.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "489a415eb4545bc2c7df20c6a7bd2fda34451c37d509650dd6485bcbe8b13ab2", + "size_in_bytes": 13502 + }, + { + "_path": "Lib/idlelib/__pycache__/idle.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "eeeadfcfa68ee9d7c2fed98efbc59130c4acc11e2ddc6cce93a464082c276822", + "size_in_bytes": 626 + }, + { + "_path": "Lib/idlelib/__pycache__/iomenu.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6e8f7e5b2b5ea6a4d7f636700697e40bb13ba9d358b8eb532e9869926b803762", + "size_in_bytes": 23059 + }, + { + "_path": "Lib/idlelib/__pycache__/macosx.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "931c7a1988f4234831a4d16d388dd0ea26f4fa36e7bb0a133db483575df913c2", + "size_in_bytes": 11180 + }, + { + "_path": "Lib/idlelib/__pycache__/mainmenu.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9c641965519fb94885721fea20c1876af3e854d31026cd0e9c0692264f8553c3", + "size_in_bytes": 3722 + }, + { + "_path": "Lib/idlelib/__pycache__/multicall.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "fdc99fd53029379f5e448bea6d3db209c590dca70bb7acc9d5b68b69b6564a07", + "size_in_bytes": 25493 + }, + { + "_path": "Lib/idlelib/__pycache__/outwin.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5031c37a95ed51ed67eb12c9a2ef86a2b5f63f896f9a778e3beeed484e96fda8", + "size_in_bytes": 8479 + }, + { + "_path": "Lib/idlelib/__pycache__/parenmatch.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b68d1d0c0eb9cbf77031f4a57e2bf083505fed0b6468279cedc9e45a0dfaf774", + "size_in_bytes": 10005 + }, + { + "_path": "Lib/idlelib/__pycache__/pathbrowser.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f206f32e2c383f4393f1ac0090b363e9d1c6a65647dba425fcaa779a2108faa4", + "size_in_bytes": 6184 + }, + { + "_path": "Lib/idlelib/__pycache__/percolator.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5f2138656f37924d130c46778d8926f420fe3054556c55540fcbbc6dfe8d682f", + "size_in_bytes": 7525 + }, + { + "_path": "Lib/idlelib/__pycache__/pyparse.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5858a36b9707e341264d11a41d6999b799fe1a7a6d92b66458373acdf4484ee2", + "size_in_bytes": 19680 + }, + { + "_path": "Lib/idlelib/__pycache__/pyshell.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3225521197b69ce03d85901da24e9deb1ef187b8c9d76782ad45c07bc4767731", + "size_in_bytes": 87682 + }, + { + "_path": "Lib/idlelib/__pycache__/query.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "889b7fe55a6807c594443944e43cc62880b926eb3377a47a560c085cc91ce3c2", + "size_in_bytes": 22072 + }, + { + "_path": "Lib/idlelib/__pycache__/redirector.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b62267413c5b7e86fed2497f6c7fbeb9e36b698dc10f25c0ebabe6761fc44d88", + "size_in_bytes": 9252 + }, + { + "_path": "Lib/idlelib/__pycache__/replace.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "852a4319c90984ed7ce34def31d3cc38c423b9f09f20cc0cc2b2ca806fc5f564", + "size_in_bytes": 15886 + }, + { + "_path": "Lib/idlelib/__pycache__/rpc.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3544c082ed11828e9e22e879deb1d6b3bd241a01427c66a2ce84445fd7b404d4", + "size_in_bytes": 32763 + }, + { + "_path": "Lib/idlelib/__pycache__/run.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "12e61b5290d79b87ab80e80ac63d76db34db449384a4da70a6e4c37e82cd1a5b", + "size_in_bytes": 32310 + }, + { + "_path": "Lib/idlelib/__pycache__/runscript.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8afeea47ecc888bab769f759ffef22b6d36146321ae2bdaf6a9fb33fc0f6a6e6", + "size_in_bytes": 11678 + }, + { + "_path": "Lib/idlelib/__pycache__/scrolledlist.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7a4b192d844737b3499b89b695d3f1fb39c6de8c5e26614f3479055e0cdccd76", + "size_in_bytes": 9861 + }, + { + "_path": "Lib/idlelib/__pycache__/search.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3a2e8893ff748826cc11b755627eed6bdefd40e87d3a9676eacc056ef301bfb2", + "size_in_bytes": 8941 + }, + { + "_path": "Lib/idlelib/__pycache__/searchbase.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7521e47776525717c85aa957426dbfde55f858b8dd67d95d8bf6423cfb333197", + "size_in_bytes": 12977 + }, + { + "_path": "Lib/idlelib/__pycache__/searchengine.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4de34f482db2d06abf440bf4de467e3f492a8e66a930967f396f632d1665f1cc", + "size_in_bytes": 11049 + }, + { + "_path": "Lib/idlelib/__pycache__/sidebar.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8b196c0895e7869f83e08dfb859e9a00de6f10f68eefc7e1fbe52b71b4a88539", + "size_in_bytes": 31254 + }, + { + "_path": "Lib/idlelib/__pycache__/squeezer.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b0a86aa57d30207775338a52989903fb54bcc5d346c5268177e81cc3564e68ac", + "size_in_bytes": 15254 + }, + { + "_path": "Lib/idlelib/__pycache__/stackviewer.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "231e3d788d7d5733ca3ff1d47c4d9c6f6e83e92e88bb5e66041b1caf9c80b234", + "size_in_bytes": 7809 + }, + { + "_path": "Lib/idlelib/__pycache__/statusbar.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a0b325ef9c9842f1fc144b2425d3b57d867ea4d444ec175d267bf2f1750f4929", + "size_in_bytes": 3505 + }, + { + "_path": "Lib/idlelib/__pycache__/textview.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "30018d2da4cb53975dcc1b1d0d9d5c61efeea46565ac336570627b2d1139626f", + "size_in_bytes": 11365 + }, + { + "_path": "Lib/idlelib/__pycache__/tooltip.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "36c86ac064ba0d8289995380da69342bacb2cda066a8757e63ef9248667ec524", + "size_in_bytes": 10534 + }, + { + "_path": "Lib/idlelib/__pycache__/tree.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "291f41b106e6720af70f9a334ad44c773216e1bebcfd6138d255c3f90aada84b", + "size_in_bytes": 29400 + }, + { + "_path": "Lib/idlelib/__pycache__/undo.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4d679389208db9d9ce4f35da97d4f836474c36e44e9790559aef8a4cc92ea286", + "size_in_bytes": 19978 + }, + { + "_path": "Lib/idlelib/__pycache__/util.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "01968b333a9bd876272daaaa8eebf8a69fc9062f51fccc790ff161ec02b006bd", + "size_in_bytes": 858 + }, + { + "_path": "Lib/idlelib/__pycache__/window.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d7746b9dc85f1aaa7abbfa1703a4385e2795ca763ce1502675c77659be00acd5", + "size_in_bytes": 5486 + }, + { + "_path": "Lib/idlelib/__pycache__/zoomheight.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "959aef8ec5238fa7e25ee3fa686fbd6412eb5e53019b5e3564c78dcabd3a5fa7", + "size_in_bytes": 5025 + }, + { + "_path": "Lib/idlelib/__pycache__/zzdummy.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e1f1cb337d25c4d0116ca4f45c81ee32356585a73422b3415f280e78c6cb45e7", + "size_in_bytes": 3521 + }, + { + "_path": "Lib/idlelib/autocomplete.py", + "path_type": "hardlink", + "sha256": "0d36f7694a50cbaa22d9bf03b91fa0658a147bd90dd867714a9b411febb36427", + "size_in_bytes": 9354 + }, + { + "_path": "Lib/idlelib/autocomplete_w.py", + "path_type": "hardlink", + "sha256": "91170b060749d0b3c8f2ab31499104028bedf971e5575155d43392d5c8dae5d6", + "size_in_bytes": 20863 + }, + { + "_path": "Lib/idlelib/autoexpand.py", + "path_type": "hardlink", + "sha256": "c8eb28ef7addf5a664a7e3addfbfebe29040a8695e1db515828305aacba2ee4e", + "size_in_bytes": 3216 + }, + { + "_path": "Lib/idlelib/browser.py", + "path_type": "hardlink", + "sha256": "b607102a6e2ff7de241744008144a5480e2925098694be2a46003d8f60da0f52", + "size_in_bytes": 8588 + }, + { + "_path": "Lib/idlelib/calltip.py", + "path_type": "hardlink", + "sha256": "3a723fdf88c0018dfadd19757142a643b01b785c6df17a50bbe21463663ab590", + "size_in_bytes": 7267 + }, + { + "_path": "Lib/idlelib/calltip_w.py", + "path_type": "hardlink", + "sha256": "077e9d0d95946296077d5c95f343e242a7d250a6efece4afc58759b5e984e6c3", + "size_in_bytes": 7083 + }, + { + "_path": "Lib/idlelib/codecontext.py", + "path_type": "hardlink", + "sha256": "628a13325b3bf2f76dea9254b20178b3232261f83c660f0e33785e6215dd6492", + "size_in_bytes": 11420 + }, + { + "_path": "Lib/idlelib/colorizer.py", + "path_type": "hardlink", + "sha256": "4de77a632286cf7cb616a2cf50dcd16a99d452fe7b16bf94c34950be97f293c2", + "size_in_bytes": 14783 + }, + { + "_path": "Lib/idlelib/config-extensions.def", + "path_type": "hardlink", + "sha256": "e75df0b77ff61253be457af636d5eb7c55a3ff2b6a733beea844d2b294972ebf", + "size_in_bytes": 2266 + }, + { + "_path": "Lib/idlelib/config-highlight.def", + "path_type": "hardlink", + "sha256": "609eada44ff4aa9d5cd10ad8b4c29bb76db8ebc74912a0ae86f5ea3cd19b7547", + "size_in_bytes": 2864 + }, + { + "_path": "Lib/idlelib/config-keys.def", + "path_type": "hardlink", + "sha256": "bee81ba5c5abec1e35e313268f8d8fe72d305d0ad73abfba3d2ea1e2b2308710", + "size_in_bytes": 10910 + }, + { + "_path": "Lib/idlelib/config-main.def", + "path_type": "hardlink", + "sha256": "e783704ad5cd9b3f44c026f55c98be2c52190bf9b7832251283f3e953ba80f87", + "size_in_bytes": 3168 + }, + { + "_path": "Lib/idlelib/config.py", + "path_type": "hardlink", + "sha256": "226d4259cf50e32bb1c2b76b90e6914a9d1790171363d82d1c4c47ed9673aa9b", + "size_in_bytes": 38387 + }, + { + "_path": "Lib/idlelib/config_key.py", + "path_type": "hardlink", + "sha256": "856bd4b2c1fd7275856d3869cad8975f7770edbf021a93c64816a41c2322c2fa", + "size_in_bytes": 15230 + }, + { + "_path": "Lib/idlelib/configdialog.py", + "path_type": "hardlink", + "sha256": "68a6a9470476408acdce5e3a8816196e025f8cccd0845bf1da579db19a5bba8c", + "size_in_bytes": 105314 + }, + { + "_path": "Lib/idlelib/debugger.py", + "path_type": "hardlink", + "sha256": "6e595d5a388e46b6b6e24490e970a3d355ec116a16a064bfca6ed86d4b17dcb4", + "size_in_bytes": 20991 + }, + { + "_path": "Lib/idlelib/debugger_r.py", + "path_type": "hardlink", + "sha256": "ddc797740231f068ca7c7c8610e799d72ad11af670d9bc0b6f9e04fe2ba222d1", + "size_in_bytes": 12115 + }, + { + "_path": "Lib/idlelib/debugobj.py", + "path_type": "hardlink", + "sha256": "aae9e2468a3d05366480864dc56689c65896757faf3b0364b8eef9feb4876a43", + "size_in_bytes": 4177 + }, + { + "_path": "Lib/idlelib/debugobj_r.py", + "path_type": "hardlink", + "sha256": "4e583b43fdf9bd4a731d70e074ee597aba03f3c8c36302bdc7e74650fb1fcc11", + "size_in_bytes": 1082 + }, + { + "_path": "Lib/idlelib/delegator.py", + "path_type": "hardlink", + "sha256": "c2b31919d27056fc3aaa8f4ef798fbdf162665175fa9216d665f58ba2e4a464d", + "size_in_bytes": 1044 + }, + { + "_path": "Lib/idlelib/dynoption.py", + "path_type": "hardlink", + "sha256": "29933f56722b2efb5cf451825a7fe50f357983e68f6a261afdf89b52f778e488", + "size_in_bytes": 1993 + }, + { + "_path": "Lib/idlelib/editor.py", + "path_type": "hardlink", + "sha256": "e277fc183eefdf1fc20acfbd18a6bdde4988d0193edd27cb8e865e74f798c897", + "size_in_bytes": 69561 + }, + { + "_path": "Lib/idlelib/extend.txt", + "path_type": "hardlink", + "sha256": "5bceaf660c46faf8f9fbf2be5e23389d6e6477d1e458fee680e606bcc95d2853", + "size_in_bytes": 3631 + }, + { + "_path": "Lib/idlelib/filelist.py", + "path_type": "hardlink", + "sha256": "64e194e4514141414ecb231ac165ed861749bb0d31d0758c7c3a823ce154abe1", + "size_in_bytes": 3871 + }, + { + "_path": "Lib/idlelib/format.py", + "path_type": "hardlink", + "sha256": "dc2b00fb239f38543bf973d94daef2c52457b905d4d89c640993823127b7923c", + "size_in_bytes": 15777 + }, + { + "_path": "Lib/idlelib/grep.py", + "path_type": "hardlink", + "sha256": "f5a9327c83e7aecec64efb81bf9f4542a4f3e0a13d0b6443e8eca5dfbb509835", + "size_in_bytes": 7526 + }, + { + "_path": "Lib/idlelib/help.html", + "path_type": "hardlink", + "sha256": "ac81ab586d33514ce0f303cf02d04bc9a2184569c82f4c85fed7c16b209e6dbb", + "size_in_bytes": 78525 + }, + { + "_path": "Lib/idlelib/help.py", + "path_type": "hardlink", + "sha256": "35f26243be00070246751349d864ffc576242b38aa559ed536e7b635819ea847", + "size_in_bytes": 11902 + }, + { + "_path": "Lib/idlelib/help_about.py", + "path_type": "hardlink", + "sha256": "93aec712aa0f1899597c52697d859cf26c63163ee355e456f0e20b984dcfdfdf", + "size_in_bytes": 8910 + }, + { + "_path": "Lib/idlelib/history.py", + "path_type": "hardlink", + "sha256": "f91f1568d083bdbc856d38ef48493bcb138c6a492d523385b300a5bac30133e6", + "size_in_bytes": 4065 + }, + { + "_path": "Lib/idlelib/hyperparser.py", + "path_type": "hardlink", + "sha256": "18563d2b4c248aed70b7f29fd903fd51d1b5aceb3dc93c23f9a54141eed7a9b0", + "size_in_bytes": 12889 + }, + { + "_path": "Lib/idlelib/idle.bat", + "path_type": "hardlink", + "sha256": "15a3977f0d2c6a8e87db2ef7050ea10afb3a88b064bf5ef95439924e42464114", + "size_in_bytes": 177 + }, + { + "_path": "Lib/idlelib/idle.py", + "path_type": "hardlink", + "sha256": "33ffa2f718e123fd1c4e536bb4a471978515787ee9fbf7806a92073a787a733a", + "size_in_bytes": 454 + }, + { + "_path": "Lib/idlelib/idle.pyw", + "path_type": "hardlink", + "sha256": "26101d297127132c5e9634499f41ad00e125ea308343a20b278bee9e9225eb5c", + "size_in_bytes": 570 + }, + { + "_path": "Lib/idlelib/idle_test/README.txt", + "path_type": "hardlink", + "sha256": "94cca8aab706b6ceb5d9ed44cad93127988c9370cdde250a53bec9b132261f05", + "size_in_bytes": 8880 + }, + { + "_path": "Lib/idlelib/idle_test/__init__.py", + "path_type": "hardlink", + "sha256": "0a7370f8ab516e0944f381fcecee02ac660926551b3eb543f88ace3ef024ca70", + "size_in_bytes": 1250 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ee97954d6ae057913ced42014797625fc9ab97a195fdbb8c6bf8891d572c7606", + "size_in_bytes": 1043 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/htest.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "779222b8680613b4805432d16e392375d076ea4acae1d678e08bf701e906561e", + "size_in_bytes": 17231 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/mock_idle.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6d32b718259e14b5b83648f1ff5f02737cff8d5a5922728f179f0d05ff0f3903", + "size_in_bytes": 3445 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/mock_tk.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b7e8a29843327d5e84b192ea07499abd13a44461d1c829338f64bc8d7b80f22d", + "size_in_bytes": 15355 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/template.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c1862b11a3ae60b53e99acade2ce5ad97bb1baa9cad8759159495f19c682a6e2", + "size_in_bytes": 1663 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_autocomplete.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3959535a9a10f34e2e80fdcae0965a43c991d8a4eabb6a8321645423afa1343c", + "size_in_bytes": 20899 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_autocomplete_w.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ddbcb0665582b791f7689a9ccc1e4ac2759693a4fc6272ab9f59aa3a2a861564", + "size_in_bytes": 2086 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_autoexpand.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d9ff5a691f21a7e00f0f977984027d5397b536e22cb4886cdc90872bcc25a922", + "size_in_bytes": 7958 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_browser.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c926f2a8c7827f348dad9854c67f7314b3fa9854f8f54483b12b85530cb28fc2", + "size_in_bytes": 18729 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_calltip.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0b2ed642aa6391efb763a3e0a14bb8c26931056a2f8420baf9df055846905e5a", + "size_in_bytes": 29722 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_calltip_w.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f9e2e6885bb9a0e7bbafae1f6f7670a1074de1ba98b4d8c0597081c732b2e396", + "size_in_bytes": 2032 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_codecontext.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "66ea532a362b5f19a1d43c02400f17a393612e994bfbad3b447ca0de70b8d2b5", + "size_in_bytes": 23659 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_colorizer.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5002b74ee64b418132a163f7106f7b8c120648e20e986a7d7d32585a46b3bc96", + "size_in_bytes": 36019 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_config.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "35d62a807caa4cd50efc92ce065e3f6d573b4d8f3f2ac5443b83870b6629f87d", + "size_in_bytes": 57571 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_config_key.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "60c506d31a4ae78926fe3ae6bd7a80f578c3397901e3d1ea863df8aacaafd674", + "size_in_bytes": 23563 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_configdialog.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3fdbc606bdbd9475e02ede4c567302defcee975d1342acab482ddd91a30eccaa", + "size_in_bytes": 96826 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_debugger.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "40b11e891f919575397cafb205e5a6fc7e1932626381f10bf159196bf8ff34eb", + "size_in_bytes": 19605 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_debugger_r.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "896f61981872e373409cbdeacd9f2fb26d95c419ce4cf2d695d026b9cda1cd57", + "size_in_bytes": 1686 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_debugobj.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "09cbecff6d9fd52252e6f896ba46277aaa1b40bf09e9d6c3a60e42162f99ea39", + "size_in_bytes": 4698 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_debugobj_r.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "de2a3f7f33657cee8e7e98e8c3e38265d1e559827cf7c54009f3633fcfeaed6e", + "size_in_bytes": 1723 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_delegator.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7b3a5df24570131b5fa801f84b4d010bd16d7245c26bfcf3c293ee0a9f80adb0", + "size_in_bytes": 2229 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_editmenu.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "28eb7cbac204f3a29044973297a363a8adeecde6bda73fedecf917b6ae3f4897", + "size_in_bytes": 5330 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_editor.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0a1537ea66ed8ed9bf9ef4eb9be87e23750a16d22954c6850d90c8b23d9c8deb", + "size_in_bytes": 12474 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_filelist.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "322bfd3c07dfc29f34484a24e5900b44b88b82e649c932689b8bfb52c5430d2f", + "size_in_bytes": 2323 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_format.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b1ad9d0085c501e8ee57458e7d5507b859df8e339195375e5b0854412d1042e8", + "size_in_bytes": 36227 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_grep.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2eab3dbba80f8f8396714ae53a77a5c8293063b2e93a8746f483d360d1767137", + "size_in_bytes": 9670 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_help.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e20b2e80f09feae7ac68fda3c15aafa263cc7fc88507703e282fefe1719ebf8f", + "size_in_bytes": 2411 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_help_about.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2e9eab3bf1f5d20d277e164cc4779d788fa5eac27200d06d3c107be9179a7e73", + "size_in_bytes": 12353 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_history.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3b31949f9ae9f96bd3ab8aac64e2368bfb9bf96089fe81441cce6ac213f172a8", + "size_in_bytes": 11651 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_hyperparser.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "550c33913cbbad5b3fe6b4b2ccd92a1c94de8a32cb63e9601bd40b394be34ece", + "size_in_bytes": 17637 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_iomenu.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "66c6b8018b444332e683672707021d73ae8d8d18fa0b0d26a929685000ffc079", + "size_in_bytes": 5512 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_macosx.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d89958f2e62e5b8b44354c2b77f186ce76f1d592631cf1394507e8b575058f53", + "size_in_bytes": 7521 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_mainmenu.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "82cbb3c2614cff1d10001077b3b845c2a340e0f39fc005a38e2bf9ac91e30134", + "size_in_bytes": 2940 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_multicall.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9750cdaeed6adfc08adfbbdfbcd94bedfaf1a69036e17da114a80a4419bec626", + "size_in_bytes": 3116 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_outwin.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8e6fb3c5aff1ac718b6c270cd4623c4f9bdbeeda7112b9bd1ad28617ec36e534", + "size_in_bytes": 10451 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_parenmatch.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ee678d54bdb96a18a2836bc96eb8e2a413ee3151f954b9102d10156eb575fb2b", + "size_in_bytes": 6973 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_pathbrowser.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "aa498f30d771ab00aaca1a5cfc9bd3541c33726edf072b76ee088363588edb08", + "size_in_bytes": 6304 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_percolator.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d04a18692b14883552750b74025c2c86b187088ba79da730132dd8fc46130179", + "size_in_bytes": 9374 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_pyparse.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5be0ad8e1e4e90597dc9946daabb19c4be4c300e3bf44245a3c626ca8060f067", + "size_in_bytes": 26928 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_pyshell.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c69c4a27f4b5ec20685bc9a2aee3028e2bc4b6c69a9d53087c0f07a7cc656412", + "size_in_bytes": 10652 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_query.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c93e3753aa17397c7aaf6a80e7f0cb66ca3358a574a8f4c079109118ff62ebb4", + "size_in_bytes": 35547 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_redirector.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8b361a6dc5a7ccb5089b6b96aeadd76a3add4b4cc7e30424a75877d76b64bf1b", + "size_in_bytes": 10069 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_replace.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3dc59eea09eab2c4f82edc5a76245f941b6097581229991e4a5118cf57cd2701", + "size_in_bytes": 16444 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_rpc.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "487300da03da1bb500ee09bcff7977dc0dd8ebe85e3dd9a2817abdffb618a168", + "size_in_bytes": 2460 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_run.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c6e91550b37f3513d00014a45c6486e9e847d8264500be58fa77b568b77f5b70", + "size_in_bytes": 35257 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_runscript.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3eab48d83c9b41e123b619b68da1854ae74e7b26abc127447ccef4b967e38152", + "size_in_bytes": 2174 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_scrolledlist.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "55ea9dea0a82f60aa0a3171472fdb52cf299b6c42015a98b72090fd19b99e4a3", + "size_in_bytes": 1566 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_search.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d0ffbc25e64d41c897cb53155a03f9c6c10a78bc03d277800081a21a3cc1aad4", + "size_in_bytes": 5053 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_searchbase.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5033aade2059a393630ba1214fa614d06d9222199906cf29b883f8bf1fb9b3bb", + "size_in_bytes": 10706 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_searchengine.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "bbc2a7fad535b491f9bcce8bf6b3e0f7619d9d210c4a52b32450803d2e66ecd1", + "size_in_bytes": 19849 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_sidebar.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "fa3ba4820143bed6b264d86b66fae29e6cff6715d7c640110271ce024f8eafde", + "size_in_bytes": 51256 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_squeezer.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f78b907e4d5978c02d8f7a814ecfea1ad0976981aefa5b17060ace0244c61574", + "size_in_bytes": 30608 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_stackviewer.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "608d66ce76ae5c4bf4c9d0dd7612cfe0c74464abccbccfa5d8126641a2090f46", + "size_in_bytes": 2341 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_statusbar.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "164eacb32b771b9b1346ec00fa745b342b004332b6159d90b135e542247d6d12", + "size_in_bytes": 2856 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_text.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e6fbea3090f926ac0051c97f10a977fe0660cfa82a336cd0a77aac0cd0aedc60", + "size_in_bytes": 12997 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_textview.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1c3f1fd1c3157e503eb71a80f0bfb09cbed2b9fafb43a1dd09e15861ef1d1b45", + "size_in_bytes": 17235 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_tooltip.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8f30cb979c7cefc0fbb06fa2d876c06acf6ad2c41958c9f298e3429363b25ead", + "size_in_bytes": 11122 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_tree.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "74b8ccd72acc81c6b5733fb79258c935e9f12ac123481101d24c7408e09bc8e7", + "size_in_bytes": 4238 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_undo.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "34c6219a6a949da865da7a9381c5cf1aa1bfb2cf44c5023b5fdb7f9ca40cd9f8", + "size_in_bytes": 8844 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_util.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3829e7215cef377fd0ece04dbd05bff224627954aa89dae05bc10b8509804f1a", + "size_in_bytes": 979 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_warning.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1520a2c92da58317f29b9c3dc727bccd85abd7045dad9bb0e846945794f529ea", + "size_in_bytes": 4941 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_window.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "77154732f4a7dee987c9a09c06bcbe27710fbee1789c82b9eb8cd2a7b99e0c7d", + "size_in_bytes": 2751 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_zoomheight.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "85b8ec6f69ece2725a9efd9058ea86bc0358f798e21dc3febb9091588f72c998", + "size_in_bytes": 2591 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/test_zzdummy.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b4c02a6806b0a42f22d2d77060d69fc2bdd3339ea21635e0646cc0424c1aa9d0", + "size_in_bytes": 8772 + }, + { + "_path": "Lib/idlelib/idle_test/__pycache__/tkinter_testing_utils.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ac0400e1276a685d79e5c5d867139ae402b2031da6d59fcec4e565ceec521899", + "size_in_bytes": 2906 + }, + { + "_path": "Lib/idlelib/idle_test/example_noext", + "path_type": "hardlink", + "sha256": "526edff5d21fd1f1421f5ab6a706cb51732edcae235b9895f93a8f46e25505fe", + "size_in_bytes": 68 + }, + { + "_path": "Lib/idlelib/idle_test/example_stub.pyi", + "path_type": "hardlink", + "sha256": "e89a8196b490fe728f31af590b3bbca69bddc7aec8cbf09d2a5ae0953240ac56", + "size_in_bytes": 154 + }, + { + "_path": "Lib/idlelib/idle_test/htest.py", + "path_type": "hardlink", + "sha256": "8c0413ab3067d28fe93f40e2e1da410414095ab278f63fc578a9d8452f98eb5c", + "size_in_bytes": 15313 + }, + { + "_path": "Lib/idlelib/idle_test/mock_idle.py", + "path_type": "hardlink", + "sha256": "637d74d26089c582fb784c2920f5bcb41e5b1fc8b9e0931ddc1cc8d92becbff4", + "size_in_bytes": 1943 + }, + { + "_path": "Lib/idlelib/idle_test/mock_tk.py", + "path_type": "hardlink", + "sha256": "7d60a26e82fd0469a95e02c2adda6607363a51ab67d5851cc323a58a595f74a7", + "size_in_bytes": 11693 + }, + { + "_path": "Lib/idlelib/idle_test/template.py", + "path_type": "hardlink", + "sha256": "43421286ad234a4240f8d4bc09f67bb58da0bf9d9b07bf93010989ef2c17f2f8", + "size_in_bytes": 642 + }, + { + "_path": "Lib/idlelib/idle_test/test_autocomplete.py", + "path_type": "hardlink", + "sha256": "0ee1af80bb645bd57e6f6383f5e5473f901e9d40524992abf9c48a4163997eef", + "size_in_bytes": 11093 + }, + { + "_path": "Lib/idlelib/idle_test/test_autocomplete_w.py", + "path_type": "hardlink", + "sha256": "f8cd80196c2841f65f53ca5ae1c4fb99c7c215b29cf88774e0b189c99e4cee79", + "size_in_bytes": 720 + }, + { + "_path": "Lib/idlelib/idle_test/test_autoexpand.py", + "path_type": "hardlink", + "sha256": "85f913f8cbd5dfd5d52d3b7d00eedec231ec3e4ee7d117db4a2bb714eb1a7243", + "size_in_bytes": 4638 + }, + { + "_path": "Lib/idlelib/idle_test/test_browser.py", + "path_type": "hardlink", + "sha256": "bdfd3bd9ab02ee535e77f3233920f80891eb84d7042f7db381afc7766b3702eb", + "size_in_bytes": 8420 + }, + { + "_path": "Lib/idlelib/idle_test/test_calltip.py", + "path_type": "hardlink", + "sha256": "a67efd1c92e824321254f615d35a72508ee09d75e1058c3d01ad7d8bf3be1ebf", + "size_in_bytes": 13658 + }, + { + "_path": "Lib/idlelib/idle_test/test_calltip_w.py", + "path_type": "hardlink", + "sha256": "7462c048c689f82c3ae6b5782a18776762f88055b80ae77a92243b6c0606e004", + "size_in_bytes": 686 + }, + { + "_path": "Lib/idlelib/idle_test/test_codecontext.py", + "path_type": "hardlink", + "sha256": "84e6b890b22b2abcc0865c691162b93c6ffb9b4e17f05011bdaffa770a52fcf0", + "size_in_bytes": 16082 + }, + { + "_path": "Lib/idlelib/idle_test/test_colorizer.py", + "path_type": "hardlink", + "sha256": "6a3fbb630e0ecc7aafc9c8bc56ece3462911c733aa3bb4c52ee55c1d897301d4", + "size_in_bytes": 22882 + }, + { + "_path": "Lib/idlelib/idle_test/test_config.py", + "path_type": "hardlink", + "sha256": "02546eb557e57b1654da9016cf56f1826869f3e6c78bcafffb8a89013641c1a1", + "size_in_bytes": 32091 + }, + { + "_path": "Lib/idlelib/idle_test/test_config_key.py", + "path_type": "hardlink", + "sha256": "54d0c65e1f66d37c415d3fe533c8db891974f08e8fca6374596280d64db86586", + "size_in_bytes": 11462 + }, + { + "_path": "Lib/idlelib/idle_test/test_configdialog.py", + "path_type": "hardlink", + "sha256": "56685b99d406c974ffce84260b08b06476b1e98f701d0675c378d86c8f19f579", + "size_in_bytes": 55389 + }, + { + "_path": "Lib/idlelib/idle_test/test_debugger.py", + "path_type": "hardlink", + "sha256": "8117fa37bf2c4266809f3a41c7c37c603c6a390b235801504123ea533c55d7cc", + "size_in_bytes": 9727 + }, + { + "_path": "Lib/idlelib/idle_test/test_debugger_r.py", + "path_type": "hardlink", + "sha256": "ccc0ba5e03ee1df449f78a164efdc6739f5a530315ab3971ac05c652bc779cea", + "size_in_bytes": 965 + }, + { + "_path": "Lib/idlelib/idle_test/test_debugobj.py", + "path_type": "hardlink", + "sha256": "5427a574cfcfd36a48e365f6f8864b226ee8d7eb48702ff1496570302b1d9acc", + "size_in_bytes": 1611 + }, + { + "_path": "Lib/idlelib/idle_test/test_debugobj_r.py", + "path_type": "hardlink", + "sha256": "22d74368ba175175b9c14315f9d82fd7ddde60ae93d2e5572e9a647de7e869eb", + "size_in_bytes": 545 + }, + { + "_path": "Lib/idlelib/idle_test/test_delegator.py", + "path_type": "hardlink", + "sha256": "559d39df8c1ff38d177943f245b87f5379ee5ea93399fd6b5f7bfa882e6ed8ca", + "size_in_bytes": 1567 + }, + { + "_path": "Lib/idlelib/idle_test/test_editmenu.py", + "path_type": "hardlink", + "sha256": "ed3800137d48ffcf86ecb71afe5a24cd9ed381571f23036438ba8a97f502326a", + "size_in_bytes": 2564 + }, + { + "_path": "Lib/idlelib/idle_test/test_editor.py", + "path_type": "hardlink", + "sha256": "654ae5ca7f747a4a88d2868de48c7bff1f35b26098075f840722e955fe4cb83e", + "size_in_bytes": 8151 + }, + { + "_path": "Lib/idlelib/idle_test/test_filelist.py", + "path_type": "hardlink", + "sha256": "d4cea5fdba68fb9e361541820d44eed003c317f4ef14bb9df3406b8d2c53ef7c", + "size_in_bytes": 795 + }, + { + "_path": "Lib/idlelib/idle_test/test_format.py", + "path_type": "hardlink", + "sha256": "b356a2a8f5fe14c39c6af73623484df4ed930cc16ef4605f3b04fd9b618867a6", + "size_in_bytes": 23610 + }, + { + "_path": "Lib/idlelib/idle_test/test_grep.py", + "path_type": "hardlink", + "sha256": "ca64de882b5608e016b7df8f739089c9f262643bce09979b76399cc4be1ea12c", + "size_in_bytes": 5072 + }, + { + "_path": "Lib/idlelib/idle_test/test_help.py", + "path_type": "hardlink", + "sha256": "0513a2872307b45ea7869b7e07dc437d7e8c69524073513b96374397f371b32a", + "size_in_bytes": 863 + }, + { + "_path": "Lib/idlelib/idle_test/test_help_about.py", + "path_type": "hardlink", + "sha256": "47663dfbcddced35ad97631cebb690a30ab3aa724bde0a7174d11290ac79eb02", + "size_in_bytes": 5904 + }, + { + "_path": "Lib/idlelib/idle_test/test_history.py", + "path_type": "hardlink", + "sha256": "6319fe7810ed91786b503de80701a291a4f9abe54c9e101c19c0917b709e62f3", + "size_in_bytes": 5517 + }, + { + "_path": "Lib/idlelib/idle_test/test_hyperparser.py", + "path_type": "hardlink", + "sha256": "cd2fbc788d4d75b514e53951dc90d00d41a8a87baad31bc1e380b7449bfcf183", + "size_in_bytes": 9082 + }, + { + "_path": "Lib/idlelib/idle_test/test_iomenu.py", + "path_type": "hardlink", + "sha256": "8250eb60ea1d7760589febf38c171c8c6e202e527a680030233539db59439d8d", + "size_in_bytes": 2457 + }, + { + "_path": "Lib/idlelib/idle_test/test_macosx.py", + "path_type": "hardlink", + "sha256": "975e48ab453711c5072988e2e66a7fe51e716ac64e494f022a5ff82781ccd368", + "size_in_bytes": 3444 + }, + { + "_path": "Lib/idlelib/idle_test/test_mainmenu.py", + "path_type": "hardlink", + "sha256": "faa064ffd9c8e30b1205e46bb4ede816c74b7948cfa34c7795ed19c35eac10d5", + "size_in_bytes": 1638 + }, + { + "_path": "Lib/idlelib/idle_test/test_multicall.py", + "path_type": "hardlink", + "sha256": "1bfb51912275d8e346dce0a40ab84316b15e3f142e66529a8c9cfd52210c1a1f", + "size_in_bytes": 1317 + }, + { + "_path": "Lib/idlelib/idle_test/test_outwin.py", + "path_type": "hardlink", + "sha256": "4f0590e1fe9af387fa627cb8a40cd7618da5d2a46ce4b33446d54f6fbcce2105", + "size_in_bytes": 5417 + }, + { + "_path": "Lib/idlelib/idle_test/test_parenmatch.py", + "path_type": "hardlink", + "sha256": "5e0ba86116e28d46e7db9ed33d85cf7caa837e1779e1b8feb5f6b6b4a837551e", + "size_in_bytes": 3544 + }, + { + "_path": "Lib/idlelib/idle_test/test_pathbrowser.py", + "path_type": "hardlink", + "sha256": "a7d9c5085ff5c64232897f6ee0a09258a41a35f153f47ff0f3b8fa97ec67be9e", + "size_in_bytes": 2422 + }, + { + "_path": "Lib/idlelib/idle_test/test_percolator.py", + "path_type": "hardlink", + "sha256": "133b134a46b23cf2c635be3116415fd388e3a1c1581bf1a77d7f7f0aff3a725b", + "size_in_bytes": 4065 + }, + { + "_path": "Lib/idlelib/idle_test/test_pyparse.py", + "path_type": "hardlink", + "sha256": "8f386a9f535369afb495322e104077c66c5a3abb91917ec69f868b405120cf35", + "size_in_bytes": 19365 + }, + { + "_path": "Lib/idlelib/idle_test/test_pyshell.py", + "path_type": "hardlink", + "sha256": "ff47aecd0657edbd7bc920473fe2e55b0bb0db6f347dc52f5e81b767897d3bc5", + "size_in_bytes": 4965 + }, + { + "_path": "Lib/idlelib/idle_test/test_query.py", + "path_type": "hardlink", + "sha256": "632c2dc13a158a5902e5b758166151ffa377db7f5a0c368bc3b0741a237876c3", + "size_in_bytes": 15454 + }, + { + "_path": "Lib/idlelib/idle_test/test_redirector.py", + "path_type": "hardlink", + "sha256": "517c1fe16da359e01f3cdfdf3f7aead4283e8b8e1107522b72f59d4c4f3ade4c", + "size_in_bytes": 4176 + }, + { + "_path": "Lib/idlelib/idle_test/test_replace.py", + "path_type": "hardlink", + "sha256": "321333b3eaad9ecbf633186bc625d4a60c4c736def0fa00665add2ab899eecb1", + "size_in_bytes": 8299 + }, + { + "_path": "Lib/idlelib/idle_test/test_rpc.py", + "path_type": "hardlink", + "sha256": "1e2d997f442002389b3dadb47ed8134947c664a32ef637f43afdcbd1b5c13823", + "size_in_bytes": 805 + }, + { + "_path": "Lib/idlelib/idle_test/test_run.py", + "path_type": "hardlink", + "sha256": "3a116bd1038efdb87831c45bece072fae2464cd568f1ddb9cca1d7fb85bf34a9", + "size_in_bytes": 15687 + }, + { + "_path": "Lib/idlelib/idle_test/test_runscript.py", + "path_type": "hardlink", + "sha256": "4264a834dc230d397725f398d905d0746321d543c56644e5c89af59fe3fedb61", + "size_in_bytes": 777 + }, + { + "_path": "Lib/idlelib/idle_test/test_scrolledlist.py", + "path_type": "hardlink", + "sha256": "a84ec601c8786daf0564e978c97c0e14095c23f9a08bb64950f9cb541b074b3a", + "size_in_bytes": 496 + }, + { + "_path": "Lib/idlelib/idle_test/test_search.py", + "path_type": "hardlink", + "sha256": "c0550b241c99a566f61929515ca97aedf99f73568df3dfe93078ed22cb54892b", + "size_in_bytes": 2459 + }, + { + "_path": "Lib/idlelib/idle_test/test_searchbase.py", + "path_type": "hardlink", + "sha256": "2b8550dd411b75c6152c4da90843e1221094400080f9a1752e383d0b776f775b", + "size_in_bytes": 5691 + }, + { + "_path": "Lib/idlelib/idle_test/test_searchengine.py", + "path_type": "hardlink", + "sha256": "519ddd5633eb8732539594f79ed21a6544f65e599a0d5c8c84db3a488ccdad97", + "size_in_bytes": 11588 + }, + { + "_path": "Lib/idlelib/idle_test/test_sidebar.py", + "path_type": "hardlink", + "sha256": "262977182301b015c9d5051d8ac9861eb286f03b4126d3b01e4d6fe36d866f09", + "size_in_bytes": 26854 + }, + { + "_path": "Lib/idlelib/idle_test/test_squeezer.py", + "path_type": "hardlink", + "sha256": "fd5f695e2b1c296719e0a5b494a93184cc7e28cca22e9265def8171b23276b6c", + "size_in_bytes": 19656 + }, + { + "_path": "Lib/idlelib/idle_test/test_stackviewer.py", + "path_type": "hardlink", + "sha256": "15eaeabf43bbaf7d7bc795fb3dfd59c92f3691c73a20548513dcadef8d45b8bf", + "size_in_bytes": 991 + }, + { + "_path": "Lib/idlelib/idle_test/test_statusbar.py", + "path_type": "hardlink", + "sha256": "0e9b262b9ad0046cbb0af1101a651fcb88cd1cba38e474b863abbb074b260a02", + "size_in_bytes": 1133 + }, + { + "_path": "Lib/idlelib/idle_test/test_text.py", + "path_type": "hardlink", + "sha256": "55abe8a9d0bdb45efecb879207f1259702cdcf47dbc636d7cca8dd458f0dc70f", + "size_in_bytes": 6970 + }, + { + "_path": "Lib/idlelib/idle_test/test_textview.py", + "path_type": "hardlink", + "sha256": "e45b199106608c7c981c149d3b4ccf092e7a2e7e9430cc76887cd769b9aaf533", + "size_in_bytes": 7364 + }, + { + "_path": "Lib/idlelib/idle_test/test_tooltip.py", + "path_type": "hardlink", + "sha256": "b9a82e57761bbca3d4e07193652e8294895765092ef8a651f4dcf63acec7f153", + "size_in_bytes": 5385 + }, + { + "_path": "Lib/idlelib/idle_test/test_tree.py", + "path_type": "hardlink", + "sha256": "62ae68d64105485107e8173f94ce09739f276004bc8fa65efa5add2c6188e166", + "size_in_bytes": 1752 + }, + { + "_path": "Lib/idlelib/idle_test/test_undo.py", + "path_type": "hardlink", + "sha256": "c5178b2dd77d794938fa52adce719d4948a92ba1a689068cec1fb6888d033e0e", + "size_in_bytes": 4228 + }, + { + "_path": "Lib/idlelib/idle_test/test_util.py", + "path_type": "hardlink", + "sha256": "300f627fc2199deb246ec793ef47b032de742d763a4170c8bb15e19ccbf602a5", + "size_in_bytes": 308 + }, + { + "_path": "Lib/idlelib/idle_test/test_warning.py", + "path_type": "hardlink", + "sha256": "d1efc442b3fb93de89fb0988c73f8536fc5099afb761d2b69ec101c239c8c193", + "size_in_bytes": 2740 + }, + { + "_path": "Lib/idlelib/idle_test/test_window.py", + "path_type": "hardlink", + "sha256": "336f2b6994f5aacca9689f32249db20a8dac36934314b7d5ba391d94169d63c6", + "size_in_bytes": 1075 + }, + { + "_path": "Lib/idlelib/idle_test/test_zoomheight.py", + "path_type": "hardlink", + "sha256": "6300aa47014a5c2dfc9bc0d6c3fb234dff4e4b60a6527d4cdfbb8c416f99df44", + "size_in_bytes": 999 + }, + { + "_path": "Lib/idlelib/idle_test/test_zzdummy.py", + "path_type": "hardlink", + "sha256": "4502524aaa1923393725c04e6b2f27077399190e42bc8903415e95718c5f3c6f", + "size_in_bytes": 4455 + }, + { + "_path": "Lib/idlelib/idle_test/tkinter_testing_utils.py", + "path_type": "hardlink", + "sha256": "ece147cef65152a54b0a3d4319bdf8ed82d9a6310273b0056cc17a2de4d744cd", + "size_in_bytes": 2333 + }, + { + "_path": "Lib/idlelib/iomenu.py", + "path_type": "hardlink", + "sha256": "7004f1ab2cfa5994e453f426507170ec37c1c4a5b9837ba319e5eaebf1a29c34", + "size_in_bytes": 16159 + }, + { + "_path": "Lib/idlelib/macosx.py", + "path_type": "hardlink", + "sha256": "dd779ec0188847fa526bae492b6a38bab696bd9a1e21ce7c36bd3e74e7d3da0a", + "size_in_bytes": 9401 + }, + { + "_path": "Lib/idlelib/mainmenu.py", + "path_type": "hardlink", + "sha256": "092fad4454f593d7bf2e5e1e746acade92bb346d06476ba527f162f843ae3208", + "size_in_bytes": 3938 + }, + { + "_path": "Lib/idlelib/multicall.py", + "path_type": "hardlink", + "sha256": "efb7d9bddcae17fab2108cb714c240c82d1368087b6d2b91e02ec224ddebce12", + "size_in_bytes": 18652 + }, + { + "_path": "Lib/idlelib/outwin.py", + "path_type": "hardlink", + "sha256": "e1946c1a25a020a48843b2ed528bcdd6df29b2af117472b7e2627997b1339b84", + "size_in_bytes": 5715 + }, + { + "_path": "Lib/idlelib/parenmatch.py", + "path_type": "hardlink", + "sha256": "f122e13c385a135cbbbe8b1d87efeed43ddd3e0be9ddd8aa24b267b61fac4287", + "size_in_bytes": 7204 + }, + { + "_path": "Lib/idlelib/pathbrowser.py", + "path_type": "hardlink", + "sha256": "42a4e008922c991049f1b42ca18700b65f2f8d0ab6dd12cc22671771e90c2065", + "size_in_bytes": 3093 + }, + { + "_path": "Lib/idlelib/percolator.py", + "path_type": "hardlink", + "sha256": "42fe72c167eb3a2795cbe64c498d7cbe1de05132be29a99a58226ae83efb31d4", + "size_in_bytes": 3568 + }, + { + "_path": "Lib/idlelib/pyparse.py", + "path_type": "hardlink", + "sha256": "21c6bf43370998d5a5a6670f7b13409335e9a2c1a350ed586bbe63be5f226648", + "size_in_bytes": 19864 + }, + { + "_path": "Lib/idlelib/pyshell.py", + "path_type": "hardlink", + "sha256": "bf5182b2565539c6ee6c5941db9ba3a4bfa60e21ac17ec23a675a1b2269ab19f", + "size_in_bytes": 62537 + }, + { + "_path": "Lib/idlelib/query.py", + "path_type": "hardlink", + "sha256": "faea5edd6b8693e6a32107054ad0de3be4d28e6aacb7792f86cbbe146131373b", + "size_in_bytes": 15067 + }, + { + "_path": "Lib/idlelib/redirector.py", + "path_type": "hardlink", + "sha256": "7911a7534eb0c73ee3e2464c5f8498109653f73ebed8fa903780c5fd7ca00754", + "size_in_bytes": 6777 + }, + { + "_path": "Lib/idlelib/replace.py", + "path_type": "hardlink", + "sha256": "ea13db39aa89df369b36200c7301874a5636403e8270b1862f946e2fff081b84", + "size_in_bytes": 9841 + }, + { + "_path": "Lib/idlelib/rpc.py", + "path_type": "hardlink", + "sha256": "8d0cb6e11c8dcc5dbda89b9a582bfaa74fe2b661dde442b02eb61b8fc47d9eb3", + "size_in_bytes": 21078 + }, + { + "_path": "Lib/idlelib/run.py", + "path_type": "hardlink", + "sha256": "7d2c0013a3231f78a4b2aee0fbbaee7fb90134b07905ba6a309b4827cbbea945", + "size_in_bytes": 21439 + }, + { + "_path": "Lib/idlelib/runscript.py", + "path_type": "hardlink", + "sha256": "b92740fddc7b1d603b1736a135bd15518081f20c0db1e1a779cab715ee9120fe", + "size_in_bytes": 8273 + }, + { + "_path": "Lib/idlelib/scrolledlist.py", + "path_type": "hardlink", + "sha256": "25b0ad247977f6079226052e2b76dd4c127bf50f2f5e8ffbd1fe10bc631bfca9", + "size_in_bytes": 4478 + }, + { + "_path": "Lib/idlelib/search.py", + "path_type": "hardlink", + "sha256": "c53ff4d4814d97d0d95b7e15030d3ae8c732366ed84c2b300183e933270df724", + "size_in_bytes": 5567 + }, + { + "_path": "Lib/idlelib/searchbase.py", + "path_type": "hardlink", + "sha256": "5e13c99d9f264166d9204eeff0492d43d03f2afd8f66494b3e110d7665ab29cc", + "size_in_bytes": 7856 + }, + { + "_path": "Lib/idlelib/searchengine.py", + "path_type": "hardlink", + "sha256": "11b0c8df926e4f6bd2e26d0264b2d902c41bcc70d68a4a830df1ea2da2c2a6cc", + "size_in_bytes": 7415 + }, + { + "_path": "Lib/idlelib/sidebar.py", + "path_type": "hardlink", + "sha256": "760f14ebb0312adb289cda0562c9eff70982a0acde5d9d9d0b591390cd4a581e", + "size_in_bytes": 20338 + }, + { + "_path": "Lib/idlelib/squeezer.py", + "path_type": "hardlink", + "sha256": "112221334fee94a88cba2ca7ac455e1bd6ab796397cbe036b1e8a98bc0787e30", + "size_in_bytes": 12834 + }, + { + "_path": "Lib/idlelib/stackviewer.py", + "path_type": "hardlink", + "sha256": "ee053a65298e2ec2f4628d8269a33362816271fd81fab4e550a621493c26a76f", + "size_in_bytes": 4016 + }, + { + "_path": "Lib/idlelib/statusbar.py", + "path_type": "hardlink", + "sha256": "3f4dc0f27b0c23e488d022abe8461529ce8a1b4eaf9dbfd97123ef2c502f684e", + "size_in_bytes": 1474 + }, + { + "_path": "Lib/idlelib/textview.py", + "path_type": "hardlink", + "sha256": "eace58159e9636bb1456885c21f5ed474e203090139e5dd3457ac72ad5552006", + "size_in_bytes": 6808 + }, + { + "_path": "Lib/idlelib/tooltip.py", + "path_type": "hardlink", + "sha256": "73dfad0e6652bcd67f7fccdface2e4cd8d5f3c6ffe2ef1c2e86ca0cb12d5d034", + "size_in_bytes": 6471 + }, + { + "_path": "Lib/idlelib/tree.py", + "path_type": "hardlink", + "sha256": "dd594fd0f47ed3cb956d6bc77f72f200144aca13a3c3b9ecd7f472fcefc9256a", + "size_in_bytes": 16483 + }, + { + "_path": "Lib/idlelib/undo.py", + "path_type": "hardlink", + "sha256": "291fda98995bb4688fbe05fd3fa689e21aade3627c4c16e8971ed353f6cc3107", + "size_in_bytes": 11016 + }, + { + "_path": "Lib/idlelib/util.py", + "path_type": "hardlink", + "sha256": "a80958a9f028ed987daf18cd55d78f6db3aff12e9c5629323d992829c0737413", + "size_in_bytes": 731 + }, + { + "_path": "Lib/idlelib/window.py", + "path_type": "hardlink", + "sha256": "ca31d8c01c9b468fcad0a4e529c8e205c1e4ecf30520545db654d466bd7158bd", + "size_in_bytes": 2616 + }, + { + "_path": "Lib/idlelib/zoomheight.py", + "path_type": "hardlink", + "sha256": "5f6ff83cb0df3ee5e7d997ffe23efb341b994bfbaf00b79a4832d54231a095dd", + "size_in_bytes": 4203 + }, + { + "_path": "Lib/idlelib/zzdummy.py", + "path_type": "hardlink", + "sha256": "5e248f0ea4f35052d23bb2c43564aa567b8cebaf91fd63ba0be8fef2f4167945", + "size_in_bytes": 2005 + }, + { + "_path": "Lib/imaplib.py", + "path_type": "hardlink", + "sha256": "43c858a2e8cd721098a6df08967f6b49301b721d1cf3e11526e5bffaf5a29299", + "size_in_bytes": 55217 + }, + { + "_path": "Lib/imghdr.py", + "path_type": "hardlink", + "sha256": "cd784fa55c7e285970600018940bd82e99a82aad3f2d095c53d6612095c24133", + "size_in_bytes": 3952 + }, + { + "_path": "Lib/imp.py", + "path_type": "hardlink", + "sha256": "3c64d27e656df0baaefb1f0953e25a865d18085b07422fdcfba8705c7b3893be", + "size_in_bytes": 10606 + }, + { + "_path": "Lib/importlib/__init__.py", + "path_type": "hardlink", + "sha256": "49ad4fdc8139026f7f3773e3f50f09207ff6bd8e92a2c382545525235448e525", + "size_in_bytes": 6089 + }, + { + "_path": "Lib/importlib/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1794a3a494193ec811cf36e93f246391ca4d2df8bda1c53c64b66eb60357c902", + "size_in_bytes": 6644 + }, + { + "_path": "Lib/importlib/__pycache__/_abc.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "cc87cebf4c7013d01498c876b413937e48406d4cd8fd40e60e0c3d84c2d58101", + "size_in_bytes": 2327 + }, + { + "_path": "Lib/importlib/__pycache__/_bootstrap.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "58e13d6257292e37e24350f34d02eb1f2cdaf883d5eb92a5c1ed50c5fc1836b9", + "size_in_bytes": 57784 + }, + { + "_path": "Lib/importlib/__pycache__/_bootstrap_external.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7b20d752cb294c937b632e8509cae8569e4dff2825fb91a16760ed6e58c950a8", + "size_in_bytes": 72294 + }, + { + "_path": "Lib/importlib/__pycache__/abc.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "dc94084682b2d2442631218aba8792e1e541fe4ef2947e3e6bee7ade8be51040", + "size_in_bytes": 14475 + }, + { + "_path": "Lib/importlib/__pycache__/machinery.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "060cdc1c0f6984a932e1f1d53b118aa5f9085fb4e027c21fbea916c470d35503", + "size_in_bytes": 1284 + }, + { + "_path": "Lib/importlib/__pycache__/readers.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0f8a7b390fec725b78295e648d3d6d89a5a351926abfe89913ac00e949852e31", + "size_in_bytes": 513 + }, + { + "_path": "Lib/importlib/__pycache__/simple.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0f52b933efe6147041dc870252fabea3803553ded25f1d083be82168f543a73b", + "size_in_bytes": 524 + }, + { + "_path": "Lib/importlib/__pycache__/util.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7bc891877766da1d0dfc306c527243744067ac5250a511d80f401d3d97a66837", + "size_in_bytes": 15194 + }, + { + "_path": "Lib/importlib/_abc.py", + "path_type": "hardlink", + "sha256": "e24fa90513d1fd6e10df30dc28044dfcad857b88161c79de10f7109c18227e8d", + "size_in_bytes": 1852 + }, + { + "_path": "Lib/importlib/_bootstrap.py", + "path_type": "hardlink", + "sha256": "2aa31b7369a9725ce893fed35e33a2ffb1c908ecc7411a34d7975cb25a28f695", + "size_in_bytes": 48223 + }, + { + "_path": "Lib/importlib/_bootstrap_external.py", + "path_type": "hardlink", + "sha256": "7c9a59da1b351a226a092b1e1671cf9935255f2c22d593a138c8938dec7e399e", + "size_in_bytes": 68962 + }, + { + "_path": "Lib/importlib/abc.py", + "path_type": "hardlink", + "sha256": "10c316fd409976a2b5a0a379451048e418cce21d2b792820738debe5e2b74c5e", + "size_in_bytes": 10969 + }, + { + "_path": "Lib/importlib/machinery.py", + "path_type": "hardlink", + "sha256": "d045cd7ecf2a12b6ecbfbef79eb114e87ef2ebd756f5b705f73e6f3266e3dede", + "size_in_bytes": 880 + }, + { + "_path": "Lib/importlib/metadata/__init__.py", + "path_type": "hardlink", + "sha256": "bc6d98cd94459ad3b6ea5cb75cde38383647655054f065b897176f7635d2d8bc", + "size_in_bytes": 31109 + }, + { + "_path": "Lib/importlib/metadata/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "520fc687caaa5336aae2616fe572cfd16df8d2e314735286c969ccdeabbcbaeb", + "size_in_bytes": 58941 + }, + { + "_path": "Lib/importlib/metadata/__pycache__/_adapters.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3fcdee564573d7435d6b0ae2d1c14586b531447320f6ddbea4ee2587a3446719", + "size_in_bytes": 3776 + }, + { + "_path": "Lib/importlib/metadata/__pycache__/_collections.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1f5ba8e6d7812362cd9f4e78581e176712663f41f410cb6bc95434951cdab003", + "size_in_bytes": 2123 + }, + { + "_path": "Lib/importlib/metadata/__pycache__/_functools.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2ee551bfe7e6cb66c481cdd1d0901320c0f8ad34ec4699792771061cc7c8085b", + "size_in_bytes": 3563 + }, + { + "_path": "Lib/importlib/metadata/__pycache__/_itertools.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6ede290b4e73ce122373192e47199ea35f91ad79933fbe08172bb55e69b34799", + "size_in_bytes": 2526 + }, + { + "_path": "Lib/importlib/metadata/__pycache__/_meta.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "77fccf1a88287dd1545780f599d4a42b3d362e989cc4b233769086079bd07069", + "size_in_bytes": 2894 + }, + { + "_path": "Lib/importlib/metadata/__pycache__/_text.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0f99f98a02042b7c36bda46ca5e9d3d31305a138235e5268c8d967c2f30151f6", + "size_in_bytes": 4321 + }, + { + "_path": "Lib/importlib/metadata/_adapters.py", + "path_type": "hardlink", + "sha256": "07a7c28b9fbc98b543154663de4ac8e67028fa62a9d5d1ffa886afc88c85ac9b", + "size_in_bytes": 1862 + }, + { + "_path": "Lib/importlib/metadata/_collections.py", + "path_type": "hardlink", + "sha256": "089d0e4c21c88d6034648552e2fa0e440b27d91e11d9c40112d3ec6442690126", + "size_in_bytes": 743 + }, + { + "_path": "Lib/importlib/metadata/_functools.py", + "path_type": "hardlink", + "sha256": "3ec636fb8aeb297e1155e442d681a9d65075a660bd78a37cf3f7fe6c3f6e3a80", + "size_in_bytes": 2895 + }, + { + "_path": "Lib/importlib/metadata/_itertools.py", + "path_type": "hardlink", + "sha256": "72faffdaff0145bc5c225e71e6575fa9d1e3848f188bcb3cca4e741bf9e6ea34", + "size_in_bytes": 2068 + }, + { + "_path": "Lib/importlib/metadata/_meta.py", + "path_type": "hardlink", + "sha256": "c920f8096b01e6a23a15375520bf3de6b418504df58d6e506f2fb203395d4512", + "size_in_bytes": 1134 + }, + { + "_path": "Lib/importlib/metadata/_text.py", + "path_type": "hardlink", + "sha256": "1c2b0592c66924b7933f734493f9e0ac079755146d4ebb7287d78e001a113f80", + "size_in_bytes": 2166 + }, + { + "_path": "Lib/importlib/readers.py", + "path_type": "hardlink", + "sha256": "d0d57d118d64916f7e6edb04f8bd1a760a1abb879125899ef50a36d09ef54df4", + "size_in_bytes": 327 + }, + { + "_path": "Lib/importlib/resources/__init__.py", + "path_type": "hardlink", + "sha256": "7af3e6d7690b818a939bea5bce6eb46cebae9ae993f08a41356169d2e332af31", + "size_in_bytes": 506 + }, + { + "_path": "Lib/importlib/resources/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "bbae8f728cfde09e553c92e4560a4104d7389cec33757041b9a2a48cede9bd98", + "size_in_bytes": 758 + }, + { + "_path": "Lib/importlib/resources/__pycache__/_adapters.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9cb368cec2bb62319dc190c8c98a6377c9fd9732e623caa8c2cca87f9794c5b6", + "size_in_bytes": 10675 + }, + { + "_path": "Lib/importlib/resources/__pycache__/_common.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ce1775766776377981b690f2a6c46589f82aa84d7c7f7545062abe331379992c", + "size_in_bytes": 4221 + }, + { + "_path": "Lib/importlib/resources/__pycache__/_itertools.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f0acf30a783536fa7f8e1fa14ab7d46c5d83d87da361d3bdd79f219b9900edd7", + "size_in_bytes": 1320 + }, + { + "_path": "Lib/importlib/resources/__pycache__/_legacy.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4f46487471f1cf92f73fdd7d2a9f98d4b31e173a78dd3de3f66284645912de15", + "size_in_bytes": 6418 + }, + { + "_path": "Lib/importlib/resources/__pycache__/abc.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4614f4469f24568c0d2aa4865bf4575c7b5c139605d6315e3cbeddbd108d8f13", + "size_in_bytes": 8482 + }, + { + "_path": "Lib/importlib/resources/__pycache__/readers.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f49e80265cc261f30eb3b6a89c8012351c2eac8172d720f305b21b767884434f", + "size_in_bytes": 8281 + }, + { + "_path": "Lib/importlib/resources/__pycache__/simple.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d65448d4d0b088b38bc5ac1fa4f4c29c87590b5ae70005f2acc55e6bfbd3b330", + "size_in_bytes": 6864 + }, + { + "_path": "Lib/importlib/resources/_adapters.py", + "path_type": "hardlink", + "sha256": "a39d6d3f686956da213f7de0498c809063692df60306ac7162c69dca24598b51", + "size_in_bytes": 4504 + }, + { + "_path": "Lib/importlib/resources/_common.py", + "path_type": "hardlink", + "sha256": "d4c487b710c16cbb061999417d2bf297ce6f21309f9d81d353d6e627b1126d8c", + "size_in_bytes": 2891 + }, + { + "_path": "Lib/importlib/resources/_itertools.py", + "path_type": "hardlink", + "sha256": "582749d46b3f90d170284372206ed33b4638df82160aed338d5552b126d9c14f", + "size_in_bytes": 884 + }, + { + "_path": "Lib/importlib/resources/_legacy.py", + "path_type": "hardlink", + "sha256": "4cc2e4c7a68433a53cc484443d7a8666b31b5214e23d4b8f97a1120fb45d623e", + "size_in_bytes": 3494 + }, + { + "_path": "Lib/importlib/resources/abc.py", + "path_type": "hardlink", + "sha256": "d106439f012fb61aa2410e779fcd979ac1d3d677a85e0db5588baf8080100ea8", + "size_in_bytes": 4571 + }, + { + "_path": "Lib/importlib/resources/readers.py", + "path_type": "hardlink", + "sha256": "21505ac8f35d6d23d737623baec9651e021ccb5f789271703e5fd447d9942d10", + "size_in_bytes": 3557 + }, + { + "_path": "Lib/importlib/resources/simple.py", + "path_type": "hardlink", + "sha256": "ba32ec6537797cadde6d29ca91025d30d6368d4e5ef5a73ad20897604c8db92a", + "size_in_bytes": 3123 + }, + { + "_path": "Lib/importlib/simple.py", + "path_type": "hardlink", + "sha256": "8e687aeeb1db537d2717cb0352c5f126ff7d4095c6de6dc7f00d5103f3009c40", + "size_in_bytes": 354 + }, + { + "_path": "Lib/importlib/util.py", + "path_type": "hardlink", + "sha256": "a1f26649b3409cc90627d3657dd8d38d159bd7e7a2ce34ecca1297119701f608", + "size_in_bytes": 12717 + }, + { + "_path": "Lib/inspect.py", + "path_type": "hardlink", + "sha256": "7a134c67f2256307547f2f0b81eb6f89b652c078ab22e59c062770ba9736c6ff", + "size_in_bytes": 123419 + }, + { + "_path": "Lib/io.py", + "path_type": "hardlink", + "sha256": "12636601d4f488b583cff41668c3a386c3b2d93499df09de0df9d9a2a4b95194", + "size_in_bytes": 4320 + }, + { + "_path": "Lib/ipaddress.py", + "path_type": "hardlink", + "sha256": "ba8d3389ff084fcb232b48204ec04f2b3ea4bd0eadf7b18c814947d185de2c64", + "size_in_bytes": 81414 + }, + { + "_path": "Lib/json/__init__.py", + "path_type": "hardlink", + "sha256": "d5d41e2c29049515d295d81a6d40b4890fbec8d8482cfb401630f8ef2f77e4d5", + "size_in_bytes": 14020 + }, + { + "_path": "Lib/json/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "971e2d92ddf82a8400f2128e11ce0e89734cc44d7a8c448a9ba48fd58ed1d2ee", + "size_in_bytes": 14204 + }, + { + "_path": "Lib/json/__pycache__/decoder.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7c1b4f4a5ca6e8f4472294945d29fb78b0827b4feb2e1cf1ed5302eb78fac484", + "size_in_bytes": 15171 + }, + { + "_path": "Lib/json/__pycache__/encoder.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "097edf0bd744033b5ae206d5ad11e07e816af63590023621174a4cc9b3d34c83", + "size_in_bytes": 16783 + }, + { + "_path": "Lib/json/__pycache__/scanner.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "06118bf1c3dd194f6ebe522af321b250ad95f75f7289e923ac02acdc31fc6c79", + "size_in_bytes": 3631 + }, + { + "_path": "Lib/json/__pycache__/tool.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2d246d43e39ca3892e2fa684507c078c5c668b92efbcfbc516d3eeb435fe7705", + "size_in_bytes": 4734 + }, + { + "_path": "Lib/json/decoder.py", + "path_type": "hardlink", + "sha256": "9f02654649816145bc76f8c210a5fe3ba1de142d4d97a1c93105732e747c285b", + "size_in_bytes": 12473 + }, + { + "_path": "Lib/json/encoder.py", + "path_type": "hardlink", + "sha256": "af7bd40a0d0d0a3e726a9b4b3a2a543019f6ab97a340d0162a9c29ca9da97869", + "size_in_bytes": 16070 + }, + { + "_path": "Lib/json/scanner.py", + "path_type": "hardlink", + "sha256": "8604d9d03786d0d509abb49e9f069337278ea988c244069ae8ca2c89acc2cb08", + "size_in_bytes": 2425 + }, + { + "_path": "Lib/json/tool.py", + "path_type": "hardlink", + "sha256": "d5174b728b376a12cff3f17472d6b9b609c1d3926f7ee02d74d60c80afd60c77", + "size_in_bytes": 3339 + }, + { + "_path": "Lib/keyword.py", + "path_type": "hardlink", + "sha256": "afbe73afb68d32fa998e5ff3d081090deec457152470f5331cc2bd430a0e9d2a", + "size_in_bytes": 1061 + }, + { + "_path": "Lib/lib2to3/Grammar.txt", + "path_type": "hardlink", + "sha256": "508e62e787dd756eb0a4eb1b8d128320ca02cd246ab14cc8ce0a476dc88cc5b6", + "size_in_bytes": 8696 + }, + { + "_path": "Lib/lib2to3/Grammar3.11.15.final.0.pickle", + "path_type": "hardlink", + "sha256": "97c8ed74d091fcfd23498029bb819c29d096c3dcb1326edee5dfb0591ade2e4b", + "size_in_bytes": 15313 + }, + { + "_path": "Lib/lib2to3/PatternGrammar.txt", + "path_type": "hardlink", + "sha256": "ee5ba5db3b6722a0e2fbe2560ebc1c883e72328ef9c3b4da1c7c5d1cc649bce3", + "size_in_bytes": 793 + }, + { + "_path": "Lib/lib2to3/PatternGrammar3.11.15.final.0.pickle", + "path_type": "hardlink", + "sha256": "36ee934395b9209737b13893ddaff05fad8e239c2fdfac29d401d3fceeb30768", + "size_in_bytes": 1225 + }, + { + "_path": "Lib/lib2to3/__init__.py", + "path_type": "hardlink", + "sha256": "5373a81ab198cda8e95652dff46ecfee197a0b8901e8432ab448d97b8bc37f87", + "size_in_bytes": 156 + }, + { + "_path": "Lib/lib2to3/__main__.py", + "path_type": "hardlink", + "sha256": "c7b09f90e66dea194ad63dc02c6425dff977d16f1f21a157b7475905c219a707", + "size_in_bytes": 67 + }, + { + "_path": "Lib/lib2to3/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a29878fdcb27eb3a99a43298098fe7bbff2ca3999da59b93342e3506c586a3ec", + "size_in_bytes": 355 + }, + { + "_path": "Lib/lib2to3/__pycache__/__main__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c9ecdf38acb71dcdeed5ae50c56f39e439db90c80fef3e9dca3359a5ced6529a", + "size_in_bytes": 299 + }, + { + "_path": "Lib/lib2to3/__pycache__/btm_matcher.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0c8184a69e0fa00b4d978c774b40a7f47ab565ff8fe6f0afda4863bbce0b5275", + "size_in_bytes": 7782 + }, + { + "_path": "Lib/lib2to3/__pycache__/btm_utils.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "245d99e73e0b56a6c4c76d645371c0b2729ae2fbd09e0a5375ef2e2fca2b7cf3", + "size_in_bytes": 11498 + }, + { + "_path": "Lib/lib2to3/__pycache__/fixer_base.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a0b5f8b54f8db26053a576b6b81f03ca90b3496698023da78962ae3d3c2f1671", + "size_in_bytes": 8399 + }, + { + "_path": "Lib/lib2to3/__pycache__/fixer_util.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d9396b67fdd35c591abc3c3d15a432090a1171ae9399db2a72fc1118fe23a741", + "size_in_bytes": 22349 + }, + { + "_path": "Lib/lib2to3/__pycache__/main.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "23493361dd06ef9a1a357fe3cf2c52240a0dcc72253e9fdaf0b71d81183305f5", + "size_in_bytes": 15234 + }, + { + "_path": "Lib/lib2to3/__pycache__/patcomp.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "bf277174ef0d41832763e3044664bc9294b11d06200badad1e5ac933b298df19", + "size_in_bytes": 10693 + }, + { + "_path": "Lib/lib2to3/__pycache__/pygram.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "741b455df77d183a0c3baf8aae031f3cfc3990d288f7d82915b050d616c8bdb0", + "size_in_bytes": 2038 + }, + { + "_path": "Lib/lib2to3/__pycache__/pytree.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ccd6c816e1047ca40219ac6bddd83d9297a923120cd1d3dc0d9e91a2bed649c8", + "size_in_bytes": 36961 + }, + { + "_path": "Lib/lib2to3/__pycache__/refactor.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a0c81c5be21662c44ccd28351be1a480ed9e30f76f2c8540bff3388603b69e76", + "size_in_bytes": 38494 + }, + { + "_path": "Lib/lib2to3/btm_matcher.py", + "path_type": "hardlink", + "sha256": "a1aa5d35558acf4b6016054963285cb145f97a764926bea07cbd674563f3248d", + "size_in_bytes": 6623 + }, + { + "_path": "Lib/lib2to3/btm_utils.py", + "path_type": "hardlink", + "sha256": "c0653eb497a1a48195dd9c4ecbbf87e4eab31188be29ab1640e353209741588c", + "size_in_bytes": 9945 + }, + { + "_path": "Lib/lib2to3/fixer_base.py", + "path_type": "hardlink", + "sha256": "c795a53ca849c42212c8ec33a74284e0377df852eb4ea599aba62d5af1df282a", + "size_in_bytes": 6690 + }, + { + "_path": "Lib/lib2to3/fixer_util.py", + "path_type": "hardlink", + "sha256": "306d0b2ea8169bdca711c6a31c0b1a3ce710d38ae2b6568ef519aa38451af608", + "size_in_bytes": 15206 + }, + { + "_path": "Lib/lib2to3/fixes/__init__.py", + "path_type": "hardlink", + "sha256": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9", + "size_in_bytes": 47 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7657823c59d4687578039888c5e111223a0cbf2abeb86bc16d114bbbc4e9a0cd", + "size_in_bytes": 138 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_apply.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "94dc695a080fbb11950f1dd5bd8ee49136d6851dee504c66cd830583f3065e88", + "size_in_bytes": 2808 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_asserts.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "276154214f28d745b3fac7c117986ff8a175decb672f7c1153203cc26e4330c5", + "size_in_bytes": 1725 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_basestring.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9eee0ff9166bef564460cc65d865e6bb81516767ff333066431013ecdc6a42d3", + "size_in_bytes": 854 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_buffer.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a813fb29a82c35e187ba04510aeb1b129c609a2f59d4f8c5ff6dbccd773b6a18", + "size_in_bytes": 1072 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_dict.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "05f10b67afe2167d11330e2c9ca73f4a2ea55fe3a1824e2cc272d085003553e3", + "size_in_bytes": 5013 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_except.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d8cc5a528f5bee4132b5e437488fd4ab54603f67e7c0f8281549d94ce58e2d50", + "size_in_bytes": 4770 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_exec.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "39536be71b636aeda7a322273429d4759727a472cd949dda849fa6c3b65637da", + "size_in_bytes": 1812 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_execfile.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1213594105f90e5bf34b65ac765d933201cd2f1edf7c8425bd04bdb091d825bb", + "size_in_bytes": 3184 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_exitfunc.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b0b722a78ba4455a91d9fafc058fec46bfc5a20ef8c39b056250c39c99558847", + "size_in_bytes": 3921 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_filter.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "071fe15f51f1af429533add9678ee7c098fb8bc120702f54dfd0f7d3f1d2168e", + "size_in_bytes": 4035 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_funcattrs.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d23cc493c9e10dacdc8eef4b00d09ebc847d1d8c6bd73e23c836e3ed29fd886e", + "size_in_bytes": 1294 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_future.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "62eefd5ea0cd79c2742b728dbafceec8fd4def90d1b04813e6278660099d8c43", + "size_in_bytes": 991 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_getcwdu.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c0cd3fea1c85b10144f6bb1b2c0e8b3d4387c09f52c43d897a70859b9ef6af3b", + "size_in_bytes": 1051 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_has_key.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ebf5458a5522cbb75d0e18c6eb133f9e5ef73cbf6636774a9cb777ba7a2d6518", + "size_in_bytes": 4445 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_idioms.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "55c0ed088ffa5179d83810ca1c31b77557d467b1ae08e277f5473dc5e3274ffc", + "size_in_bytes": 6062 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_import.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3e9fe7c906a9b11f38ab57f860b776943b231e2f51bf98169bb060812dfdb65b", + "size_in_bytes": 4780 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_imports.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "924abfb5e4de274562698cb04718aa168917e6adaae35a2a9c1562f6e50d8d94", + "size_in_bytes": 6928 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_imports2.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2d20661ae8abcd406cfb4d45c557ba8580c870db77355cc187622bbbfad36a7d", + "size_in_bytes": 668 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_input.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0d2f5d2bdb329b6ab8ca00a5b92fc98c0ccee25d9ab90eb11d16264377183d37", + "size_in_bytes": 1379 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_intern.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6d4e5f030311f02ceac13e676b4b727b865c754d26446c7c7a2e0a834c568123", + "size_in_bytes": 1491 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_isinstance.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "48a1293d82c6f9a449380fa0c46673fe928de240ea0b280accb333f7ca772a06", + "size_in_bytes": 2467 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_itertools.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "253ef86dd6f5520cf7af90af1c4389bbc5e5bb7d344cb6e635e3f1812cc9255a", + "size_in_bytes": 2117 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_itertools_imports.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c3722630826878205db6e665ffa8d92711326036495674e06f680f0771ee9408", + "size_in_bytes": 2760 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_long.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2187c9b4f4c17bdfed0c1a7dc7ed643ddbc59afd40494de737c76d89479e5ccc", + "size_in_bytes": 961 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_map.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d5702e4c47c13b956ed3aca91ff6af1da9c63eae217ab22de653caa8b5ffef69", + "size_in_bytes": 4814 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_metaclass.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7e2e0a5523cd16ce90abc320c295aff4639112f4a49555770c6161177b347805", + "size_in_bytes": 10739 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_methodattrs.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "53130caa194a595ddcdf2f62a2721895303890385c6f331475935f95337364ce", + "size_in_bytes": 1265 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_ne.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "df527929d984e16e1fe6a4f906ca1c7d4587d44681e9e17052de273edd0d269b", + "size_in_bytes": 1100 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_next.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a4a9a12d3bee0e3f2cb6a876ed44cc98b1b24240206c8bc8d82705669d6ed5e2", + "size_in_bytes": 5210 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_nonzero.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1f11255c52a06713e0e29807fa928283944141d3a8deb8b23f1019aca0a6cffb", + "size_in_bytes": 1186 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_numliterals.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6b06f6453f2eca9b60da9044d725fd24aca2fdd59bb38aa7bdec1250f2882fe5", + "size_in_bytes": 1597 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_operator.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1425a133b478acc306aced8051b62b36100441c2bc72764864ae390b2b3f9332", + "size_in_bytes": 6236 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_paren.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4dafde9dc9a99105bb5fb36137b0a5b039aeac7764678085fe14752c8dc5104e", + "size_in_bytes": 1762 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_print.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "77e26048dfd0e2ec0e6c8422fe147e5eeec12e66b06befc872dd8b61fd72a0bf", + "size_in_bytes": 4114 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_raise.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5f562a6c1add7c0d1db0c98c2043b8864e716352854fe37afb8ca686ef50b98c", + "size_in_bytes": 3751 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_raw_input.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "536ab8e52ac6d306ce94b07ab447ead120f76389b0ac9ed3438ff6db9d194c38", + "size_in_bytes": 1054 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_reduce.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "711052702d1f949f59a56d1a3b509aaa2edc1d4baa00b3d6fd09c4791e49d6bd", + "size_in_bytes": 1323 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_reload.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2929bf5451e39af0e5b0c8a63c4318b6e2feb9bfea414f2470e3a710f0dddb92", + "size_in_bytes": 1503 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_renames.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0ef3a5502e9eaa63f1a9dd370fb7269262249c1f736fdf118f84ec9f14c72008", + "size_in_bytes": 3341 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_repr.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7e697d2592cafd49b6272e6b39e519c43a5ae5288242ee55a62aea5b30b6cfbf", + "size_in_bytes": 1221 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_set_literal.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "148bab3de69492c6f756c384f0110af58900d544c098c39f7f193598b9436867", + "size_in_bytes": 2734 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_standarderror.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "48cad54514786d3b015dcb22ce51db5368b0edbee9cda986c4618bf7c531170c", + "size_in_bytes": 915 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_sys_exc.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "01cc0522ab228a9f84a50417f3bbdc6b3a4f671d9704319de1b88397e2ba1227", + "size_in_bytes": 2216 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_throw.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c473d1ea1ca0803009a76776aee51a3f149b0005d2e610f42d8a745d809d04c5", + "size_in_bytes": 2877 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_tuple_params.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7b8c67ef3f5cca4b123a4f35c9e0cab8592c7033c2365f6a2c1c06e1b925e4e5", + "size_in_bytes": 8639 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_types.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d232ad49464fa7870002de2729c7971c1260a26148fcf4cc36077b8b1f5c5466", + "size_in_bytes": 2490 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_unicode.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "56fd0ef4f509c83ea6be00abb4fdb3da583ab80b750b524719bfe2c6a1a39852", + "size_in_bytes": 2516 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_urllib.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6492c4ac44d16099d7afe4fce2e2e87a925114b7e87329c5dfcb6deb418b33c9", + "size_in_bytes": 10405 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_ws_comma.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5585ee5c117ea6c899d10b8fd053c42288c6a995e2de44183e91f557e84c72e4", + "size_in_bytes": 1617 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_xrange.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "298d584f599318134716483cd6cc158db6ff0e245efbf399b33ae0feb990ff06", + "size_in_bytes": 4190 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_xreadlines.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "49f2abaab0368e9312c8fce43d91f7064ac0eabcba6b272c4a2b0fab23343c2b", + "size_in_bytes": 1579 + }, + { + "_path": "Lib/lib2to3/fixes/__pycache__/fix_zip.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5e191fe1172d76abb19af206c2cf910ad744fd94b15e7f855a6a67e9a05599b5", + "size_in_bytes": 2334 + }, + { + "_path": "Lib/lib2to3/fixes/fix_apply.py", + "path_type": "hardlink", + "sha256": "b5171e32758a78450854f40867775d4aca58665bc920ebece04fcfcc153af02a", + "size_in_bytes": 2346 + }, + { + "_path": "Lib/lib2to3/fixes/fix_asserts.py", + "path_type": "hardlink", + "sha256": "4c77972812cb5ec0a72afbce3e1d618c27ef7b239329c5c952c2bcbe77dba5dd", + "size_in_bytes": 984 + }, + { + "_path": "Lib/lib2to3/fixes/fix_basestring.py", + "path_type": "hardlink", + "sha256": "d041443d6499a735bb78fec9da1bf33b3d034b5192c98bc273b16a44692fc88f", + "size_in_bytes": 320 + }, + { + "_path": "Lib/lib2to3/fixes/fix_buffer.py", + "path_type": "hardlink", + "sha256": "2da37b49c30d6a0b4db43146ebb4ac8e5ffcb9814816b4742e464cb856977883", + "size_in_bytes": 590 + }, + { + "_path": "Lib/lib2to3/fixes/fix_dict.py", + "path_type": "hardlink", + "sha256": "38f460596ebfb64046aab3d9a65935bd4c76a470118fb7d10a088dc0ecdc53ea", + "size_in_bytes": 3760 + }, + { + "_path": "Lib/lib2to3/fixes/fix_except.py", + "path_type": "hardlink", + "sha256": "7ff6f560c3c3d7a5d9ceef5ba31c556341f7ce1bc1b52d96b063f6c2c4765651", + "size_in_bytes": 3344 + }, + { + "_path": "Lib/lib2to3/fixes/fix_exec.py", + "path_type": "hardlink", + "sha256": "9e0893327205dea12004e88d18c580286e7977e081b5eda7baf5b7bc93bc6c52", + "size_in_bytes": 979 + }, + { + "_path": "Lib/lib2to3/fixes/fix_execfile.py", + "path_type": "hardlink", + "sha256": "6ff65db1192099457cb3d9f2618a893c6ac430028550284f3a34d5c08042b0eb", + "size_in_bytes": 2048 + }, + { + "_path": "Lib/lib2to3/fixes/fix_exitfunc.py", + "path_type": "hardlink", + "sha256": "ef4f18f651d32410c43644c27590903d41e38e763b0e108e6c685a3412a7d29c", + "size_in_bytes": 2495 + }, + { + "_path": "Lib/lib2to3/fixes/fix_filter.py", + "path_type": "hardlink", + "sha256": "2c7f0121193395750eab2b2abf5059d9a3b1a61f81763f52511265d7bca5cb21", + "size_in_bytes": 2765 + }, + { + "_path": "Lib/lib2to3/fixes/fix_funcattrs.py", + "path_type": "hardlink", + "sha256": "111df53fac6a121d61abe33883a68e731820ddc4864b0a4c1000cf2ac5f019cd", + "size_in_bytes": 644 + }, + { + "_path": "Lib/lib2to3/fixes/fix_future.py", + "path_type": "hardlink", + "sha256": "baba8cafb48dd9181a0e1f7b0f20b585ce2925e8f347e00b87407a256bb16663", + "size_in_bytes": 547 + }, + { + "_path": "Lib/lib2to3/fixes/fix_getcwdu.py", + "path_type": "hardlink", + "sha256": "5bc5252f683a401e7d81c5911617c4af1a1bcdf99a51c4bf1cfccb00446ff220", + "size_in_bytes": 451 + }, + { + "_path": "Lib/lib2to3/fixes/fix_has_key.py", + "path_type": "hardlink", + "sha256": "32943d3b921c1c3f0d3776d19e5120806990b817bc99a7e22799847abfda1f63", + "size_in_bytes": 3196 + }, + { + "_path": "Lib/lib2to3/fixes/fix_idioms.py", + "path_type": "hardlink", + "sha256": "600e34faf36e14307e59d55088e3979881d497b8fc9d77659e77709f9e8bafd7", + "size_in_bytes": 4876 + }, + { + "_path": "Lib/lib2to3/fixes/fix_import.py", + "path_type": "hardlink", + "sha256": "803baf96f9603c957eb974f252b0ad9829c889a293e0ce6829db1bce3da6dd4e", + "size_in_bytes": 3256 + }, + { + "_path": "Lib/lib2to3/fixes/fix_imports.py", + "path_type": "hardlink", + "sha256": "cdf7ee6d85e2b148230984cfc4ea3f193be458958ea42ef290854a9672a64370", + "size_in_bytes": 5684 + }, + { + "_path": "Lib/lib2to3/fixes/fix_imports2.py", + "path_type": "hardlink", + "sha256": "b6f3c628839ffe7fd72569dd6ca2210e18edae3e180002747ea011b76b7ec0ef", + "size_in_bytes": 289 + }, + { + "_path": "Lib/lib2to3/fixes/fix_input.py", + "path_type": "hardlink", + "sha256": "10c5ef3b45a4ee7e88af8852181916a788aae2bea52b08f3473815c1c43598d1", + "size_in_bytes": 708 + }, + { + "_path": "Lib/lib2to3/fixes/fix_intern.py", + "path_type": "hardlink", + "sha256": "8d29a162536b99c91bd2f9259dda7f39fec751949d6354d2c1f2e5d070c87d66", + "size_in_bytes": 1144 + }, + { + "_path": "Lib/lib2to3/fixes/fix_isinstance.py", + "path_type": "hardlink", + "sha256": "8408c92b99f50d8c4978b47a2b2155588e315f2ebbe58c160dcdcdcb89e19914", + "size_in_bytes": 1608 + }, + { + "_path": "Lib/lib2to3/fixes/fix_itertools.py", + "path_type": "hardlink", + "sha256": "578a51b9935020b03a510de15ece55fcd02c9474f37a54c158fb97ba5fd15af1", + "size_in_bytes": 1548 + }, + { + "_path": "Lib/lib2to3/fixes/fix_itertools_imports.py", + "path_type": "hardlink", + "sha256": "2e419cfbd7f2a326ae7fa10873aa377112ebec32545238fdf988acb088c3cdb7", + "size_in_bytes": 2086 + }, + { + "_path": "Lib/lib2to3/fixes/fix_long.py", + "path_type": "hardlink", + "sha256": "306b80e0a72c0d16dd934b7d51ab0c9a4224f83be5d6cbad8a7158a0a5d73551", + "size_in_bytes": 476 + }, + { + "_path": "Lib/lib2to3/fixes/fix_map.py", + "path_type": "hardlink", + "sha256": "b82c0762c44adf2af7745c030afe291e2badfe360925046c8e58d85340717696", + "size_in_bytes": 3640 + }, + { + "_path": "Lib/lib2to3/fixes/fix_metaclass.py", + "path_type": "hardlink", + "sha256": "45a30c866aa2ff69e089da147ed09986aad4516b5e5dd943f8dfcb7d3946a3e1", + "size_in_bytes": 8197 + }, + { + "_path": "Lib/lib2to3/fixes/fix_methodattrs.py", + "path_type": "hardlink", + "sha256": "8d60082f98ce52ee4955099bfd447cbadfa0e9b24ccb8d135cecc833168d44e8", + "size_in_bytes": 606 + }, + { + "_path": "Lib/lib2to3/fixes/fix_ne.py", + "path_type": "hardlink", + "sha256": "4f9cb1388ba86f29422d20979d3423fdf3541ba35a17ed44d6f4a517ff784ecd", + "size_in_bytes": 571 + }, + { + "_path": "Lib/lib2to3/fixes/fix_next.py", + "path_type": "hardlink", + "sha256": "5c7d86d9f81b2498486d626c7feced1b92f23171cf9e42881abb78de1a93bccd", + "size_in_bytes": 3174 + }, + { + "_path": "Lib/lib2to3/fixes/fix_nonzero.py", + "path_type": "hardlink", + "sha256": "c2cd7e3ba44508643a20eec4ea4c19f2f1adfd36f6b974d7c143e449571ae736", + "size_in_bytes": 591 + }, + { + "_path": "Lib/lib2to3/fixes/fix_numliterals.py", + "path_type": "hardlink", + "sha256": "1c4dd0f7881999abde6cf4d232836fa3e55fc41a7d5aa2b9866092f65707db7f", + "size_in_bytes": 768 + }, + { + "_path": "Lib/lib2to3/fixes/fix_operator.py", + "path_type": "hardlink", + "sha256": "023872fe9f03a25387cf2c17fc950cf0f990353df66e603c3a1cd3199dbccd86", + "size_in_bytes": 3426 + }, + { + "_path": "Lib/lib2to3/fixes/fix_paren.py", + "path_type": "hardlink", + "sha256": "53734f1d7778ad28a4ec3ab4415923e2da8f230de4cd527589829f570e9f254d", + "size_in_bytes": 1226 + }, + { + "_path": "Lib/lib2to3/fixes/fix_print.py", + "path_type": "hardlink", + "sha256": "cf2690f1b502249289f52cd544190db0b94d59df5eca139829cd2bf0742e9dba", + "size_in_bytes": 2844 + }, + { + "_path": "Lib/lib2to3/fixes/fix_raise.py", + "path_type": "hardlink", + "sha256": "c38ffec5862597ee8f9dac50385af943ee312bfc394366be08b2fc12563ca1a5", + "size_in_bytes": 2926 + }, + { + "_path": "Lib/lib2to3/fixes/fix_raw_input.py", + "path_type": "hardlink", + "sha256": "ce04cbaa76d414949afc230360dd9a29ff579bd868cc7f8805230d126ac9ce9b", + "size_in_bytes": 454 + }, + { + "_path": "Lib/lib2to3/fixes/fix_reduce.py", + "path_type": "hardlink", + "sha256": "9a03910a6c183586e1db01863fcde6417d06745fb3e63032333d71c5e82e7919", + "size_in_bytes": 837 + }, + { + "_path": "Lib/lib2to3/fixes/fix_reload.py", + "path_type": "hardlink", + "sha256": "17570148167e43b2155b6e1c814a3cca9e3ef53750c504932a9c7d62a8b68a3f", + "size_in_bytes": 1081 + }, + { + "_path": "Lib/lib2to3/fixes/fix_renames.py", + "path_type": "hardlink", + "sha256": "8b71472317bf3adabf819e665c725d03e3064baa45f6ffbfd78cca83eaa46e8d", + "size_in_bytes": 2221 + }, + { + "_path": "Lib/lib2to3/fixes/fix_repr.py", + "path_type": "hardlink", + "sha256": "d16930b7ef8577747cfef602aba854c64ce85d4ae1e54a18a456eaa202643e3d", + "size_in_bytes": 613 + }, + { + "_path": "Lib/lib2to3/fixes/fix_set_literal.py", + "path_type": "hardlink", + "sha256": "33f2c0b6e16357e083c3a98877e7317abe1578a44c288e5979c9d96fb5aa6727", + "size_in_bytes": 1697 + }, + { + "_path": "Lib/lib2to3/fixes/fix_standarderror.py", + "path_type": "hardlink", + "sha256": "ce7eb37bc7fb29aa138b1cec6656ae8b4886cbfa700e119a1bb8484284cb717a", + "size_in_bytes": 449 + }, + { + "_path": "Lib/lib2to3/fixes/fix_sys_exc.py", + "path_type": "hardlink", + "sha256": "0143830586d09d702ca3eeaa8f86698e5fd18af69fd28147e71a1a77600d356a", + "size_in_bytes": 1034 + }, + { + "_path": "Lib/lib2to3/fixes/fix_throw.py", + "path_type": "hardlink", + "sha256": "fec731ed523d5cdfa21893833b52b2844eabfd1549792c1c9f8ceac2d0e8e901", + "size_in_bytes": 1582 + }, + { + "_path": "Lib/lib2to3/fixes/fix_tuple_params.py", + "path_type": "hardlink", + "sha256": "f3307d4750d0657d9c42b857d5f37bdb5824f9358939da7d16d13f61eb8abc72", + "size_in_bytes": 5565 + }, + { + "_path": "Lib/lib2to3/fixes/fix_types.py", + "path_type": "hardlink", + "sha256": "a0a133cfc78e82e1f71ce628408e7d10a38552ba3e3228ebd113838c1ce44484", + "size_in_bytes": 1774 + }, + { + "_path": "Lib/lib2to3/fixes/fix_unicode.py", + "path_type": "hardlink", + "sha256": "01b2a9b1084b6a0424f27eec488c761f75f053a409608ec36a9ee0ede0d38097", + "size_in_bytes": 1256 + }, + { + "_path": "Lib/lib2to3/fixes/fix_urllib.py", + "path_type": "hardlink", + "sha256": "3d1c04d976ff4d2841025a785aaab0cc4ee06c9c9b4e09d1e2456949fa273856", + "size_in_bytes": 8367 + }, + { + "_path": "Lib/lib2to3/fixes/fix_ws_comma.py", + "path_type": "hardlink", + "sha256": "5e7a16daec0b2619110516804bf90cac459a4d0315198fd4eff69c36c54378dd", + "size_in_bytes": 1090 + }, + { + "_path": "Lib/lib2to3/fixes/fix_xrange.py", + "path_type": "hardlink", + "sha256": "60d8ce92db6f399606d2e40a3c631ba566127e8cd637ebbf35b822672139cab2", + "size_in_bytes": 2694 + }, + { + "_path": "Lib/lib2to3/fixes/fix_xreadlines.py", + "path_type": "hardlink", + "sha256": "e8c2f19f7047bfc7539fd78839929004d8fe0efba1fbcbd9d712d285e43834ba", + "size_in_bytes": 689 + }, + { + "_path": "Lib/lib2to3/fixes/fix_zip.py", + "path_type": "hardlink", + "sha256": "55ce115556c7513dd967364dc6a40c39210c874e8168cf090ddd6dc606df34cb", + "size_in_bytes": 1289 + }, + { + "_path": "Lib/lib2to3/main.py", + "path_type": "hardlink", + "sha256": "8f5dfa77b8c8b375daba8bb88aaa195395674311e2513b29575a70821e3aa0b8", + "size_in_bytes": 11854 + }, + { + "_path": "Lib/lib2to3/patcomp.py", + "path_type": "hardlink", + "sha256": "a033a3eb91a39f96747d4300aa3394965e529c71896cd6503dd27e6b685eede5", + "size_in_bytes": 7054 + }, + { + "_path": "Lib/lib2to3/pgen2/__init__.py", + "path_type": "hardlink", + "sha256": "858eb0f50533bd3bd16fe32815f77fabfed92ede885070b6cb15827ec66ea500", + "size_in_bytes": 143 + }, + { + "_path": "Lib/lib2to3/pgen2/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "996e888ddb3be0f4e5a61bdb2c847211cffc98dcc934156382b5aa303ff20bbd", + "size_in_bytes": 172 + }, + { + "_path": "Lib/lib2to3/pgen2/__pycache__/conv.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "03eb5af2db3b49f5b515c5f86d204055be6986ee7238fa890a05dc770fb37e36", + "size_in_bytes": 13229 + }, + { + "_path": "Lib/lib2to3/pgen2/__pycache__/driver.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9adb1b023dafdcf223b255158e8e5a572b99f25adad04e5a1e2a1892dd869064", + "size_in_bytes": 8790 + }, + { + "_path": "Lib/lib2to3/pgen2/__pycache__/grammar.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "456f2a3784e8dd45c12998f5993f86805ce69501f867f0973211203fb2dce7f4", + "size_in_bytes": 7539 + }, + { + "_path": "Lib/lib2to3/pgen2/__pycache__/literals.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "71dd5df99fbe227170598ac43cf21ed20d93db76c5fe551638bc82e457923cf1", + "size_in_bytes": 3058 + }, + { + "_path": "Lib/lib2to3/pgen2/__pycache__/parse.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "53c257cb689849cbe4fcece7474617531e724b3211df5b7b71e9cb3978ca3969", + "size_in_bytes": 9014 + }, + { + "_path": "Lib/lib2to3/pgen2/__pycache__/pgen.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2f786e05976855424bfa4c2dcbc542236f4f536db1448d10fb3ecdaaa2a8673a", + "size_in_bytes": 20237 + }, + { + "_path": "Lib/lib2to3/pgen2/__pycache__/token.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "37c8114fc33af823a9f252e6c8dc5b812d173337e96cb029fec07f963a25c1aa", + "size_in_bytes": 2347 + }, + { + "_path": "Lib/lib2to3/pgen2/__pycache__/tokenize.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a0f9d047c0d00c97596a1440859765a56797026fb434a38e22dff9f05b9b9321", + "size_in_bytes": 24131 + }, + { + "_path": "Lib/lib2to3/pgen2/conv.py", + "path_type": "hardlink", + "sha256": "e2946a686c12e02248fafb1a57e7514e0c22bdb2b4a66e644215c86fedc37bff", + "size_in_bytes": 9642 + }, + { + "_path": "Lib/lib2to3/pgen2/driver.py", + "path_type": "hardlink", + "sha256": "57af5e220cd6c6b75e8dead2cea395ead2297dd98e398ad705ca2bce0e9e6594", + "size_in_bytes": 5969 + }, + { + "_path": "Lib/lib2to3/pgen2/grammar.py", + "path_type": "hardlink", + "sha256": "4898d446d6ae73f7259a3f91839eca1a3380670a9f378b80780707f714fad17c", + "size_in_bytes": 5552 + }, + { + "_path": "Lib/lib2to3/pgen2/literals.py", + "path_type": "hardlink", + "sha256": "84bc9d5387a2e20fab844e530358571afa39fa3fc0e8024270b5f7d8ac5a595a", + "size_in_bytes": 1635 + }, + { + "_path": "Lib/lib2to3/pgen2/parse.py", + "path_type": "hardlink", + "sha256": "e245e005e524ab445a570df31f70c6fd7b901ee3b0b68bd3bcf4b41b37fa7bb6", + "size_in_bytes": 8155 + }, + { + "_path": "Lib/lib2to3/pgen2/pgen.py", + "path_type": "hardlink", + "sha256": "8fe2ac7e0303f0110d75832d746e6661fcd5373fa498d929163f557fd1027434", + "size_in_bytes": 13830 + }, + { + "_path": "Lib/lib2to3/pgen2/token.py", + "path_type": "hardlink", + "sha256": "47c7f968e1e3bf66d53fb4a6a9fc848cdae11d66d49bb70c7cf41961ea91f30c", + "size_in_bytes": 1302 + }, + { + "_path": "Lib/lib2to3/pgen2/tokenize.py", + "path_type": "hardlink", + "sha256": "aaa0b98f6a65e08e9f8e34358198e329d29554a0d4b5f5059924a252eeb0f5c4", + "size_in_bytes": 21119 + }, + { + "_path": "Lib/lib2to3/pygram.py", + "path_type": "hardlink", + "sha256": "b49d77876a9d1822ff6be04daf464341a8e4c0c3414240abf519254de2a97a48", + "size_in_bytes": 1305 + }, + { + "_path": "Lib/lib2to3/pytree.py", + "path_type": "hardlink", + "sha256": "e53689352fb4fc83d85a09369650389ee01db802ad872a8abfc0bf6603ec38b9", + "size_in_bytes": 27974 + }, + { + "_path": "Lib/lib2to3/refactor.py", + "path_type": "hardlink", + "sha256": "6e9a4262fb65cd4d277f009df73ffa5748f5fe3b963d3c5395c160d5f88b089b", + "size_in_bytes": 27507 + }, + { + "_path": "Lib/linecache.py", + "path_type": "hardlink", + "sha256": "c985113d9219c02950916e75090158bccf44cacac09014741b1c59b07968d111", + "size_in_bytes": 5649 + }, + { + "_path": "Lib/locale.py", + "path_type": "hardlink", + "sha256": "ac828df41b2fac93ba3e66a2735216c98c0e1853b8dfb9b859e301fe64153feb", + "size_in_bytes": 79095 + }, + { + "_path": "Lib/logging/__init__.py", + "path_type": "hardlink", + "sha256": "fb2531d0c21738a13eb38093e22c5c7bb651c309dcc79fa444227ce841859c7f", + "size_in_bytes": 80677 + }, + { + "_path": "Lib/logging/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4e4e1a68f254fb11dc3cb91184f81605530bffa14b3a0e45c418339f2f97dfb6", + "size_in_bytes": 98773 + }, + { + "_path": "Lib/logging/__pycache__/config.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "94fea9b9d4ca9fbd73a91b59a1efc3a46cdc384c8599e8b6f541edaf88c06c9e", + "size_in_bytes": 44898 + }, + { + "_path": "Lib/logging/__pycache__/handlers.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "19ffe73231e06b5576ad8d33e281fde9d73487abef226503e9b87df9afe37678", + "size_in_bytes": 70177 + }, + { + "_path": "Lib/logging/config.py", + "path_type": "hardlink", + "sha256": "b83aead25609a9d14beb107005136c0da8c6b930338e861e64bb2bc237bc34fe", + "size_in_bytes": 37001 + }, + { + "_path": "Lib/logging/handlers.py", + "path_type": "hardlink", + "sha256": "2c452d744d1a5e40dc61737223fd7d19c96878505c7b50636fa988addc354afa", + "size_in_bytes": 61920 + }, + { + "_path": "Lib/lzma.py", + "path_type": "hardlink", + "sha256": "58fb9d2fdc8a8af7b25e218f17ea3b51bdfa53bdf40f440ab33c605974ca5c2e", + "size_in_bytes": 13277 + }, + { + "_path": "Lib/mailbox.py", + "path_type": "hardlink", + "sha256": "acfdba74ce626babe25ad0aff9255292f90ffdadd8dd47b40ba526daa29e805b", + "size_in_bytes": 78830 + }, + { + "_path": "Lib/mailcap.py", + "path_type": "hardlink", + "sha256": "b85eccb4567c5c7652b08fe1308fd2337fc5f206d805faad908cb98e35b0eeb8", + "size_in_bytes": 9369 + }, + { + "_path": "Lib/mimetypes.py", + "path_type": "hardlink", + "sha256": "c8604af9340bee72663b73109223e57abc2d5e7511c94ad3e40f6533414734fc", + "size_in_bytes": 22962 + }, + { + "_path": "Lib/modulefinder.py", + "path_type": "hardlink", + "sha256": "e07ab000c3698a7530af2c52955ac8bb7647140d22dca1c30f83443faa191e0f", + "size_in_bytes": 23699 + }, + { + "_path": "Lib/msilib/__init__.py", + "path_type": "hardlink", + "sha256": "d024165f8b2d90e2fb428348b2e9548dea43f3539d4dbf91e752bde5a4510c98", + "size_in_bytes": 17655 + }, + { + "_path": "Lib/msilib/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "dde2506c3b76b402ddd6fb972a34239e15d94c6f5794431ece40c3f7bf2d4bd8", + "size_in_bytes": 27434 + }, + { + "_path": "Lib/msilib/__pycache__/schema.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "91d3f1418441c004bf3ee59b9eef856b520c063f38e8421c4737dde3cfaa164c", + "size_in_bytes": 75101 + }, + { + "_path": "Lib/msilib/__pycache__/sequence.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1955b63978167eeb84302f5075879bb8bbd81864a0d60df7822f8d1f3e7804fd", + "size_in_bytes": 2475 + }, + { + "_path": "Lib/msilib/__pycache__/text.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "63b64b79fe2a9dcaa08e673fd18a26416aa5cc216354358b8c062fc7cd8e48ce", + "size_in_bytes": 8116 + }, + { + "_path": "Lib/msilib/schema.py", + "path_type": "hardlink", + "sha256": "a7d6c1a4699a75bb88a8a012adbb64142dc47adcc31212c3c0e7ae092b4161ae", + "size_in_bytes": 81579 + }, + { + "_path": "Lib/msilib/sequence.py", + "path_type": "hardlink", + "sha256": "a68438bacd41b60c5359b5c5ef32163249f69233292fa94acd53535cb08cd65d", + "size_in_bytes": 3929 + }, + { + "_path": "Lib/msilib/text.py", + "path_type": "hardlink", + "sha256": "fe5bc6023fc58e01e1c80fbe21304ccd6aadd8c384fe6afebed279c3d2925de4", + "size_in_bytes": 9018 + }, + { + "_path": "Lib/multiprocessing/__init__.py", + "path_type": "hardlink", + "sha256": "a5a42976033c7d63ee2740acceef949a3582dcb0e0442845f9717e1be771c68b", + "size_in_bytes": 916 + }, + { + "_path": "Lib/multiprocessing/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4c09b7780d40bf56b647992976f409b5e3eea8e15fd989d225060f05276e3473", + "size_in_bytes": 1093 + }, + { + "_path": "Lib/multiprocessing/__pycache__/connection.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3d64764e82d32059b1dfb85b3725822325d80c1677b8a22bff589600e62f5a49", + "size_in_bytes": 48979 + }, + { + "_path": "Lib/multiprocessing/__pycache__/context.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a9831057d5ac4aa36328f20b191b5d645da587e6c837ed97dc6c0c68bba8056f", + "size_in_bytes": 19537 + }, + { + "_path": "Lib/multiprocessing/__pycache__/forkserver.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d6a635b4bb39c6b16c93b7f91d127cd4339d2e3eed4028ddf37450077b75e580", + "size_in_bytes": 17000 + }, + { + "_path": "Lib/multiprocessing/__pycache__/heap.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "71c59a85d8a40593d7f07f6a583115792a1f4b6edb02ee89d3a8e3da7e0d6f12", + "size_in_bytes": 14665 + }, + { + "_path": "Lib/multiprocessing/__pycache__/managers.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "652428402d3fad40d229a33ec9b0da54459e892fe87cb2c0c898b82970ec1f41", + "size_in_bytes": 73513 + }, + { + "_path": "Lib/multiprocessing/__pycache__/pool.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "92727a468ba006fad8675e2ffa6d7919e3520715fb9d79958df3a94ed7ed314a", + "size_in_bytes": 47350 + }, + { + "_path": "Lib/multiprocessing/__pycache__/popen_fork.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f0b57177d548eba3f6296dcc6ddc0336875f05385d31fbf9e94bedfa22ff8d83", + "size_in_bytes": 4343 + }, + { + "_path": "Lib/multiprocessing/__pycache__/popen_forkserver.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "45b84c72ba4a516e2291cd4ca3f65906f5762013d485002bf072ec30704d57d9", + "size_in_bytes": 4322 + }, + { + "_path": "Lib/multiprocessing/__pycache__/popen_spawn_posix.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8e39ff7f0fb0d08e972415f6521bb571fce3eadafc46dfb0e50ebf839359f8fb", + "size_in_bytes": 4399 + }, + { + "_path": "Lib/multiprocessing/__pycache__/popen_spawn_win32.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "dd0eca9c95f1badc4b56132a61c4af6fb7f3f29d6e8d26a8dd5eeb4e792a646c", + "size_in_bytes": 6604 + }, + { + "_path": "Lib/multiprocessing/__pycache__/process.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5121d1d2c6e2129c489d125fd1272113d28d17938fc6f1c55a1861dcc253f0cc", + "size_in_bytes": 19149 + }, + { + "_path": "Lib/multiprocessing/__pycache__/queues.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1daa7b5df0b7cd759cd7db9055ccc1f7f9d9d64150dd6a6c058f6666fc77f149", + "size_in_bytes": 19983 + }, + { + "_path": "Lib/multiprocessing/__pycache__/reduction.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "fee0de463b7e18824cdad1e4282ad8acc2888a20e72e22816c10bfee4e34c23f", + "size_in_bytes": 14965 + }, + { + "_path": "Lib/multiprocessing/__pycache__/resource_sharer.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ff46a1297e50c46a94041ac8917f858af9201417135466284f2e99ab4fa4bf02", + "size_in_bytes": 9984 + }, + { + "_path": "Lib/multiprocessing/__pycache__/resource_tracker.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "478e5c821b40fc5774c6085e0e2c4875b20b665ca4ec0f33198bfd7be2e962dd", + "size_in_bytes": 12628 + }, + { + "_path": "Lib/multiprocessing/__pycache__/shared_memory.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9148b91834551c60e6c9454698cd4bb559a4990cd383f72742af096c6e2c7a3b", + "size_in_bytes": 24524 + }, + { + "_path": "Lib/multiprocessing/__pycache__/sharedctypes.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b364f990f4a173730c7bb989d889228eca02c3520a616fda6970f8a392564a70", + "size_in_bytes": 12048 + }, + { + "_path": "Lib/multiprocessing/__pycache__/spawn.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c19cdcd3d0b1d56481dd11340888f5ddc4da0f270185620cbfe65b8d5a4779a1", + "size_in_bytes": 12701 + }, + { + "_path": "Lib/multiprocessing/__pycache__/synchronize.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c43b4f9e55b5c9b8a36c66c6f3e7e05ac9e61ef2bdf68057d5acdbbc060a8197", + "size_in_bytes": 22504 + }, + { + "_path": "Lib/multiprocessing/__pycache__/util.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e4a151366e53809cc153db59419f32c1383be09193dcb5fe77989899e9a7ff17", + "size_in_bytes": 20741 + }, + { + "_path": "Lib/multiprocessing/connection.py", + "path_type": "hardlink", + "sha256": "4fd122a7695ffa1429461e3e8f241cbac6361dc9aebf06bc94483545e3bf73d5", + "size_in_bytes": 32395 + }, + { + "_path": "Lib/multiprocessing/context.py", + "path_type": "hardlink", + "sha256": "bd8628d1e140d933d40ed14b51009820c1b0b9b5b6c71971df5fc761da65bd08", + "size_in_bytes": 11597 + }, + { + "_path": "Lib/multiprocessing/dummy/__init__.py", + "path_type": "hardlink", + "sha256": "9127a40ea0ff342cb414383b5e7c594a05be2dd835fe246bd3bb0dc036a32a90", + "size_in_bytes": 3061 + }, + { + "_path": "Lib/multiprocessing/dummy/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "289bab9b74864dc6b0f734ce49290eff967b82c6310185b948adff69402b077a", + "size_in_bytes": 6222 + }, + { + "_path": "Lib/multiprocessing/dummy/__pycache__/connection.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ee93dc91e0d0f421ff2dc32c15d93fce629bd14e3d6bb260e4ffed1aa9d09ecc", + "size_in_bytes": 3957 + }, + { + "_path": "Lib/multiprocessing/dummy/connection.py", + "path_type": "hardlink", + "sha256": "d63dd1979fde9c133efe430ee870e6ba6de43c0a0513866ce3ce475791fe57ab", + "size_in_bytes": 1598 + }, + { + "_path": "Lib/multiprocessing/forkserver.py", + "path_type": "hardlink", + "sha256": "e99f0aa2e4dc41af9d259f220c5eb2632e2ace89b6851e712223bf2682016f29", + "size_in_bytes": 12134 + }, + { + "_path": "Lib/multiprocessing/heap.py", + "path_type": "hardlink", + "sha256": "f6bb79bb99b9ae484935f0d68822e9603a1622dd0b6c4966c79db232a93ba614", + "size_in_bytes": 11626 + }, + { + "_path": "Lib/multiprocessing/managers.py", + "path_type": "hardlink", + "sha256": "7a67d8ccc2805e519917911abb9913a3a9650f8e9623ac98d8ec8a289dba69e2", + "size_in_bytes": 47684 + }, + { + "_path": "Lib/multiprocessing/pool.py", + "path_type": "hardlink", + "sha256": "1539ad7e8aa4b8df03778f1fe5381d928928c5837be7172747bf07c3e6cb4a78", + "size_in_bytes": 32759 + }, + { + "_path": "Lib/multiprocessing/popen_fork.py", + "path_type": "hardlink", + "sha256": "0a09db57e7fab7061c01a61778feea6e2b6bb02ccbc150332f2960b05258ef95", + "size_in_bytes": 2377 + }, + { + "_path": "Lib/multiprocessing/popen_forkserver.py", + "path_type": "hardlink", + "sha256": "0588ad0e5a36718b4377dc2a2a97864a10986c25a33dc3bfed12595711b0cdab", + "size_in_bytes": 2230 + }, + { + "_path": "Lib/multiprocessing/popen_spawn_posix.py", + "path_type": "hardlink", + "sha256": "97b5d25aa479516894489877e6a7921252ee35f51e118c2f1f91f32919e7caa8", + "size_in_bytes": 2029 + }, + { + "_path": "Lib/multiprocessing/popen_spawn_win32.py", + "path_type": "hardlink", + "sha256": "6ef8efd9cd4e99c64a6778f7ad0957e924de9eb4aa167337ed121a2621b1ffaa", + "size_in_bytes": 4515 + }, + { + "_path": "Lib/multiprocessing/process.py", + "path_type": "hardlink", + "sha256": "67f0c2a7a3a83c92dd024705bac18619a2e123c9df77c414beb81035ea4a0e18", + "size_in_bytes": 12139 + }, + { + "_path": "Lib/multiprocessing/queues.py", + "path_type": "hardlink", + "sha256": "c6a5e3d6918de807074142eb4257746093ca78ffd897d828d559b7ea711c71a8", + "size_in_bytes": 12023 + }, + { + "_path": "Lib/multiprocessing/reduction.py", + "path_type": "hardlink", + "sha256": "4999f8b9ae7b3e8a7f5de302612b4131498dc2e238a2c47f894905c1c63294fe", + "size_in_bytes": 9512 + }, + { + "_path": "Lib/multiprocessing/resource_sharer.py", + "path_type": "hardlink", + "sha256": "bba3c7f2b76a9cf4e8ceb642801c405411da95adf91947d81b0043586038290e", + "size_in_bytes": 5145 + }, + { + "_path": "Lib/multiprocessing/resource_tracker.py", + "path_type": "hardlink", + "sha256": "b0099f5e2285fe2462b77c47bbf29220b57c778741a34f386c10c1e9940884c8", + "size_in_bytes": 10332 + }, + { + "_path": "Lib/multiprocessing/shared_memory.py", + "path_type": "hardlink", + "sha256": "51301e70710220e1c494ff5383ac94442a38a4a6622f2eb94e40128c45de1aeb", + "size_in_bytes": 18458 + }, + { + "_path": "Lib/multiprocessing/sharedctypes.py", + "path_type": "hardlink", + "sha256": "77ef522912474652490b7df523112858e51721e63dcf109b8567a35ce9b31b0d", + "size_in_bytes": 6306 + }, + { + "_path": "Lib/multiprocessing/spawn.py", + "path_type": "hardlink", + "sha256": "ebf9fa40eb622384c37690d8c78e7208744df031155ab4ceedab0fc791a1669b", + "size_in_bytes": 9644 + }, + { + "_path": "Lib/multiprocessing/synchronize.py", + "path_type": "hardlink", + "sha256": "9afc08f6d99deb0cefcbe2f0302dadf3942114aa5564afa0b41bc69f54d1ecaf", + "size_in_bytes": 12285 + }, + { + "_path": "Lib/multiprocessing/util.py", + "path_type": "hardlink", + "sha256": "6752c4515ec69f82e9df64e017da490c3754e51d818c270ea1ad2d64e09268be", + "size_in_bytes": 14261 + }, + { + "_path": "Lib/netrc.py", + "path_type": "hardlink", + "sha256": "6394e8e650d04c26ed20b6058d5e93119f544ef1bd00aefb942297d2e2f6c7e1", + "size_in_bytes": 6929 + }, + { + "_path": "Lib/nntplib.py", + "path_type": "hardlink", + "sha256": "6a76a94b951b273aa87335d7c9c4d7273e4c59485c784b057f681443b32d9004", + "size_in_bytes": 41087 + }, + { + "_path": "Lib/ntpath.py", + "path_type": "hardlink", + "sha256": "258e9f1fb694c4f73314fa5bf13ec03db90f1b136549de82b4e12af7a98f38e2", + "size_in_bytes": 28766 + }, + { + "_path": "Lib/nturl2path.py", + "path_type": "hardlink", + "sha256": "980982ba66cc403d17874369d2770e09845b3d49f1d4514e1c52e01518114332", + "size_in_bytes": 2887 + }, + { + "_path": "Lib/numbers.py", + "path_type": "hardlink", + "sha256": "6d70991643a109e9c99e94d6ea2734a995fa8e89114a70ea09737413fa9ae292", + "size_in_bytes": 10348 + }, + { + "_path": "Lib/opcode.py", + "path_type": "hardlink", + "sha256": "e6fc6dc49ced415d6ec285aaf1076148b8c4cb253d3a4d2384a7bab994d394bf", + "size_in_bytes": 10447 + }, + { + "_path": "Lib/operator.py", + "path_type": "hardlink", + "sha256": "b2af20f67667203c1730e686cc5d0427becc94db4c97f1d3efe3ed2158473f6a", + "size_in_bytes": 10965 + }, + { + "_path": "Lib/optparse.py", + "path_type": "hardlink", + "sha256": "07d224301cba312fa0697bff9cd5a4bb4f778a90629632091b3f4ae874d89af5", + "size_in_bytes": 60369 + }, + { + "_path": "Lib/os.py", + "path_type": "hardlink", + "sha256": "8a5d4ac7b87c6c5b31fcb5081f7f7c06f8403a2fdb3eb23692c48933baeb899e", + "size_in_bytes": 39530 + }, + { + "_path": "Lib/pathlib.py", + "path_type": "hardlink", + "sha256": "3b21ac188fd9ac20bacc8ccd976fabd5d8ccf5000f8e157d3dfff005b228fb3d", + "size_in_bytes": 48566 + }, + { + "_path": "Lib/pdb.py", + "path_type": "hardlink", + "sha256": "bb1603e96c17a4c8c3266b0df9fbcca25565d492f0444e968cdba045058e4f03", + "size_in_bytes": 64173 + }, + { + "_path": "Lib/pickle.py", + "path_type": "hardlink", + "sha256": "227b9550b1491f5ed3bf7b444a97f91113d47a3bb0e82fb49da24cbc255d407f", + "size_in_bytes": 65132 + }, + { + "_path": "Lib/pickletools.py", + "path_type": "hardlink", + "sha256": "1d43b5d94c640f5fc7569a0cda0ecb3b08e97cc1ba9c1907ba72bac610903a3e", + "size_in_bytes": 93861 + }, + { + "_path": "Lib/pipes.py", + "path_type": "hardlink", + "sha256": "153f2d249d954b5536c6a049202617ff43ba2f9b109c426e06676c577ddedc61", + "size_in_bytes": 8978 + }, + { + "_path": "Lib/pkgutil.py", + "path_type": "hardlink", + "sha256": "54e8463bc398757aeb01253996c0ef12e2ba8fefdef89dd2e54b15bd70669228", + "size_in_bytes": 24638 + }, + { + "_path": "Lib/platform.py", + "path_type": "hardlink", + "sha256": "1fbf3610ebdd7e981c50459dd188b94a25544ca297086d25b4b5576ab9626a93", + "size_in_bytes": 43792 + }, + { + "_path": "Lib/plistlib.py", + "path_type": "hardlink", + "sha256": "7b25f338cc4a4e600ad25b3c5b7bf54f0714ddc1ae7d5aa5a7bc77ff5f7c38d1", + "size_in_bytes": 28594 + }, + { + "_path": "Lib/poplib.py", + "path_type": "hardlink", + "sha256": "7b341e6adb4e4341b211a221a7224849ea415fc1e39c014b05ae7d9a566819f4", + "size_in_bytes": 15198 + }, + { + "_path": "Lib/posixpath.py", + "path_type": "hardlink", + "sha256": "aa5c97446b9d11a3b6d5a5f949a814243bbda8f2862d70bd9f18ad6961bb001c", + "size_in_bytes": 17072 + }, + { + "_path": "Lib/pprint.py", + "path_type": "hardlink", + "sha256": "3a51d754e876047c9891c29817d979edf4e717801ad283b2cfcf242cc196ad7e", + "size_in_bytes": 24583 + }, + { + "_path": "Lib/profile.py", + "path_type": "hardlink", + "sha256": "4d87bdc8b85bf0a9bdee3e9d975a8a1a0c7360cb264fb68c4c48a102e718e3a3", + "size_in_bytes": 22883 + }, + { + "_path": "Lib/pstats.py", + "path_type": "hardlink", + "sha256": "d62d1e6a626ebd92187419bfe075a76997cce26fe99dd4520786d4a82b6ff10c", + "size_in_bytes": 29356 + }, + { + "_path": "Lib/pty.py", + "path_type": "hardlink", + "sha256": "0b153a3908429ae92056178405f8d44ad204282cbc188ac7ab5ea4bf3c4f65e0", + "size_in_bytes": 6317 + }, + { + "_path": "Lib/py_compile.py", + "path_type": "hardlink", + "sha256": "3464f04938b57a7aafbc5c394ccd4c46823ee607f7fe36b48b91ecbc30ff4e48", + "size_in_bytes": 7837 + }, + { + "_path": "Lib/pyclbr.py", + "path_type": "hardlink", + "sha256": "e8ca09333701ba41244e20b8c2c37b7ed0499b88c4b2ca82cac51ef89ca9e647", + "size_in_bytes": 11396 + }, + { + "_path": "Lib/pydoc.py", + "path_type": "hardlink", + "sha256": "8ec708a846132f72b35184595c1a6498518f3ee63b10fc8244be8f225f582e78", + "size_in_bytes": 112650 + }, + { + "_path": "Lib/pydoc_data/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "Lib/pydoc_data/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5b263b3fea927b31e41135c8118bb8830924e8106db188624a1104a00ffb005c", + "size_in_bytes": 135 + }, + { + "_path": "Lib/pydoc_data/__pycache__/topics.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5018c8a7c54c8f7026dc6da92c1954a3ad11fc809c2ac71fd8da3d54ca90f081", + "size_in_bytes": 483546 + }, + { + "_path": "Lib/pydoc_data/_pydoc.css", + "path_type": "hardlink", + "sha256": "038d4bf51b4d373284640f3658d70eaa856def24d8d02b8e29b289beaabf1cc9", + "size_in_bytes": 1325 + }, + { + "_path": "Lib/pydoc_data/topics.py", + "path_type": "hardlink", + "sha256": "c883c85bcd1ed3544080937358de2097cb0ba99aa44b5d1ca976bebf6030ccba", + "size_in_bytes": 775171 + }, + { + "_path": "Lib/queue.py", + "path_type": "hardlink", + "sha256": "f6c37fc37cd7440979f7d22d40ee818fa3b714c573610c08fa52911d541193f0", + "size_in_bytes": 11496 + }, + { + "_path": "Lib/quopri.py", + "path_type": "hardlink", + "sha256": "7070b61e5a582423a1bb405e3d23cb3e26c4faafcb142a8cbb88ec3f2d6104e9", + "size_in_bytes": 7268 + }, + { + "_path": "Lib/random.py", + "path_type": "hardlink", + "sha256": "b931a2d452db89ab9e1f79d59b66ce194dbd6748049cfe44699726da52b9c956", + "size_in_bytes": 32162 + }, + { + "_path": "Lib/re/__init__.py", + "path_type": "hardlink", + "sha256": "029ead61f362489e9bb034f4c2503abee95462056541e9ad07715de3c353b0da", + "size_in_bytes": 15889 + }, + { + "_path": "Lib/re/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "fa32288ce0737d12618e6f315cac4f184ff676c6a1c5ec94d77306cd8a68a124", + "size_in_bytes": 19298 + }, + { + "_path": "Lib/re/__pycache__/_casefix.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "67cd62a9ca5f0b3c0af8b042a685083480bcfd6b3a3913119a87d4f5d81482ac", + "size_in_bytes": 1830 + }, + { + "_path": "Lib/re/__pycache__/_compiler.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1f41b717ffdce959bf028e6bca29aa41ca1cb262950340e1eb0c994c15800463", + "size_in_bytes": 31851 + }, + { + "_path": "Lib/re/__pycache__/_constants.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3ec931c9a54d7e73a2a2ff4014e788ec12a87a8e88afa80cf9467db8f3a1c994", + "size_in_bytes": 5934 + }, + { + "_path": "Lib/re/__pycache__/_parser.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "869bfe147e111a96cbdeaee59d78eefea4746c7d56033889fbf53126707bddc4", + "size_in_bytes": 50125 + }, + { + "_path": "Lib/re/_casefix.py", + "path_type": "hardlink", + "sha256": "41572ac50cf96b04496e676d8a6708898bb8e752e06dad34ed4c50c5d8f1fe40", + "size_in_bytes": 5446 + }, + { + "_path": "Lib/re/_compiler.py", + "path_type": "hardlink", + "sha256": "c05067f8bfa4c13cbbf1eedc4d5cafc9b621bcb6ebc5771ba0518a18095af15a", + "size_in_bytes": 26089 + }, + { + "_path": "Lib/re/_constants.py", + "path_type": "hardlink", + "sha256": "3e4463dc8ba87c4a3563be46d2d593e82ca9a0fb91768cfe5a07554ed3de82c5", + "size_in_bytes": 5930 + }, + { + "_path": "Lib/re/_parser.py", + "path_type": "hardlink", + "sha256": "4748e39c77d6dc14f81af80e68a62ad99031a8182d5e0b219a6666d0cfb1626f", + "size_in_bytes": 42420 + }, + { + "_path": "Lib/reprlib.py", + "path_type": "hardlink", + "sha256": "264433cc232332db871666b3bb6e4c2cb97b092cb8d5056a45ec2e53daea2b1c", + "size_in_bytes": 5437 + }, + { + "_path": "Lib/rlcompleter.py", + "path_type": "hardlink", + "sha256": "fee9ad9c55529be48329b78e982fbba0201bd218326eaf80a87996c9f8c805bb", + "size_in_bytes": 7827 + }, + { + "_path": "Lib/runpy.py", + "path_type": "hardlink", + "sha256": "f7af4206d8cbb27fce7731174b190edd6569ec3fad060a727d4bfcde69dd965c", + "size_in_bytes": 13159 + }, + { + "_path": "Lib/sched.py", + "path_type": "hardlink", + "sha256": "edfb309483d7cb05e06ad86d1fdeb819629f71402dc6710a1bec36c7afcaac50", + "size_in_bytes": 6351 + }, + { + "_path": "Lib/secrets.py", + "path_type": "hardlink", + "sha256": "86893f2e4d33e8d02f8cc1d1de7a436d395ae9c9d48ff3dc0225a9cca1601759", + "size_in_bytes": 2028 + }, + { + "_path": "Lib/selectors.py", + "path_type": "hardlink", + "sha256": "1eeb102373e18c96311203f30c516e785bd8642275aa0bd66e43a284c9692385", + "size_in_bytes": 19671 + }, + { + "_path": "Lib/shelve.py", + "path_type": "hardlink", + "sha256": "b978c6f0ffa901b041d6518afed03f2938a62168066013ee7d23baac31c356c0", + "size_in_bytes": 8560 + }, + { + "_path": "Lib/shlex.py", + "path_type": "hardlink", + "sha256": "42ab6060f316e121e374e6621d8c1c98b8db323903c3df289a810c45a8ae46a7", + "size_in_bytes": 13501 + }, + { + "_path": "Lib/shutil.py", + "path_type": "hardlink", + "sha256": "aa2c11b95294111edddfeb02f9082ec7c4c21060d87f6857364b5bb95fb94e09", + "size_in_bytes": 56517 + }, + { + "_path": "Lib/signal.py", + "path_type": "hardlink", + "sha256": "0363c964c90ac0b3e515de5749205e6e6454051a1211058375d84d91eab6071a", + "size_in_bytes": 2495 + }, + { + "_path": "Lib/site-packages/README.txt", + "path_type": "hardlink", + "sha256": "cba8fece8f62c36306ba27a128f124a257710e41fc619301ee97be93586917cb", + "size_in_bytes": 119 + }, + { + "_path": "Lib/site.py", + "path_type": "hardlink", + "sha256": "0577e4b379d8ef4aa0ecf88a264ef18c10f72ea72119afae36524d1aae77c9bf", + "size_in_bytes": 22987 + }, + { + "_path": "Lib/smtpd.py", + "path_type": "hardlink", + "sha256": "ef3420607dc3f2d9d7bf5238d1865942036ebb8e37c7c9a3ad8663043565a1da", + "size_in_bytes": 31162 + }, + { + "_path": "Lib/smtplib.py", + "path_type": "hardlink", + "sha256": "b154e27998d0ef0b32fcc665299cdb30883ffe039ede3c4faac3a9db6618d35d", + "size_in_bytes": 45418 + }, + { + "_path": "Lib/sndhdr.py", + "path_type": "hardlink", + "sha256": "d1cb49f6545ef831a69322275ef26f6ca6964953e70d81a8a80fcca8d600ffc0", + "size_in_bytes": 7448 + }, + { + "_path": "Lib/socket.py", + "path_type": "hardlink", + "sha256": "64360e73e3db69396d45d5ee256e8306b3653212ab96ae4a130070488cddbb30", + "size_in_bytes": 37557 + }, + { + "_path": "Lib/socketserver.py", + "path_type": "hardlink", + "sha256": "a1402df8627949d0b72591e742795fcd48f911172610d4e3c2f16bd7dcae8128", + "size_in_bytes": 27586 + }, + { + "_path": "Lib/sqlite3/__init__.py", + "path_type": "hardlink", + "sha256": "29878411a7bcefcd56a3751fe689dea2c99bda75a13a485d78898834a323f0c0", + "size_in_bytes": 2536 + }, + { + "_path": "Lib/sqlite3/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "41d12c9b0b3cbe34f374a14bbd7a7d0e0c56297ccd6045a96eab31aa88e56e60", + "size_in_bytes": 1840 + }, + { + "_path": "Lib/sqlite3/__pycache__/dbapi2.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "67c28281dd0d49ccaf5ab0c2d10de81d3618f58220e953f47733820a95387363", + "size_in_bytes": 4916 + }, + { + "_path": "Lib/sqlite3/__pycache__/dump.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c03c590507620aca60ec74a5f74a3ae9204a83319d15039b37f782678706d69e", + "size_in_bytes": 4352 + }, + { + "_path": "Lib/sqlite3/dbapi2.py", + "path_type": "hardlink", + "sha256": "e49882f895bbbdad7e5af6a9079edffaae9b82bba3fd664281acb607db56c346", + "size_in_bytes": 3305 + }, + { + "_path": "Lib/sqlite3/dump.py", + "path_type": "hardlink", + "sha256": "7b23e13d844d448f6b34fa8b051cec57c9a2c37a94eae96c57b03233b64457d8", + "size_in_bytes": 3471 + }, + { + "_path": "Lib/sre_compile.py", + "path_type": "hardlink", + "sha256": "f7fd87f8ac9dad7d1387e2401761ec05806c5108201a6d1ede6ab2f481f6df54", + "size_in_bytes": 231 + }, + { + "_path": "Lib/sre_constants.py", + "path_type": "hardlink", + "sha256": "87013dc0b349c2c044100f70a8daa9d713e60a527e26f6ab8ee1fc978a6d3234", + "size_in_bytes": 232 + }, + { + "_path": "Lib/sre_parse.py", + "path_type": "hardlink", + "sha256": "c4929134532306081918f185c99305c6f55213bc16b32f8c259bc60f7f81e810", + "size_in_bytes": 229 + }, + { + "_path": "Lib/ssl.py", + "path_type": "hardlink", + "sha256": "5c9b4daa3d54e9941978c75076a6d0c60be3324a7bcda5b54b5fdf33e1d156d6", + "size_in_bytes": 54305 + }, + { + "_path": "Lib/stat.py", + "path_type": "hardlink", + "sha256": "052af0327eae6941b69b05c088b3e748f79995635f80ac4cc7125eb333eb4c77", + "size_in_bytes": 5485 + }, + { + "_path": "Lib/statistics.py", + "path_type": "hardlink", + "sha256": "889a066f1b8063e73387ceb84018efc507a89b365b56c6afb9cc15b2ed25c2d9", + "size_in_bytes": 47705 + }, + { + "_path": "Lib/string.py", + "path_type": "hardlink", + "sha256": "24aeae1f0526250f442022022bf98df9a823b1cb330543ee79e70e44907462e9", + "size_in_bytes": 11786 + }, + { + "_path": "Lib/stringprep.py", + "path_type": "hardlink", + "sha256": "60b6c83581093029312efb6670b11c540090b3f78bcf72264467b494f02f21a5", + "size_in_bytes": 12917 + }, + { + "_path": "Lib/struct.py", + "path_type": "hardlink", + "sha256": "9c231f9497caf513a22dee8f790b07f969b0e45854a0bdd6dd84b492e08c2856", + "size_in_bytes": 257 + }, + { + "_path": "Lib/subprocess.py", + "path_type": "hardlink", + "sha256": "baa9f9138d8d20df6284f67e7d2e790f847f65e2c5370de322d54cccd737f2d9", + "size_in_bytes": 88725 + }, + { + "_path": "Lib/sunau.py", + "path_type": "hardlink", + "sha256": "d1ed39eafff3b238071b2708059afcffa8ca58f2eadfcdc085e7a459c36275ee", + "size_in_bytes": 18480 + }, + { + "_path": "Lib/symtable.py", + "path_type": "hardlink", + "sha256": "ce90d8e945776674b15302527e3d56d053276356cecc373eeb4e558623240b0c", + "size_in_bytes": 10368 + }, + { + "_path": "Lib/sysconfig.py", + "path_type": "hardlink", + "sha256": "89f95941aac4069d0c811acd9042f78ab09cf79797194059d463f1bb3141b97e", + "size_in_bytes": 30395 + }, + { + "_path": "Lib/tabnanny.py", + "path_type": "hardlink", + "sha256": "73bc1829f10634726db7a22f1cb5c06f76802d54cd7edba0ecff145156caa2f8", + "size_in_bytes": 11299 + }, + { + "_path": "Lib/tarfile.py", + "path_type": "hardlink", + "sha256": "8d54813fe9ede7fcef47aff61d26976eac7512a41873d36ac2fa1b610a0fd835", + "size_in_bytes": 111943 + }, + { + "_path": "Lib/telnetlib.py", + "path_type": "hardlink", + "sha256": "1984cebfb50180759ca075b0ea340d3624500dc22fab524a4dbf57c18bb548ca", + "size_in_bytes": 23301 + }, + { + "_path": "Lib/tempfile.py", + "path_type": "hardlink", + "sha256": "ea4b01b1dfd4ab1f3974a98c216879770a4f7db060bf233a48e3a4223487c836", + "size_in_bytes": 31873 + }, + { + "_path": "Lib/test/__init__.py", + "path_type": "hardlink", + "sha256": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9", + "size_in_bytes": 47 + }, + { + "_path": "Lib/test/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "99c3b87c69ce6a682e83dbfe73e73596c0c0fbbbd15c383c5c0f073eb0fb51d9", + "size_in_bytes": 129 + }, + { + "_path": "Lib/test/support/__init__.py", + "path_type": "hardlink", + "sha256": "1aeb789756647c5ef96567632a39f059930313a3adcc3ed211294e1725454014", + "size_in_bytes": 76208 + }, + { + "_path": "Lib/test/support/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d16c0bd6563f4f2ab0d54bfc1d561bed2ed3454857a01629ebaaa5c93fc7b742", + "size_in_bytes": 103072 + }, + { + "_path": "Lib/test/support/__pycache__/bytecode_helper.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "80b8f9a097bb4bcac01943402ee9a2a8b51bd4ca3b3e75d94c70606b46e1c918", + "size_in_bytes": 2619 + }, + { + "_path": "Lib/test/support/__pycache__/hashlib_helper.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b64799d13daa4dfc909bc513f16ada73f8bf96e6972cac3a2302d5a3197c8d4b", + "size_in_bytes": 2808 + }, + { + "_path": "Lib/test/support/__pycache__/import_helper.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "67e2ce0ce47df6b15a98ee6760775d265ad356f317b0c4df1fc1e81bb80bd093", + "size_in_bytes": 15407 + }, + { + "_path": "Lib/test/support/__pycache__/interpreters.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f176988ac2b3d7f2fda0b40faaad01865d62550556d7cfdf9acb9e42a2f04b54", + "size_in_bytes": 10543 + }, + { + "_path": "Lib/test/support/__pycache__/logging_helper.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a12d3a146eedfe01e61e66ace8b6fa8649d2cc77d1a8b83d9c6891d58e1f7ff5", + "size_in_bytes": 1639 + }, + { + "_path": "Lib/test/support/__pycache__/os_helper.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1b0b6cf947bb753cccf2943de0a8ebaa6d5f2cdf743f57ef25b2bf6e67b44b13", + "size_in_bytes": 30265 + }, + { + "_path": "Lib/test/support/__pycache__/pty_helper.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3a5d317b057db97977466bb7136a06b62beb87e63740312b3b8892fe1b3b9cab", + "size_in_bytes": 4294 + }, + { + "_path": "Lib/test/support/__pycache__/script_helper.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ef9162bbc4517c479b5deaa887ccf75b010498dce70405f6f829edf577f9366d", + "size_in_bytes": 14392 + }, + { + "_path": "Lib/test/support/__pycache__/socket_helper.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "dcaf592c895da2435058ac70303eddef39262561c903b7e0cd3cf6e8151ef4d5", + "size_in_bytes": 16979 + }, + { + "_path": "Lib/test/support/__pycache__/threading_helper.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "636e105951179198891924c317516e1106e25b39af9e80f65080811405398fff", + "size_in_bytes": 12317 + }, + { + "_path": "Lib/test/support/__pycache__/warnings_helper.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3a4bb3ec8d34b850a38da9464bc78d4730ab8ae85f35067dc98d1d03799b8bf0", + "size_in_bytes": 11107 + }, + { + "_path": "Lib/test/support/bytecode_helper.py", + "path_type": "hardlink", + "sha256": "8adf3d7f67b83b0eb473e070655421b57627b820e42119886db4345d665b087e", + "size_in_bytes": 1647 + }, + { + "_path": "Lib/test/support/hashlib_helper.py", + "path_type": "hardlink", + "sha256": "19924c427e33c86284ef2a41f76ab6937ab36f12e3d1ef4e617cdbf616a8fc12", + "size_in_bytes": 1907 + }, + { + "_path": "Lib/test/support/import_helper.py", + "path_type": "hardlink", + "sha256": "529d6a1e517d89e4270308d8fdf3a44058f23249e82fc0b305da8844c0bc13a4", + "size_in_bytes": 10082 + }, + { + "_path": "Lib/test/support/interpreters.py", + "path_type": "hardlink", + "sha256": "d77d05cea8a58266c831522ea230300068f0efe734ad07dee4e0cf3cf0e014c4", + "size_in_bytes": 5829 + }, + { + "_path": "Lib/test/support/logging_helper.py", + "path_type": "hardlink", + "sha256": "be1927e654180fcf6d84257be161fe6fa59796774e862c89b6b78adb656738f3", + "size_in_bytes": 916 + }, + { + "_path": "Lib/test/support/os_helper.py", + "path_type": "hardlink", + "sha256": "759d942c6377c91b2197a341a759536005f980d07c187af9f9356146e92fcf13", + "size_in_bytes": 22855 + }, + { + "_path": "Lib/test/support/pty_helper.py", + "path_type": "hardlink", + "sha256": "d724296e344278ce3ffb39962c5761dd04b19e987f8068a09fff02cab7418cc2", + "size_in_bytes": 3052 + }, + { + "_path": "Lib/test/support/script_helper.py", + "path_type": "hardlink", + "sha256": "65a4dc19ffb84e91400a7e3c6e51a58ced9f998270703fb8f9fc96daaa0c5740", + "size_in_bytes": 11719 + }, + { + "_path": "Lib/test/support/socket_helper.py", + "path_type": "hardlink", + "sha256": "bab758812667fffaf509e57d0758640fb91693850d1b413390e878ff5e003f3a", + "size_in_bytes": 13419 + }, + { + "_path": "Lib/test/support/threading_helper.py", + "path_type": "hardlink", + "sha256": "a742cff6379b4f9786e8f0a081c4ab5cbaf8090f9024999447209257c92a8995", + "size_in_bytes": 7882 + }, + { + "_path": "Lib/test/support/warnings_helper.py", + "path_type": "hardlink", + "sha256": "515c10201568a2fcb868d1c34ffe9d7f04e3f617a2cb61d587167359a83b09ec", + "size_in_bytes": 6853 + }, + { + "_path": "Lib/textwrap.py", + "path_type": "hardlink", + "sha256": "62867e40cdea6669b361f72af4d7daf0359f207c92cbeddfc7c7506397c1f31c", + "size_in_bytes": 19718 + }, + { + "_path": "Lib/this.py", + "path_type": "hardlink", + "sha256": "481d0cb3de511eae0b5713dad18542b07eafd9c013bb7690f7497bad49923a71", + "size_in_bytes": 1003 + }, + { + "_path": "Lib/threading.py", + "path_type": "hardlink", + "sha256": "f8b8d9ebd040e1373d76e73c23c683f7c7c204add96bf9d8d9c21ac751cf5252", + "size_in_bytes": 58231 + }, + { + "_path": "Lib/timeit.py", + "path_type": "hardlink", + "sha256": "e6414bbc158ad2007fc17f892ec49cca67cbb6d4f90920f4267ddeb19f032a03", + "size_in_bytes": 13519 + }, + { + "_path": "Lib/tkinter/__init__.py", + "path_type": "hardlink", + "sha256": "ec29262d0002430fa0062ef44e51cff02a2c2f74744b6e6b910471e5e3178dcc", + "size_in_bytes": 172803 + }, + { + "_path": "Lib/tkinter/__main__.py", + "path_type": "hardlink", + "sha256": "9738a6cb9cdd8139721dd82118bd527897db5325d807222883f70fb1c5a1c27e", + "size_in_bytes": 148 + }, + { + "_path": "Lib/tkinter/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "149ca161026b1aa084ca0e738078e2cf62c9626986f974d85ad5f4b611cb377c", + "size_in_bytes": 259337 + }, + { + "_path": "Lib/tkinter/__pycache__/__main__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d81a98d3b46f75205ea75e520445e21328d52742191c4b4981e4d2a73769c673", + "size_in_bytes": 446 + }, + { + "_path": "Lib/tkinter/__pycache__/colorchooser.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0335001cba263804c2f8a68632c27bd16ea8ff6668f0b119d248a65c6207d952", + "size_in_bytes": 3010 + }, + { + "_path": "Lib/tkinter/__pycache__/commondialog.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "648240c0a8c0dc9be96db766364980eb0ab2dec1440792892d1402242da950f2", + "size_in_bytes": 2104 + }, + { + "_path": "Lib/tkinter/__pycache__/constants.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8be13e30055677ff1375eacb789bdd309290ebe510fa4a7aefb23ba99fe52af7", + "size_in_bytes": 1922 + }, + { + "_path": "Lib/tkinter/__pycache__/dialog.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1222fa2a5e63aa93b2e54534c94a07c60060acd27196f2dc9b19b276e3d91de1", + "size_in_bytes": 2343 + }, + { + "_path": "Lib/tkinter/__pycache__/dnd.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4497a5ac72175d484c331b17e9bed81ae8a6b252a2c9a2014e7919369a5726cb", + "size_in_bytes": 16884 + }, + { + "_path": "Lib/tkinter/__pycache__/filedialog.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1cc5944be757c864a995f3ab196f4d357a8f3d5d2a8791a615a4faaf0b842540", + "size_in_bytes": 24703 + }, + { + "_path": "Lib/tkinter/__pycache__/font.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3303ddbb2cda366cc734e15e36149111de7e251ffe7a4af25e28cfb53aba78f2", + "size_in_bytes": 11783 + }, + { + "_path": "Lib/tkinter/__pycache__/messagebox.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0bcfeec06703203893b5c1e704fd6c1c4c9bd7d2fc81787184bda9617d3f4e6f", + "size_in_bytes": 4720 + }, + { + "_path": "Lib/tkinter/__pycache__/scrolledtext.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e1eccb3aa93276e0530910b65ce8c4501267eee795d089a7c2e3a2a9e77f0857", + "size_in_bytes": 3730 + }, + { + "_path": "Lib/tkinter/__pycache__/simpledialog.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "99b84c3d2bf1b0b19747dc70699e4ed886e4bd7f8dfc02da5f43b07edc3cc4cb", + "size_in_bytes": 19427 + }, + { + "_path": "Lib/tkinter/__pycache__/tix.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1d70e94b71ace440d36821a816dd65eebc934b2b9c8e0b9fc463635efe8658d2", + "size_in_bytes": 120021 + }, + { + "_path": "Lib/tkinter/__pycache__/ttk.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6894149fb51b16518902da45b946a096322f6d307e902c5c4cea833dac4ee9a2", + "size_in_bytes": 78791 + }, + { + "_path": "Lib/tkinter/colorchooser.py", + "path_type": "hardlink", + "sha256": "1224241dcfb4ec6aff3cafc66adeb2b2a3759397a28693173915458c50040143", + "size_in_bytes": 2660 + }, + { + "_path": "Lib/tkinter/commondialog.py", + "path_type": "hardlink", + "sha256": "82dd1551f85ace68ac465f54b89c4d71bd21e3c0478d65deb1b5e4e07f5111d6", + "size_in_bytes": 1296 + }, + { + "_path": "Lib/tkinter/constants.py", + "path_type": "hardlink", + "sha256": "c01314dc51d1c8effeba2528720a65da133596d4143200c68595c02067bf1da2", + "size_in_bytes": 1493 + }, + { + "_path": "Lib/tkinter/dialog.py", + "path_type": "hardlink", + "sha256": "4f8201d3ada7b6d0f450b417e55747adaee5f894412c4875169b0736a5ff0faa", + "size_in_bytes": 1535 + }, + { + "_path": "Lib/tkinter/dnd.py", + "path_type": "hardlink", + "sha256": "542b804b243b502b5525a8b1f04a02a120b1db4e3599f5c7865e60693ed3672a", + "size_in_bytes": 11644 + }, + { + "_path": "Lib/tkinter/filedialog.py", + "path_type": "hardlink", + "sha256": "77a7a130572c2f0351f1f0dec0db4e7ac9e71970b74dfcb6c2d93b66da869df6", + "size_in_bytes": 14947 + }, + { + "_path": "Lib/tkinter/font.py", + "path_type": "hardlink", + "sha256": "a73482badacc4a69ff7fae9445793a4d858212fdef103360a478bbfd6ed2f496", + "size_in_bytes": 7000 + }, + { + "_path": "Lib/tkinter/messagebox.py", + "path_type": "hardlink", + "sha256": "cdbf655c66778a19f0e25754a5f198a850c8bd958ce651e8fe4b2b52ad7f9c63", + "size_in_bytes": 3861 + }, + { + "_path": "Lib/tkinter/scrolledtext.py", + "path_type": "hardlink", + "sha256": "c7cc050ec9cc3cc6a47215b5bc79b2d3e5c6ed895a4300ab0e20f6c249385e3f", + "size_in_bytes": 1816 + }, + { + "_path": "Lib/tkinter/simpledialog.py", + "path_type": "hardlink", + "sha256": "63349ae75f9d74a49376f3375e38e5059c9424b918bfd2c67cf45ec70dcf3eac", + "size_in_bytes": 11753 + }, + { + "_path": "Lib/tkinter/test/README", + "path_type": "hardlink", + "sha256": "fe3c79d5da8616ca37f7a9d8fddaac2c9164b593c7b116580aa99690a5f59ab5", + "size_in_bytes": 566 + }, + { + "_path": "Lib/tkinter/test/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "Lib/tkinter/test/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9a56175e619c3d5d1859cd96865f6705dec2faba2ec8b69bf3f30690690611b5", + "size_in_bytes": 137 + }, + { + "_path": "Lib/tkinter/test/__pycache__/support.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0002d0721f137cba2a93fd8a1d79aef05ebb6e307d9d64e49078252b745ee216", + "size_in_bytes": 9005 + }, + { + "_path": "Lib/tkinter/test/__pycache__/widget_tests.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "dfcbba0e8b234b316982586dfee019b113060c89d16ae498fa37a008fb425550", + "size_in_bytes": 36176 + }, + { + "_path": "Lib/tkinter/test/support.py", + "path_type": "hardlink", + "sha256": "be6b77832aeb4ff875c11048e56e59b2f305fe339e09a6f51c75c855f5447885", + "size_in_bytes": 4188 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "fe6bff918b025639e3929adeabe1b6d33d6459840d94ca1fc3c010fe37230340", + "size_in_bytes": 150 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/__pycache__/test_colorchooser.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "85177b37d470cfd02360aa531ab3caa6de946cd6073ffc7a69b9113244717417", + "size_in_bytes": 4674 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/__pycache__/test_font.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "250d5e2daa97cd800c95b842e51e604811d6007f897817c0a90092b940e7bb84", + "size_in_bytes": 12776 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/__pycache__/test_geometry_managers.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e5a961875610100c8e0bcfacdf55024b3a8ff7806d77c7c1adf98a2217cff89b", + "size_in_bytes": 90521 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/__pycache__/test_images.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "dd98c7ba7f215e7ad360dc549e2465fa2ade390f6d19e112fb837cca8f24b3cd", + "size_in_bytes": 36359 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/__pycache__/test_loadtk.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d45620ec4aaa3ba0c0f1d891b9e64da758e50c606cec106638f2bc42be47b32f", + "size_in_bytes": 2898 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/__pycache__/test_messagebox.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5cb06122aa1cc9d38f142bb0bd65844c53514f5f45d969a6faf3c2cf983704fa", + "size_in_bytes": 2446 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/__pycache__/test_misc.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3907065e5862ac2b9ef3e7e6b557b444c662410d64b8470aa7d3266cb176df12", + "size_in_bytes": 60932 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/__pycache__/test_simpledialog.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b5c4b9edfb5c90e2cb913aa65040d2163bf14ceee0b7330859915207ee4f2b19", + "size_in_bytes": 2341 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/__pycache__/test_text.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "321d68ae4e074fcfaf52f893834497edae5918315eb4d055b2578d1ebb7f83f6", + "size_in_bytes": 7025 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/__pycache__/test_variables.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c7f9948629bf135baf7bbe8285a9245dee12c8a835e56bcaed135bb6c44772b5", + "size_in_bytes": 27370 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/__pycache__/test_widgets.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "35f606810aa049c6987cd67156283fb263e41d14983e202f7e55979dfe1b36a6", + "size_in_bytes": 110036 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/test_colorchooser.py", + "path_type": "hardlink", + "sha256": "0813ca40826b08a639ae45b6990d7ad7c4125b062b5df801599eea0e649d2d4d", + "size_in_bytes": 2202 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/test_font.py", + "path_type": "hardlink", + "sha256": "83bc52f81bf3b4059756a7339523c45809675709e311f96bb569c71cc9803b8d", + "size_in_bytes": 5974 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/test_geometry_managers.py", + "path_type": "hardlink", + "sha256": "eae724352399e373a81f57182c12a8d03c05d81a8c41f9bc6fe2f58258354ede", + "size_in_bytes": 40711 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/test_images.py", + "path_type": "hardlink", + "sha256": "3573e3514421a59d359ec9a25bd0203c430b1ea52ac6c54a1069b606e958f9e7", + "size_in_bytes": 16404 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/test_loadtk.py", + "path_type": "hardlink", + "sha256": "a43f90e11f43e7bc7eb918de31dc2cd3f2f0767b151190f023ae47d26479bfe7", + "size_in_bytes": 1486 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/test_messagebox.py", + "path_type": "hardlink", + "sha256": "666707900bfacf01e2de2e8ba0c496e360a8a93c961d9c36ffed7b5922c558ee", + "size_in_bytes": 1125 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/test_misc.py", + "path_type": "hardlink", + "sha256": "0f20a886cdf57b72494458a941e6da3c72f7898f1b27b00eb3af1dc989ab1c8b", + "size_in_bytes": 30752 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/test_simpledialog.py", + "path_type": "hardlink", + "sha256": "7974ad2aa7122794a6ed0006f92b1e63f2a8242c7c202bbf3a39cbbaee447405", + "size_in_bytes": 1009 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/test_text.py", + "path_type": "hardlink", + "sha256": "0cd15898d5b81701c50963fcd51eb821700f29cf4a10ec7ad637e6279598e212", + "size_in_bytes": 4318 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/test_variables.py", + "path_type": "hardlink", + "sha256": "267ee87e14e5e30f904843e06f75915b4814a74077669968124e76ab80c614f9", + "size_in_bytes": 10801 + }, + { + "_path": "Lib/tkinter/test/test_tkinter/test_widgets.py", + "path_type": "hardlink", + "sha256": "85132043e7148a7139c3755e31ee93c20d35a59ef5ea2ded835915a6738cd981", + "size_in_bytes": 59494 + }, + { + "_path": "Lib/tkinter/test/test_ttk/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "Lib/tkinter/test/test_ttk/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8e8ccbdad1f6c796afedb645ec1948ef80da523fd258b6d4df2e3eae1dedbf91", + "size_in_bytes": 146 + }, + { + "_path": "Lib/tkinter/test/test_ttk/__pycache__/test_extensions.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4593c3b724e8f9777b7d7fc3f32f9453f2ad45309c95f4b62bc77c6831182aec", + "size_in_bytes": 21539 + }, + { + "_path": "Lib/tkinter/test/test_ttk/__pycache__/test_style.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "74c2eb2bbbfecb673f8e1e6c5eb27b8aa8ea33bd8b33c39fec82a96d2ffea9ba", + "size_in_bytes": 25316 + }, + { + "_path": "Lib/tkinter/test/test_ttk/__pycache__/test_widgets.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d2152c9c28da02ace9bf9da402cb9b61d62b948cee54301ef34115fbb388b8e5", + "size_in_bytes": 133062 + }, + { + "_path": "Lib/tkinter/test/test_ttk/test_extensions.py", + "path_type": "hardlink", + "sha256": "bf7ade2ab960fc224eee5b58567c2a16025fd1ab1d3e85a697c2c00f50f0ed84", + "size_in_bytes": 11940 + }, + { + "_path": "Lib/tkinter/test/test_ttk/test_style.py", + "path_type": "hardlink", + "sha256": "40512e7b0f4c6400e62dc1399a521e815f015567222c29446caa93a390eb0544", + "size_in_bytes": 14969 + }, + { + "_path": "Lib/tkinter/test/test_ttk/test_widgets.py", + "path_type": "hardlink", + "sha256": "2b18e4d34f7244a438725e54cf6cbaaea041b39bde9c89fae4a558b491605947", + "size_in_bytes": 70170 + }, + { + "_path": "Lib/tkinter/test/widget_tests.py", + "path_type": "hardlink", + "sha256": "59e074d0909ac002beb06caabf80faf661657fcf985d5bc3664bd8f8e4f14573", + "size_in_bytes": 19760 + }, + { + "_path": "Lib/tkinter/tix.py", + "path_type": "hardlink", + "sha256": "5d7a11093a1f6510de786b0e9d67902ab33a57f637cd8f5e2603cf6c5c609a18", + "size_in_bytes": 77032 + }, + { + "_path": "Lib/tkinter/ttk.py", + "path_type": "hardlink", + "sha256": "9e10f6f4434357958dc813ae4d9128d36d51f7bf9193ebc3f1ea049176a8b5ad", + "size_in_bytes": 56242 + }, + { + "_path": "Lib/token.py", + "path_type": "hardlink", + "sha256": "2cabb6a81cafa84b475fc852c20b6bad45955ec0f88063720a831495215f776b", + "size_in_bytes": 2386 + }, + { + "_path": "Lib/tokenize.py", + "path_type": "hardlink", + "sha256": "79aa94ebe1761811ea9b2da2ada409a8cb9abd7c6eac241d0c181a36684bb609", + "size_in_bytes": 26336 + }, + { + "_path": "Lib/tomllib/__init__.py", + "path_type": "hardlink", + "sha256": "71f67036895f4c5acab942618af0cbd3d814451ba61e967f358d0f341a5b8f51", + "size_in_bytes": 308 + }, + { + "_path": "Lib/tomllib/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c84bfb610c6c2c00037c8c8bce20f3c79f710c582bc774c7032dae9318de2df0", + "size_in_bytes": 319 + }, + { + "_path": "Lib/tomllib/__pycache__/_parser.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3c10101fa66831426ae45f2d5f5d5f1ad10fcef20626134d84c1c0aba747eab7", + "size_in_bytes": 30785 + }, + { + "_path": "Lib/tomllib/__pycache__/_re.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "9b34b90b5b87fbf73ee18f815f198830c8d1e2475292cd5f81200a9a16280d01", + "size_in_bytes": 4427 + }, + { + "_path": "Lib/tomllib/__pycache__/_types.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3c5c0ca60d43b1eeb2ed083f43d3b436a053baa49d3e8661301d816f2f8830ba", + "size_in_bytes": 340 + }, + { + "_path": "Lib/tomllib/_parser.py", + "path_type": "hardlink", + "sha256": "4579b04a7566452304781ccce37d3ebc1c36e810b058bdb1f33c0e51ddab0397", + "size_in_bytes": 22631 + }, + { + "_path": "Lib/tomllib/_re.py", + "path_type": "hardlink", + "sha256": "75b8e0e428594f6dca6bdcfd0c73977ddb52a4fc147dd80c5e78fc34ea25cbec", + "size_in_bytes": 2943 + }, + { + "_path": "Lib/tomllib/_types.py", + "path_type": "hardlink", + "sha256": "f864c6d9552a929c7032ace654ee05ef26ca75d21b027b801d77e65907138b74", + "size_in_bytes": 254 + }, + { + "_path": "Lib/trace.py", + "path_type": "hardlink", + "sha256": "dd08f8dc9adfd264e52adaf319be22246e59f2b3a9c2b6fd8cfd62bc915be639", + "size_in_bytes": 29182 + }, + { + "_path": "Lib/traceback.py", + "path_type": "hardlink", + "sha256": "c40d394aad6a3456d6b62385732a7d6272fb3444e9fa388710efefe75070201d", + "size_in_bytes": 40547 + }, + { + "_path": "Lib/tracemalloc.py", + "path_type": "hardlink", + "sha256": "c2cc84a05b824df79840c98729a0e94ef8909b11c528a1b2c5a00aa436b97b25", + "size_in_bytes": 18047 + }, + { + "_path": "Lib/tty.py", + "path_type": "hardlink", + "sha256": "066a541e6d38ead952d63cc32afbac51a33acf354799f235c582eab17488105d", + "size_in_bytes": 879 + }, + { + "_path": "Lib/turtle.py", + "path_type": "hardlink", + "sha256": "787af385d6d4417aac8b686e8d5f49ce4afd7d1d09bde685bb378ed6ecc4fb7d", + "size_in_bytes": 144360 + }, + { + "_path": "Lib/turtledemo/__init__.py", + "path_type": "hardlink", + "sha256": "5f465277c96c107a5af544b0a962561f97cb0bfd75906d9bf9741450ed02b0e1", + "size_in_bytes": 314 + }, + { + "_path": "Lib/turtledemo/__main__.py", + "path_type": "hardlink", + "sha256": "6620f0af34be5e144cf5097f120b3c9e457be5389b8b35c7aae2e88495486aee", + "size_in_bytes": 15285 + }, + { + "_path": "Lib/turtledemo/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "60763b250bfd9058af2530e19fcd158b09436b9057402f06e369fbf0a51960fe", + "size_in_bytes": 467 + }, + { + "_path": "Lib/turtledemo/__pycache__/__main__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "df8ef786000b68b247083c4b77b3fe122d97ee47d214fe82e7c287a826a6b5d0", + "size_in_bytes": 23094 + }, + { + "_path": "Lib/turtledemo/__pycache__/bytedesign.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1a48a678d2ebf0ffe3082a6e17f2112d1c38485e839b6b419847bf8b1f2e4aac", + "size_in_bytes": 9922 + }, + { + "_path": "Lib/turtledemo/__pycache__/chaos.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2074168f1c1934bc7b89119843df591cf5be55df8dc20d8df088c32711331c1f", + "size_in_bytes": 2952 + }, + { + "_path": "Lib/turtledemo/__pycache__/clock.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5cd8a5fd24eb7e1aefe0512f52f30e7e2cb4bc1b538483daf5fddcbd54c5c969", + "size_in_bytes": 7056 + }, + { + "_path": "Lib/turtledemo/__pycache__/colormixer.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "62d99ef0d77c25dbe9b28a7942bd8154eb8c7eea1c582a44c082031ce8da2fd0", + "size_in_bytes": 3895 + }, + { + "_path": "Lib/turtledemo/__pycache__/forest.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2c4f0917213e28c4eccc82c9c9c47565bfb80534cdb16d0eed5bff6c7a28d7ff", + "size_in_bytes": 6161 + }, + { + "_path": "Lib/turtledemo/__pycache__/fractalcurves.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5bc150d7690bbd50724c6671153a2eb77b4ba52df1202cf59e0c69690cea6f0a", + "size_in_bytes": 6916 + }, + { + "_path": "Lib/turtledemo/__pycache__/lindenmayer.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "bf063dcd27d89ba1ddaeb40389c491d4665dd359a3f98166b19c557dfff1b203", + "size_in_bytes": 4444 + }, + { + "_path": "Lib/turtledemo/__pycache__/minimal_hanoi.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "19463bd986682f9e201b33627fb7e53ba2dc40701852c1478e4a8f22d0a14c30", + "size_in_bytes": 4680 + }, + { + "_path": "Lib/turtledemo/__pycache__/nim.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ccdc3eebae9438339920ea82d839a02f64fa38da8b39631ff7f2d74d0d595c60", + "size_in_bytes": 14336 + }, + { + "_path": "Lib/turtledemo/__pycache__/paint.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "beb171aa77df868bffb3ddd3848cc87d07258e575e69d29b1c329dc6dbb3086e", + "size_in_bytes": 2438 + }, + { + "_path": "Lib/turtledemo/__pycache__/peace.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "eaeb6739605932b77ecb619c59ede06769b8e7a6b33f044fa4d35a35d695e3d3", + "size_in_bytes": 2256 + }, + { + "_path": "Lib/turtledemo/__pycache__/penrose.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "07704ace609d03aedd11b31f8dc3082da96c495a93a724d35e00246f39db3ee5", + "size_in_bytes": 9101 + }, + { + "_path": "Lib/turtledemo/__pycache__/planet_and_moon.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b07a985aa6e501345e28b6bce43b0ea9c1c1e5efc52d07d2ffb4d7cbdecbed34", + "size_in_bytes": 7090 + }, + { + "_path": "Lib/turtledemo/__pycache__/rosette.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "fa55b80cff6d515d1301bfbd832f2e7cf4270f6d477108e4aa4517ab7fe17781", + "size_in_bytes": 3332 + }, + { + "_path": "Lib/turtledemo/__pycache__/round_dance.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "cd4db1073fe9defcbfbff8f7b125965d43c9cfbd8dfaade8916a69ecd039a88a", + "size_in_bytes": 3295 + }, + { + "_path": "Lib/turtledemo/__pycache__/sorting_animate.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "78532199ad0d0109d1302a7024fe32be3541bff00c5f87da6118d299a9ebec27", + "size_in_bytes": 12065 + }, + { + "_path": "Lib/turtledemo/__pycache__/tree.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "227dcc9fe14d6208da9745670428cb2e03f63d7e8959924a1c6ada26ea76cd79", + "size_in_bytes": 2912 + }, + { + "_path": "Lib/turtledemo/__pycache__/two_canvases.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "33c50a6ec1fbb77687c013ddba2e307df88e74b6f28067e686ea19ade619ea0b", + "size_in_bytes": 2628 + }, + { + "_path": "Lib/turtledemo/__pycache__/yinyang.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3c75e19616f82cfd80a5609ccce9d4976e27f39c0332c26382746a642e32c730", + "size_in_bytes": 2057 + }, + { + "_path": "Lib/turtledemo/bytedesign.py", + "path_type": "hardlink", + "sha256": "6deeee99e0ddb4ed29a648f95d4d33e9f3292c21dbecec301337c22a605a280f", + "size_in_bytes": 4248 + }, + { + "_path": "Lib/turtledemo/chaos.py", + "path_type": "hardlink", + "sha256": "bc8a3a9b77e90446fb7060ff68ee008ffd6b23b366052207ec225cc163b4dae5", + "size_in_bytes": 951 + }, + { + "_path": "Lib/turtledemo/clock.py", + "path_type": "hardlink", + "sha256": "8728b6e1f7e81e8c9fbc5797588d1766e6be15d353e0f29c38f3e75d28084fcd", + "size_in_bytes": 3180 + }, + { + "_path": "Lib/turtledemo/colormixer.py", + "path_type": "hardlink", + "sha256": "bbb065830edb37fd53b1c004118853176fd8da32ee532cb0d363960880920374", + "size_in_bytes": 1339 + }, + { + "_path": "Lib/turtledemo/forest.py", + "path_type": "hardlink", + "sha256": "68cd81b7da35ca49d9066cc2cba24768cddbf90797dbd619a559cf899cde926b", + "size_in_bytes": 2966 + }, + { + "_path": "Lib/turtledemo/fractalcurves.py", + "path_type": "hardlink", + "sha256": "29fadf34c5eabda4649848d052fa2ed3ae829e55bc3ac5933f2aedf3fb04b320", + "size_in_bytes": 3473 + }, + { + "_path": "Lib/turtledemo/lindenmayer.py", + "path_type": "hardlink", + "sha256": "4b597f52c1cb35ae8ed540d1db2dab52276c7874febd7a659ee50f26be26f61e", + "size_in_bytes": 2434 + }, + { + "_path": "Lib/turtledemo/minimal_hanoi.py", + "path_type": "hardlink", + "sha256": "0e458a6257fb5a4ecd2785962850fa87924b23d4ead8aebb70aab38904ff8ef5", + "size_in_bytes": 2051 + }, + { + "_path": "Lib/turtledemo/nim.py", + "path_type": "hardlink", + "sha256": "939d1ee904a7b00579bb44719b0286e7524bf560c7ffff6d482064b41b09fdb3", + "size_in_bytes": 6513 + }, + { + "_path": "Lib/turtledemo/paint.py", + "path_type": "hardlink", + "sha256": "81aa22d0da1d934cb47edfef1883f9fe8ef864c56d484f79f9ec4b46457d047e", + "size_in_bytes": 1291 + }, + { + "_path": "Lib/turtledemo/peace.py", + "path_type": "hardlink", + "sha256": "b260b857164684b3065ad760fec0245ab6505c220814fb179a3d080f2bba0814", + "size_in_bytes": 1066 + }, + { + "_path": "Lib/turtledemo/penrose.py", + "path_type": "hardlink", + "sha256": "14aeb10db966bfd4ec923a19eb96892eb2aa2723c0962c0824fe2ca9f30e300a", + "size_in_bytes": 3380 + }, + { + "_path": "Lib/turtledemo/planet_and_moon.py", + "path_type": "hardlink", + "sha256": "cd2c5344b67dbe781cf4c7f0f1eb1b97e6d8a5bf50329bdaa4e42e7d390ea609", + "size_in_bytes": 2825 + }, + { + "_path": "Lib/turtledemo/rosette.py", + "path_type": "hardlink", + "sha256": "61dfd5bb932cc5a0c3bb9caa8ed74889a19a8d3ee3cb6707ea8f63595ec350b0", + "size_in_bytes": 1361 + }, + { + "_path": "Lib/turtledemo/round_dance.py", + "path_type": "hardlink", + "sha256": "4ecaac02e68f11ec1a406a6ce8a4b17e4f8af74f76157e0776360d0dd041f276", + "size_in_bytes": 1804 + }, + { + "_path": "Lib/turtledemo/sorting_animate.py", + "path_type": "hardlink", + "sha256": "a82a7608d3620cd8a956d3335bddbc2e30320486645de5d2ec26f481b0a74254", + "size_in_bytes": 5052 + }, + { + "_path": "Lib/turtledemo/tree.py", + "path_type": "hardlink", + "sha256": "3318448046c83c176f95a97c33b5cd82e0076bee038d72810bef3dac1085e590", + "size_in_bytes": 1401 + }, + { + "_path": "Lib/turtledemo/turtle.cfg", + "path_type": "hardlink", + "sha256": "de66698dc4f083792df6aaed1e5d94e879852d72f1f24ac09c8fb4cd144c6c88", + "size_in_bytes": 160 + }, + { + "_path": "Lib/turtledemo/two_canvases.py", + "path_type": "hardlink", + "sha256": "3300593114fb9286af9360cc9d871a40e5dcbea4aedc24b832607d1dd71c7b96", + "size_in_bytes": 1119 + }, + { + "_path": "Lib/turtledemo/yinyang.py", + "path_type": "hardlink", + "sha256": "0737a80b939aafcf3d8a1bf60b63e781979c749337d02b6c216680893f9fffc5", + "size_in_bytes": 821 + }, + { + "_path": "Lib/types.py", + "path_type": "hardlink", + "sha256": "0c08fbb650c37535a7d8361fc12029e3f4c72a418cf564e8779dae14b979e5ba", + "size_in_bytes": 10067 + }, + { + "_path": "Lib/typing.py", + "path_type": "hardlink", + "sha256": "eff3df4f1d65e13d690b8f427cada4dd3b88431dd1e7f319fda1bd0062113203", + "size_in_bytes": 120951 + }, + { + "_path": "Lib/unittest/__init__.py", + "path_type": "hardlink", + "sha256": "2a24d1843801ba82eef666abecfa49768422a8058f442af8666bf71baf68d752", + "size_in_bytes": 3934 + }, + { + "_path": "Lib/unittest/__main__.py", + "path_type": "hardlink", + "sha256": "ff6b9a100d32001715b40d61bc4d613623b139edb1fdc3566427b83c331caae3", + "size_in_bytes": 472 + }, + { + "_path": "Lib/unittest/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "39a871df0f264e6fe3612a5b4968ffd775115d106d3c69e6eea4cfbafa702f4b", + "size_in_bytes": 4214 + }, + { + "_path": "Lib/unittest/__pycache__/__main__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1ea6b7d3146b7ef8c3dabcc77fc98b48a387ce3dd773459ecb70894756eeba04", + "size_in_bytes": 640 + }, + { + "_path": "Lib/unittest/__pycache__/_log.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "fa3f59c34738cef79a24b3868bdc6f6373e65f84ffb34b8d657f1fb09744ab60", + "size_in_bytes": 4793 + }, + { + "_path": "Lib/unittest/__pycache__/async_case.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5b8289759b104c6fbf20a7b60dbd43becbf631f4eb8fb4f43d3dee111d158fab", + "size_in_bytes": 6967 + }, + { + "_path": "Lib/unittest/__pycache__/case.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7940a3c04f2ef3e17c4d2162d1f4f5ea949d5f7c920e5b46ce86a9a16b3bb734", + "size_in_bytes": 79502 + }, + { + "_path": "Lib/unittest/__pycache__/loader.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e92d111bb4151cc3d0c4742b9fb8680c7fd99a6f7535139aee7324af98398d56", + "size_in_bytes": 27376 + }, + { + "_path": "Lib/unittest/__pycache__/main.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "daa63f44bbff45ae5155ce0c374462f22c358befaf9de0885659e27d981dc9d1", + "size_in_bytes": 13782 + }, + { + "_path": "Lib/unittest/__pycache__/mock.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6d89b15da28e9021931d2f324edf943984ec2f3622a9aeba64b8a7bafc51ef01", + "size_in_bytes": 129172 + }, + { + "_path": "Lib/unittest/__pycache__/result.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ed5b174b9278b02e3fe98ecaa1e9158e9c861dc147b3384b84f32e1cd01dde43", + "size_in_bytes": 12950 + }, + { + "_path": "Lib/unittest/__pycache__/runner.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e9ada93f802cf52495a432a426ac096d64dc21d7ecc16c4ae9a48d3a407ce6f4", + "size_in_bytes": 16462 + }, + { + "_path": "Lib/unittest/__pycache__/signals.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "96326064e328e419edccc0c04ee6aecda85c48b119f9f1b1884d0a56934d8b7f", + "size_in_bytes": 3861 + }, + { + "_path": "Lib/unittest/__pycache__/suite.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0070829a793b4658fcda353b3641a665076a12a54682da21e64c0bf04b84c0d4", + "size_in_bytes": 17850 + }, + { + "_path": "Lib/unittest/__pycache__/util.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1e5aff78d834d052ed8a899ac5c7ef4ee67cb8926ee0357570466f45bfa4ee91", + "size_in_bytes": 8356 + }, + { + "_path": "Lib/unittest/_log.py", + "path_type": "hardlink", + "sha256": "905672317ab26c656c600defce25d477728068f597f00a7f94e22e8128c323b9", + "size_in_bytes": 2746 + }, + { + "_path": "Lib/unittest/async_case.py", + "path_type": "hardlink", + "sha256": "b389b976f622c28223105998bf0be011f2b8c48eb33d2f1133e41e562867ee31", + "size_in_bytes": 5465 + }, + { + "_path": "Lib/unittest/case.py", + "path_type": "hardlink", + "sha256": "f062e82d6bcdc231865b62bd3f8fc8847e49211f4884c685ec696216e227b957", + "size_in_bytes": 58503 + }, + { + "_path": "Lib/unittest/loader.py", + "path_type": "hardlink", + "sha256": "44b8d2c7eea54b02dd687d9615fe198cb67af12c832889009bc85cf5cf064d82", + "size_in_bytes": 22536 + }, + { + "_path": "Lib/unittest/main.py", + "path_type": "hardlink", + "sha256": "a05b67e605dfd82e5232735d4093c36496a818ab9e4e7db7190d05cd8405caa9", + "size_in_bytes": 11415 + }, + { + "_path": "Lib/unittest/mock.py", + "path_type": "hardlink", + "sha256": "2576119e5653ca21ab32dd5a1a5f5604deb2b1c7a240e315710ea927bc193749", + "size_in_bytes": 104264 + }, + { + "_path": "Lib/unittest/result.py", + "path_type": "hardlink", + "sha256": "eb3f6ed6a6d339b8113479f6878f1946bf082b8818a89daf85f0b63a5be1f9c1", + "size_in_bytes": 8518 + }, + { + "_path": "Lib/unittest/runner.py", + "path_type": "hardlink", + "sha256": "bc559dd2b01b373929ef342697b1a4c102f10259d96351c3961e9364de5097b8", + "size_in_bytes": 9418 + }, + { + "_path": "Lib/unittest/signals.py", + "path_type": "hardlink", + "sha256": "f8286e818ca56e10e03745bc056cdfd31147678f9a1dc8cb6b0fe96ef9a4362a", + "size_in_bytes": 2403 + }, + { + "_path": "Lib/unittest/suite.py", + "path_type": "hardlink", + "sha256": "ed2da92bc9f97c53403ee2d3d12cc53b16a96e85d596ebc887b5a93458f3f6bc", + "size_in_bytes": 13512 + }, + { + "_path": "Lib/unittest/test/__init__.py", + "path_type": "hardlink", + "sha256": "3ff9d41c8cd1f9708da1432be0abb9346bce8f8d43b06a03be9fbb30c8a87878", + "size_in_bytes": 668 + }, + { + "_path": "Lib/unittest/test/__main__.py", + "path_type": "hardlink", + "sha256": "3add05dcd7dee4190919abe0323334ac96ccf05ea7d8762d68a6ce75f9d3aea5", + "size_in_bytes": 596 + }, + { + "_path": "Lib/unittest/test/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0d32f9e50a725ab772ab243eb20a3b7d199cfe519d55567dcf27c126246edf8d", + "size_in_bytes": 1583 + }, + { + "_path": "Lib/unittest/test/__pycache__/__main__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5f3b3f98f16755dd0b7e1847fdd91c2dfa4c68f790b7b9c7f7ce27c6a410b1ee", + "size_in_bytes": 970 + }, + { + "_path": "Lib/unittest/test/__pycache__/_test_warnings.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7dbef84a8eef44b208d6037833390c7c8aa8bbd801b2fd7dda6719203032af00", + "size_in_bytes": 4165 + }, + { + "_path": "Lib/unittest/test/__pycache__/dummy.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "fc62afe777cb59ee2d4053d2646ccb779a3b1fb19109e8286087fcc7e697da1a", + "size_in_bytes": 135 + }, + { + "_path": "Lib/unittest/test/__pycache__/support.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8535c63d22a1d19fac288322ef722476c139bef87e09112521c85cffb662e452", + "size_in_bytes": 9575 + }, + { + "_path": "Lib/unittest/test/__pycache__/test_assertions.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7960109ab0a2861c68d840f290c74ddaedf8b184dee6894eb32685a32cba0847", + "size_in_bytes": 27750 + }, + { + "_path": "Lib/unittest/test/__pycache__/test_async_case.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "731ffb28ffbe98c90660d85ea6ffe70303aeb7559d40416e7dbf23cfb120802f", + "size_in_bytes": 39136 + }, + { + "_path": "Lib/unittest/test/__pycache__/test_break.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "39d3ed00bc12061097e342fc0e4fd09434d9681931db12e837c66033891ae5d0", + "size_in_bytes": 19528 + }, + { + "_path": "Lib/unittest/test/__pycache__/test_case.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "cf6507ec1f12b29adb9f9cfa48266770cc72e54cf7fa1d7d5125c4ec7c882d94", + "size_in_bytes": 164907 + }, + { + "_path": "Lib/unittest/test/__pycache__/test_discovery.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "73bac1a07581cda734acc85ffae5432d5e2a344fce027bc68feea8e14463a316", + "size_in_bytes": 60491 + }, + { + "_path": "Lib/unittest/test/__pycache__/test_functiontestcase.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2a534ec3f09fe82085f5fef1a6bfcbe0930aaa081262cbc3ea748a14d4f4f055", + "size_in_bytes": 8192 + }, + { + "_path": "Lib/unittest/test/__pycache__/test_loader.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c74ec5fce9eb2af1bdbabf7e93bdc3522e1d1ecfa7ff976c7383e1f1d0a6c30f", + "size_in_bytes": 105461 + }, + { + "_path": "Lib/unittest/test/__pycache__/test_program.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0eb67aec8bef383d13aaa8ce9ca5f5f5f59c50f3e72472fc7d9cb5182fbd178c", + "size_in_bytes": 30499 + }, + { + "_path": "Lib/unittest/test/__pycache__/test_result.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1ab7187b90ffa02e68f0c78ff59fc2540afd85f7cc0998dc38532cdf45b43e88", + "size_in_bytes": 101553 + }, + { + "_path": "Lib/unittest/test/__pycache__/test_runner.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8f66c93b705d0003c7b4936051b7cb06e67209467fb2fd308427a75138985138", + "size_in_bytes": 113255 + }, + { + "_path": "Lib/unittest/test/__pycache__/test_setups.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d198af63d12b06f781ff8222ad61b099d941c96b842dc371a444244b83994210", + "size_in_bytes": 43022 + }, + { + "_path": "Lib/unittest/test/__pycache__/test_skipping.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c3629aa1993dc7b8686b0e0defd3b2a898f20c275153f6012bb8e0886c775465", + "size_in_bytes": 47214 + }, + { + "_path": "Lib/unittest/test/__pycache__/test_suite.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "39247bc70b7b7ca4dabbc189f1cbf3cf8c5b27c717004df300c2dd9826616497", + "size_in_bytes": 29029 + }, + { + "_path": "Lib/unittest/test/_test_warnings.py", + "path_type": "hardlink", + "sha256": "19cad5a18db63d2cf37ccbc75166d186166c32f44f89d898bf47ba5016e6de91", + "size_in_bytes": 2304 + }, + { + "_path": "Lib/unittest/test/dummy.py", + "path_type": "hardlink", + "sha256": "5ec85038c527bd87cc6a9f8842324329097cf599462e886536d13211343c7717", + "size_in_bytes": 50 + }, + { + "_path": "Lib/unittest/test/support.py", + "path_type": "hardlink", + "sha256": "666649ba205681dc9a3e0650a4ab7b8752ca3788115b7e9ba76df89456e827d6", + "size_in_bytes": 3752 + }, + { + "_path": "Lib/unittest/test/test_assertions.py", + "path_type": "hardlink", + "sha256": "a64613077bd6869c8bb9d72adcd91e21adbb928a3f4c465742a44fa626657775", + "size_in_bytes": 17208 + }, + { + "_path": "Lib/unittest/test/test_async_case.py", + "path_type": "hardlink", + "sha256": "78c458bfab0476ccdd7f86b4e2a643418ee7680166a867cbfcd899c0a036cead", + "size_in_bytes": 16740 + }, + { + "_path": "Lib/unittest/test/test_break.py", + "path_type": "hardlink", + "sha256": "749bd0443482d0e04a5ece2dcb6357c63d30310a60a6db86870d7dd13711b779", + "size_in_bytes": 10811 + }, + { + "_path": "Lib/unittest/test/test_case.py", + "path_type": "hardlink", + "sha256": "01fc36432171e303b6503a23569a13907748e3caf1ba0bcf234c43b44381a5bc", + "size_in_bytes": 78261 + }, + { + "_path": "Lib/unittest/test/test_discovery.py", + "path_type": "hardlink", + "sha256": "3e4641b768047d34c678197a9e59d72d06c78820087f122dc9c412eb90f51f2f", + "size_in_bytes": 32851 + }, + { + "_path": "Lib/unittest/test/test_functiontestcase.py", + "path_type": "hardlink", + "sha256": "9b56ece677221688da6d6ae8fc8d666a3cdd20696f5c6d3ad054534f3dea5965", + "size_in_bytes": 5540 + }, + { + "_path": "Lib/unittest/test/test_loader.py", + "path_type": "hardlink", + "sha256": "6c15355ae4e00123d3709fa941c2ca1a6d4889f14bbc2255f3fa62de6efd5d97", + "size_in_bytes": 66133 + }, + { + "_path": "Lib/unittest/test/test_program.py", + "path_type": "hardlink", + "sha256": "81f27cfa4895f9593d1af45b0e83fbcbb7a216802bb145431055b26dba957d2d", + "size_in_bytes": 16727 + }, + { + "_path": "Lib/unittest/test/test_result.py", + "path_type": "hardlink", + "sha256": "19297fea08b73b6dcb5a91d76e34a1ef2b57a4bbcd6798a60baf3876583f954f", + "size_in_bytes": 54171 + }, + { + "_path": "Lib/unittest/test/test_runner.py", + "path_type": "hardlink", + "sha256": "d64219d754c7a1e56d9ffe0533d6559285f9963ac86d44048b9158be625ab2bb", + "size_in_bytes": 50643 + }, + { + "_path": "Lib/unittest/test/test_setups.py", + "path_type": "hardlink", + "sha256": "0bd10fabe5314c160aea7aff21f59a9f5cd272d97327fbf391e096df3dcfc6f4", + "size_in_bytes": 16503 + }, + { + "_path": "Lib/unittest/test/test_skipping.py", + "path_type": "hardlink", + "sha256": "f60057f2360698846050d4eb495f2aa6f91be2ec44690defc28e7a83f7ce116c", + "size_in_bytes": 20080 + }, + { + "_path": "Lib/unittest/test/test_suite.py", + "path_type": "hardlink", + "sha256": "a8a8e4b6a10d6287210bc33113bfb2b739c6cfaea99717690945045e683b3b9b", + "size_in_bytes": 15184 + }, + { + "_path": "Lib/unittest/test/testmock/__init__.py", + "path_type": "hardlink", + "sha256": "d09e5eceb09b486c3f8bda429cc1b1927ef65e568d583b37de53f4f9812771f3", + "size_in_bytes": 465 + }, + { + "_path": "Lib/unittest/test/testmock/__main__.py", + "path_type": "hardlink", + "sha256": "bbbc16cb8b42e626b7562a7a9c8febd810c759f844bbedab2d3425b674da47a0", + "size_in_bytes": 623 + }, + { + "_path": "Lib/unittest/test/testmock/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3e68b21399a445b7979ee98b4ee718db001fa4254222c8b92404c5e5a00913b3", + "size_in_bytes": 1198 + }, + { + "_path": "Lib/unittest/test/testmock/__pycache__/__main__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3e0c43a618757b2771991e6c4c267bb49b58d071c3c5d81abbbcbeaf23b886a1", + "size_in_bytes": 1050 + }, + { + "_path": "Lib/unittest/test/testmock/__pycache__/support.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a24379da2ffa7b96aaecc97026b46c670d73bb9d075b615a7d214925eab12468", + "size_in_bytes": 1031 + }, + { + "_path": "Lib/unittest/test/testmock/__pycache__/testasync.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "389940b9fff3953768a523988c9b3945d1a0d99cef2dc11ef007a1f396819e8e", + "size_in_bytes": 97169 + }, + { + "_path": "Lib/unittest/test/testmock/__pycache__/testcallable.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ba4bf5ca98a4bc4dcc2a1ecd576efbb12705cafaea976c25788557aece10e0f3", + "size_in_bytes": 9850 + }, + { + "_path": "Lib/unittest/test/testmock/__pycache__/testhelpers.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c436de39d22cc8ae035606ea52ac389f9cf5adbc16058a04ee0274539d23f4b0", + "size_in_bytes": 89806 + }, + { + "_path": "Lib/unittest/test/testmock/__pycache__/testmagicmethods.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "38c259d26319d1c2cb4b87d55d7a9923b8cf076c37b509eeaa20d7b16664b612", + "size_in_bytes": 40556 + }, + { + "_path": "Lib/unittest/test/testmock/__pycache__/testmock.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "55334cef821d9c90a3d7b94c4ba322815dea79de66b875799c2c57af5ce16295", + "size_in_bytes": 165714 + }, + { + "_path": "Lib/unittest/test/testmock/__pycache__/testpatch.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e084cb6b5584482691e7aae7cbfab92c39dda931a6130c38dea17ce3dddbabf8", + "size_in_bytes": 140050 + }, + { + "_path": "Lib/unittest/test/testmock/__pycache__/testsealable.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4cbdde042376a654f7b718b5ce38bc7e255ca18112e52868c1db3e7f4a10bfef", + "size_in_bytes": 20667 + }, + { + "_path": "Lib/unittest/test/testmock/__pycache__/testsentinel.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5e5efba80db7ca84446a8178e325a0dd5f50a110df536c91099364b620b1411c", + "size_in_bytes": 3479 + }, + { + "_path": "Lib/unittest/test/testmock/__pycache__/testwith.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c75b0a75b5e80fcd787e4e13e414f90ca3c0e5dca414de42e89c6f51cdef910c", + "size_in_bytes": 29741 + }, + { + "_path": "Lib/unittest/test/testmock/support.py", + "path_type": "hardlink", + "sha256": "cb226f9cd99f7a80db68391bc9e4cbfdc8b7488c4ce2fdf345235fd0d0ffb3bd", + "size_in_bytes": 268 + }, + { + "_path": "Lib/unittest/test/testmock/testasync.py", + "path_type": "hardlink", + "sha256": "7ab9ff20028a24d786d3192ed5ec2aa9492d527d37b31acdb780e65ca4f4b329", + "size_in_bytes": 38149 + }, + { + "_path": "Lib/unittest/test/testmock/testcallable.py", + "path_type": "hardlink", + "sha256": "282f1825ab17973059621d92863eb385a7246d3583bdef5f82e142cff58d7f65", + "size_in_bytes": 4267 + }, + { + "_path": "Lib/unittest/test/testmock/testhelpers.py", + "path_type": "hardlink", + "sha256": "f4b3b9d36f7aa3e32a0ce3cf96118b56c55c8e6e90d2bb28bac59f6de5d639a3", + "size_in_bytes": 34781 + }, + { + "_path": "Lib/unittest/test/testmock/testmagicmethods.py", + "path_type": "hardlink", + "sha256": "2d7dd1368e34002c3050d92b380ebeba2751157500b2fb92c3288e5cc098108b", + "size_in_bytes": 16243 + }, + { + "_path": "Lib/unittest/test/testmock/testmock.py", + "path_type": "hardlink", + "sha256": "7525ac8d3f670c06025377136412a4f4fd2a74dd445905d1819669cfe0e7e271", + "size_in_bytes": 79845 + }, + { + "_path": "Lib/unittest/test/testmock/testpatch.py", + "path_type": "hardlink", + "sha256": "4a99c1890bee1faf656189fc995bceb61f18f75fb0f18469027f891925d9aa1f", + "size_in_bytes": 60220 + }, + { + "_path": "Lib/unittest/test/testmock/testsealable.py", + "path_type": "hardlink", + "sha256": "154919b15d47165081f349415090ea49d9b9509c4c9432ccb183201f0b67c931", + "size_in_bytes": 7369 + }, + { + "_path": "Lib/unittest/test/testmock/testsentinel.py", + "path_type": "hardlink", + "sha256": "34f10ee69edee4a879ff88e15b00b09466e1df3a1bb6080673c215e17e305bb1", + "size_in_bytes": 1325 + }, + { + "_path": "Lib/unittest/test/testmock/testwith.py", + "path_type": "hardlink", + "sha256": "650200acf4306b004506689c8b2a13ae6fc533911dfd4fa137b695a05c67be58", + "size_in_bytes": 12229 + }, + { + "_path": "Lib/unittest/util.py", + "path_type": "hardlink", + "sha256": "fdcc640c3505d16deab9c32eae7c3f5f67c3b5e81c563dc6698fa7fcf403854d", + "size_in_bytes": 5215 + }, + { + "_path": "Lib/urllib/__init__.py", + "path_type": "hardlink", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size_in_bytes": 0 + }, + { + "_path": "Lib/urllib/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ce7d6a499db3ac85b56fd480eff6d83eb569f64a438e4026b10ac8f34ade2820", + "size_in_bytes": 131 + }, + { + "_path": "Lib/urllib/__pycache__/error.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8cdedf64bbbcd4c322750811203f6e75b92cd2b37d4162869de9af513fa38c00", + "size_in_bytes": 3866 + }, + { + "_path": "Lib/urllib/__pycache__/parse.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "30906497a1bb2a38144c91b240a6635c3479e768e7f7ccbbd0bad4fffffd435b", + "size_in_bytes": 55514 + }, + { + "_path": "Lib/urllib/__pycache__/request.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7d89433fcab4f7942f7efd5510b728680244501cbe932f8759f9f2a3bb02bd32", + "size_in_bytes": 126736 + }, + { + "_path": "Lib/urllib/__pycache__/response.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "abf1793ecdbe3f98f3d24aa80f98c279c40ff737d0c5313030e93dd35decd6e7", + "size_in_bytes": 5174 + }, + { + "_path": "Lib/urllib/__pycache__/robotparser.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "239c40ea5315520495594e4e5573b51c3a06527d3c8246b31df932c8f0f6e62e", + "size_in_bytes": 13315 + }, + { + "_path": "Lib/urllib/error.py", + "path_type": "hardlink", + "sha256": "d12b3cc66af3f42a8ebe63e1c91d24f92c6237b6a93a3702938dffabd812d77b", + "size_in_bytes": 2415 + }, + { + "_path": "Lib/urllib/parse.py", + "path_type": "hardlink", + "sha256": "16d609efe91f08901df42c3176a6046e34e97fd39813954871d5a16e89e6b454", + "size_in_bytes": 44836 + }, + { + "_path": "Lib/urllib/request.py", + "path_type": "hardlink", + "sha256": "a9cf43cba43ffd83956d4b14be76869585ac9c0fbf935f8772cfad24dbce4c03", + "size_in_bytes": 101960 + }, + { + "_path": "Lib/urllib/response.py", + "path_type": "hardlink", + "sha256": "7e6c3b6d7a95f0d74f5968f51a87adae8a51bf42390cdfec98c7a99203e7bb76", + "size_in_bytes": 2361 + }, + { + "_path": "Lib/urllib/robotparser.py", + "path_type": "hardlink", + "sha256": "389b811835f9a3ba72b192c3487b0266fa31f6e571b7a83ceb2a34792dc0d9fc", + "size_in_bytes": 9424 + }, + { + "_path": "Lib/uu.py", + "path_type": "hardlink", + "sha256": "dd1f5be33fb25a1b0832891ea07db4a4a2ae41b466e37e24e204604fdc6d18cf", + "size_in_bytes": 7365 + }, + { + "_path": "Lib/uuid.py", + "path_type": "hardlink", + "sha256": "e936b632e7b14cbdad7da077edf59d1de77f5a4c8507a5e7d0028b1d336d9883", + "size_in_bytes": 27597 + }, + { + "_path": "Lib/venv/__init__.py", + "path_type": "hardlink", + "sha256": "8671bc5810ee3e52a5ae7aa3b625764688cf12513b2f8e1b0b82aaec93f118a6", + "size_in_bytes": 26323 + }, + { + "_path": "Lib/venv/__main__.py", + "path_type": "hardlink", + "sha256": "722537c68c0622f8293d39bb6ab1288f3637d8dc45d6f9aae96e49af8145ca36", + "size_in_bytes": 145 + }, + { + "_path": "Lib/venv/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "da551eb05dde4799362ba47fcec92b706bfcc90576858d4339e0ab1c0ef4daaf", + "size_in_bytes": 32765 + }, + { + "_path": "Lib/venv/__pycache__/__main__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "62edc2270d38205d8298a43890cf6abcc788d73d902fefe621a7d8dc4ab72018", + "size_in_bytes": 529 + }, + { + "_path": "Lib/venv/scripts/common/Activate.ps1", + "path_type": "hardlink", + "sha256": "3795a060dea7d621320d6d841deb37591fadf7f5592c5cb2286f9867af0e91df", + "size_in_bytes": 9033 + }, + { + "_path": "Lib/venv/scripts/common/activate", + "path_type": "hardlink", + "sha256": "3fcfc8c48cb6210e2e73d69d0d758c87e5b44d0aba6ad422b458d001bdb8d263", + "size_in_bytes": 1709 + }, + { + "_path": "Lib/venv/scripts/nt/activate.bat", + "path_type": "hardlink", + "sha256": "ac8e386773f56be2821d6200ec3190bcc432ce2e3648ff95acd2f725070bc830", + "size_in_bytes": 1013 + }, + { + "_path": "Lib/venv/scripts/nt/deactivate.bat", + "path_type": "hardlink", + "sha256": "fb53ed45866fee40f01c907c1f67555a399f98361722d89120d05a2580e9e563", + "size_in_bytes": 393 + }, + { + "_path": "Lib/venv/scripts/nt/python.exe", + "path_type": "hardlink", + "sha256": "3044d800eb1676418399cb92ba1be74c7ae17af1b6b66cd8dde42fbf739f8065", + "size_in_bytes": 262144 + }, + { + "_path": "Lib/venv/scripts/nt/pythonw.exe", + "path_type": "hardlink", + "sha256": "5aaa23d602d1a1e8d6e27f5e489160089a56baedd68002d6487721c503d49873", + "size_in_bytes": 249856 + }, + { + "_path": "Lib/venv/scripts/posix/activate.csh", + "path_type": "hardlink", + "sha256": "36f88a305c0ad1c92b46e47ee070f1ea375e7cfd1fdf727081734adc0f6767ba", + "size_in_bytes": 933 + }, + { + "_path": "Lib/venv/scripts/posix/activate.fish", + "path_type": "hardlink", + "sha256": "10c67a991cfe4b0551adef183a73b900d445ed608b979357c3f72e6c890daf64", + "size_in_bytes": 2209 + }, + { + "_path": "Lib/warnings.py", + "path_type": "hardlink", + "sha256": "47328418f0365f0897a2d3789f684dbaba1d5b9c492871f1b72a35b8e2e92021", + "size_in_bytes": 21110 + }, + { + "_path": "Lib/wave.py", + "path_type": "hardlink", + "sha256": "95ba2de5e7be0420fea3e8aef0a9e0261df1f75f9f428e3455509a8f33dbe9f2", + "size_in_bytes": 21818 + }, + { + "_path": "Lib/weakref.py", + "path_type": "hardlink", + "sha256": "56f8d313fb74019e53eb9287400702fbce788b7fe30e097b0b6e06296f3f080c", + "size_in_bytes": 21513 + }, + { + "_path": "Lib/webbrowser.py", + "path_type": "hardlink", + "sha256": "77ec84259b10bf94f05a0c103ccf3d2d3cb8d7c3f5d1b73cfff1514918fac793", + "size_in_bytes": 25136 + }, + { + "_path": "Lib/wsgiref/__init__.py", + "path_type": "hardlink", + "sha256": "c30e144025a63d267778d92f2f066fa592b476e789d888f79b96c059bf0bef60", + "size_in_bytes": 657 + }, + { + "_path": "Lib/wsgiref/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5e59703a978737afcf72963edd2a4bc0dd06959c615a48fdcd3c83414fba6fd3", + "size_in_bytes": 807 + }, + { + "_path": "Lib/wsgiref/__pycache__/handlers.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "80ecdddea7b980a118a4a3e40165d23efac8f4e22abd2e4b746037f2574bc355", + "size_in_bytes": 25194 + }, + { + "_path": "Lib/wsgiref/__pycache__/headers.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "252fa7084268d382cb19ee2436a905468a23c1e1d6d2466771423c9ac82b1347", + "size_in_bytes": 11647 + }, + { + "_path": "Lib/wsgiref/__pycache__/simple_server.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f37c04a21f163df506ba9a54a626afa9006ffcdb6e16439e2c5d81d2576257f4", + "size_in_bytes": 8921 + }, + { + "_path": "Lib/wsgiref/__pycache__/types.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "81a4fddf7dc0d554b8ecb2981a525346b28aa4f7096e89dd7c6fb81961f76039", + "size_in_bytes": 4276 + }, + { + "_path": "Lib/wsgiref/__pycache__/util.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4ddfea8868eed40e822583453d24e6598039303dd05f105e5b013eaa122a6eab", + "size_in_bytes": 7833 + }, + { + "_path": "Lib/wsgiref/__pycache__/validate.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e87d1f165ba7046ab53c6bc830ea4464672a5535612827ab2025e5fef12e7582", + "size_in_bytes": 23044 + }, + { + "_path": "Lib/wsgiref/handlers.py", + "path_type": "hardlink", + "sha256": "e3712e8b8c6069d9ae70aa07801e65cfb15b1f0bf6fbf34afe92123ed9ad8745", + "size_in_bytes": 21550 + }, + { + "_path": "Lib/wsgiref/headers.py", + "path_type": "hardlink", + "sha256": "9e579ab07be58d321f820b481230a10d5ba6dc4db6512c5323051c4870465ca4", + "size_in_bytes": 7370 + }, + { + "_path": "Lib/wsgiref/simple_server.py", + "path_type": "hardlink", + "sha256": "d435cad48b5f63c0356e1ac70755e6e35eb94b02f9844b813e5762199110bc2b", + "size_in_bytes": 5171 + }, + { + "_path": "Lib/wsgiref/types.py", + "path_type": "hardlink", + "sha256": "ba66d30ce511a88eba9b809616c51e12bf89c67972102e7d976b18557f7a6387", + "size_in_bytes": 1717 + }, + { + "_path": "Lib/wsgiref/util.py", + "path_type": "hardlink", + "sha256": "93783cda348368538525f52a5e9a5a43a3de93caec26b6a030ecfb3aedf98b98", + "size_in_bytes": 5472 + }, + { + "_path": "Lib/wsgiref/validate.py", + "path_type": "hardlink", + "sha256": "622c6a2c69db3b10a8c124b5b06fcdf538bfe03f18f31667b78416123b777308", + "size_in_bytes": 15097 + }, + { + "_path": "Lib/xdrlib.py", + "path_type": "hardlink", + "sha256": "b881d9c59e381f0f01f10e911c2f1b483b1abe466d9a985f9acdeac30b0c8d6f", + "size_in_bytes": 5977 + }, + { + "_path": "Lib/xml/__init__.py", + "path_type": "hardlink", + "sha256": "34296f728e7fe68cccb97a9f6edbf3bf3a686f44044c744fe85f207a92ed4811", + "size_in_bytes": 557 + }, + { + "_path": "Lib/xml/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "849b4eb950c36bd60b5e322d01f2d5f416ff1c2f280080bfcfd9e8762751f97d", + "size_in_bytes": 708 + }, + { + "_path": "Lib/xml/dom/NodeFilter.py", + "path_type": "hardlink", + "sha256": "9bfacbbb64e239a75591a7260b3ed86748eeb4366e6c40f3542753e79bace9a7", + "size_in_bytes": 936 + }, + { + "_path": "Lib/xml/dom/__init__.py", + "path_type": "hardlink", + "sha256": "b415a6f3d3663c3ac332ee4a0f4213eadad9281508dc97410e258a03633b063a", + "size_in_bytes": 4019 + }, + { + "_path": "Lib/xml/dom/__pycache__/NodeFilter.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f41035c0dcbdbfaaabded99c0bcd6d8bfac31728f7c9a0b2eeb6479b6b9a432f", + "size_in_bytes": 1131 + }, + { + "_path": "Lib/xml/dom/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e76ffaaaca3646270b2c3f5ae960bc56b02ebbb10fea8a101de2e645dd829d59", + "size_in_bytes": 7115 + }, + { + "_path": "Lib/xml/dom/__pycache__/domreg.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "422da289f8beecc6fe4809f4a719f4c171d248b7b2cb9b46101a050d96d61c2a", + "size_in_bytes": 4226 + }, + { + "_path": "Lib/xml/dom/__pycache__/expatbuilder.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3dca5282a38b0d02d875d81a8c8fa487e428a0d7185bc97aab92e0ad72eed2ec", + "size_in_bytes": 46464 + }, + { + "_path": "Lib/xml/dom/__pycache__/minicompat.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "32370ca43bc9a6c922924b41fb326594fe22b210035ba21885c5ae8c0d275f19", + "size_in_bytes": 3880 + }, + { + "_path": "Lib/xml/dom/__pycache__/minidom.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "497717a411c7a2cb415a2117bdc8101accfb38162a40040cee9ef776e0596ccb", + "size_in_bytes": 95753 + }, + { + "_path": "Lib/xml/dom/__pycache__/pulldom.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1d1757c24940906fc5b1a2803df8794f689ab190da1bfcae9296ebdcf567230f", + "size_in_bytes": 18293 + }, + { + "_path": "Lib/xml/dom/__pycache__/xmlbuilder.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c3bb37bcbb5ef37cd7e1b7e983bc077e1cdb07f98cd15a3c9ff755f4ad2340bf", + "size_in_bytes": 18060 + }, + { + "_path": "Lib/xml/dom/domreg.py", + "path_type": "hardlink", + "sha256": "826b02a803930834b96b1086cbee7db1d21c684f65dd3073706dc7bb5ba1a3e8", + "size_in_bytes": 3451 + }, + { + "_path": "Lib/xml/dom/expatbuilder.py", + "path_type": "hardlink", + "sha256": "40ebc018d1f1d7f16121f2dec0cede039fea8a89bf18862d7ed3489adb934be8", + "size_in_bytes": 35767 + }, + { + "_path": "Lib/xml/dom/minicompat.py", + "path_type": "hardlink", + "sha256": "42974c4c67803dfe80b016ff8aeea0d1e5c751703ab3aec5be765f4e534367be", + "size_in_bytes": 3367 + }, + { + "_path": "Lib/xml/dom/minidom.py", + "path_type": "hardlink", + "sha256": "ceb557c3bc32e2a734d947dffb2452676cfb2f6d83d6b490b9e2d9f700f45d33", + "size_in_bytes": 67982 + }, + { + "_path": "Lib/xml/dom/pulldom.py", + "path_type": "hardlink", + "sha256": "614b88673d496a360e6b10efe8d733c7c0826fb214470ff12f24a1e597699870", + "size_in_bytes": 11637 + }, + { + "_path": "Lib/xml/dom/xmlbuilder.py", + "path_type": "hardlink", + "sha256": "d4f33a8f018755626b64557953a91c6bba21ff613da46f7558a2874aa5d08ebf", + "size_in_bytes": 12387 + }, + { + "_path": "Lib/xml/etree/ElementInclude.py", + "path_type": "hardlink", + "sha256": "97b513db52e9d8382d446e283583e3adf20aae86fb93d4764565ac08250399c0", + "size_in_bytes": 6882 + }, + { + "_path": "Lib/xml/etree/ElementPath.py", + "path_type": "hardlink", + "sha256": "ae8a80a8b51567b4f0965481682705e70c73dd6bfa145283f630d6833f1b4975", + "size_in_bytes": 13997 + }, + { + "_path": "Lib/xml/etree/ElementTree.py", + "path_type": "hardlink", + "sha256": "86c7890d6903d9fe37687633617afac35fc53b0d6bab4ee0a334ea3ffd0c31c4", + "size_in_bytes": 74399 + }, + { + "_path": "Lib/xml/etree/__init__.py", + "path_type": "hardlink", + "sha256": "91950edfb196c105d93886f8af7ea3c0a79e06a6b63be3e5a4ea09804e8672a6", + "size_in_bytes": 1605 + }, + { + "_path": "Lib/xml/etree/__pycache__/ElementInclude.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "516945b2afaf7cc4b6876b0c5cec5fcf1e534dc871276be11e18d3b5530c7c13", + "size_in_bytes": 4604 + }, + { + "_path": "Lib/xml/etree/__pycache__/ElementPath.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b69a74e5da829d19726ed7e05ff7718e808d2f6446a0c0038280dda7e7a394ad", + "size_in_bytes": 17215 + }, + { + "_path": "Lib/xml/etree/__pycache__/ElementTree.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f490056f48fd840157a09fbdbb7425baa4b3904f08a0a3c88ddd336007a2cde3", + "size_in_bytes": 90534 + }, + { + "_path": "Lib/xml/etree/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "800637acd9bc63a91cb4cdf8ed3a75da3d160bdfbb43756b4918a7dcad442dc7", + "size_in_bytes": 134 + }, + { + "_path": "Lib/xml/etree/__pycache__/cElementTree.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "fc7c10d8aa9884a10ddc539bfdd1691e7a5571f61e8f59e94e98da19bd6159be", + "size_in_bytes": 186 + }, + { + "_path": "Lib/xml/etree/cElementTree.py", + "path_type": "hardlink", + "sha256": "d0f57acab07fe4f9c116c3392d85946bac8e78608f409cea70005f16ea019b57", + "size_in_bytes": 82 + }, + { + "_path": "Lib/xml/parsers/__init__.py", + "path_type": "hardlink", + "sha256": "b88497adc30d5d5eda7789c25a2206ee9270c932d584d7ac42680325651da45c", + "size_in_bytes": 167 + }, + { + "_path": "Lib/xml/parsers/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ef039ffca143482d5554283a57fd903846bbe06a410dbda7f7705c876fa7a4d1", + "size_in_bytes": 318 + }, + { + "_path": "Lib/xml/parsers/__pycache__/expat.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c4225ab252dc8bf23984039a0fb87f8bd5360b9fa2c67f2b86c831bb1f048d33", + "size_in_bytes": 400 + }, + { + "_path": "Lib/xml/parsers/expat.py", + "path_type": "hardlink", + "sha256": "64e1947747c2874117a7458bba1f07c86620cc0ed9a4a4116d262878e4a2aa09", + "size_in_bytes": 248 + }, + { + "_path": "Lib/xml/sax/__init__.py", + "path_type": "hardlink", + "sha256": "4cf987c524aaa6ca2030a59a13a98ea3eae6cd3051099d1dd462d557e7bc7e77", + "size_in_bytes": 3642 + }, + { + "_path": "Lib/xml/sax/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "67b4c93651c12e81b7b006972e0765484a01c8fe556c858cf60292d1c4161ca7", + "size_in_bytes": 5047 + }, + { + "_path": "Lib/xml/sax/__pycache__/_exceptions.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "dc2cfc4d694404dd00875135d79a05f2ba6c84051234940ba268c73c5daae216", + "size_in_bytes": 6811 + }, + { + "_path": "Lib/xml/sax/__pycache__/expatreader.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a8d3398c713e6e311427edfe584e2ea43809eaef892f7b376af7a8abe6ca2a29", + "size_in_bytes": 22829 + }, + { + "_path": "Lib/xml/sax/__pycache__/handler.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ac2b63b892c02f2a07d57da838ab8cd7f8a3e875e7fa5d26dff4ff529a5056ee", + "size_in_bytes": 15531 + }, + { + "_path": "Lib/xml/sax/__pycache__/saxutils.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "027bdc8a395346a4a3b018274760ec1e9ff2c476f64c905d96b105ab1bf23eaf", + "size_in_bytes": 21559 + }, + { + "_path": "Lib/xml/sax/__pycache__/xmlreader.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0432444f4752eb43f9e619a1931266506b1a49ce401097625cbac488f870d6d3", + "size_in_bytes": 20921 + }, + { + "_path": "Lib/xml/sax/_exceptions.py", + "path_type": "hardlink", + "sha256": "cfa45778e457731e0988d9ceef29cf9eeef916f22d7bd53f4cb08c7a2b8b2ce2", + "size_in_bytes": 4785 + }, + { + "_path": "Lib/xml/sax/expatreader.py", + "path_type": "hardlink", + "sha256": "4ee774e2d0a3efe1cd1a1afdb3778f6a95523c79bc940ddfd40c19592ba7be21", + "size_in_bytes": 16211 + }, + { + "_path": "Lib/xml/sax/handler.py", + "path_type": "hardlink", + "sha256": "64c7aae49f1dd382a7b9012610307bfa1d43a14a5dc09a5c8da30903f6805c3d", + "size_in_bytes": 15617 + }, + { + "_path": "Lib/xml/sax/saxutils.py", + "path_type": "hardlink", + "sha256": "3fe2cdb6386e0c4d42d37c657bbecb78b69c57aedb1610dbd8bf4043944130ab", + "size_in_bytes": 12255 + }, + { + "_path": "Lib/xml/sax/xmlreader.py", + "path_type": "hardlink", + "sha256": "922a6e2995952366b366c13736d715d77fa1868ee453fdabe35043059357768f", + "size_in_bytes": 12684 + }, + { + "_path": "Lib/xmlrpc/__init__.py", + "path_type": "hardlink", + "sha256": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8", + "size_in_bytes": 38 + }, + { + "_path": "Lib/xmlrpc/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d7b0b838d7548cce4cae02a3d7b6110dafd41194016e2f47cd49cd805a093455", + "size_in_bytes": 131 + }, + { + "_path": "Lib/xmlrpc/__pycache__/client.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "34f8ba47526de8990eb9dff931d4f543cb5df2cc9b39cf54f170502a645093f7", + "size_in_bytes": 56933 + }, + { + "_path": "Lib/xmlrpc/__pycache__/server.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e6939f45591d6e03610d5403d1d77c824e18b2591b1d3cdfc12123b08b7fc0df", + "size_in_bytes": 46909 + }, + { + "_path": "Lib/xmlrpc/client.py", + "path_type": "hardlink", + "sha256": "2e6d11a76a1d1f360655e251466ec192843a6bdac1e97bd88dcd358b3045adcd", + "size_in_bytes": 49391 + }, + { + "_path": "Lib/xmlrpc/server.py", + "path_type": "hardlink", + "sha256": "607bd06518658f7b3152a4fd1f00f778029ee8640c923bf2df61dbd52fa342b9", + "size_in_bytes": 36867 + }, + { + "_path": "Lib/zipapp.py", + "path_type": "hardlink", + "sha256": "776078e89fd7dadbce41678f8bacd3b493135e6d610911c867489415420de383", + "size_in_bytes": 7535 + }, + { + "_path": "Lib/zipfile.py", + "path_type": "hardlink", + "sha256": "8c6c3a7bea4909a66f6014a38a405a1103f0a5ebb14f8a4fa0433b72f99bf49b", + "size_in_bytes": 94447 + }, + { + "_path": "Lib/zipimport.py", + "path_type": "hardlink", + "sha256": "e84b98dd13d3a8ae3ff2094ef2889dcead41d754f0531686f0b70b8d225676cc", + "size_in_bytes": 30897 + }, + { + "_path": "Lib/zoneinfo/__init__.py", + "path_type": "hardlink", + "sha256": "ac7fb403e4371d07482ef2fda81dbcf6879484e9fc41d4be42c156d7e54c68a8", + "size_in_bytes": 703 + }, + { + "_path": "Lib/zoneinfo/__pycache__/__init__.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0448c9ab89539193aa1c75bfe90b3762ccdbf7c0e2aa2b90f38c982c5ba67ff0", + "size_in_bytes": 1209 + }, + { + "_path": "Lib/zoneinfo/__pycache__/_common.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e7a05678d6132f0ac90b813c0071a1c002a37753aa4a50c9cfb967554b598383", + "size_in_bytes": 5886 + }, + { + "_path": "Lib/zoneinfo/__pycache__/_tzpath.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "315442783f6e66add774366b9fe815dca6e7d9d0c18bdc4dc776d6836098da3c", + "size_in_bytes": 7836 + }, + { + "_path": "Lib/zoneinfo/__pycache__/_zoneinfo.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4bc916e40e0f1250390454fbb4e93b4e5f153179c6ce1d6c605838cb327d0371", + "size_in_bytes": 29000 + }, + { + "_path": "Lib/zoneinfo/_common.py", + "path_type": "hardlink", + "sha256": "67deaf0ba41aa4865e007297677207485a89b75629eea0ee5c472be8a3e83bf6", + "size_in_bytes": 5294 + }, + { + "_path": "Lib/zoneinfo/_tzpath.py", + "path_type": "hardlink", + "sha256": "90326cdd057e1161f1049c6c4a8b486d8ade35371c44fc3fb42dd13f2bedd6b6", + "size_in_bytes": 5096 + }, + { + "_path": "Lib/zoneinfo/_zoneinfo.py", + "path_type": "hardlink", + "sha256": "ebb9b679519a23252eb90541003a2fdbb3f2d7bc36713fd70672baa575dcdcb6", + "size_in_bytes": 24674 + }, + { + "_path": "Scripts/2to3-script.py", + "path_type": "hardlink", + "sha256": "cd4c36af54383d8c7103721fb491e5b0a5f5d7c71b85456d6a894bd61f1eb092", + "size_in_bytes": 74 + }, + { + "_path": "Scripts/2to3.exe", + "path_type": "hardlink", + "sha256": "f24d102084620e54fe68d07f6e9169118b283f8d33d0c8f4b974c2e05a306059", + "size_in_bytes": 54032 + }, + { + "_path": "Scripts/idle-script.py", + "path_type": "hardlink", + "sha256": "d43ef2f45ffd2551b678003ade97d9b4a17413c322935571c006d2871d96e8f6", + "size_in_bytes": 72 + }, + { + "_path": "Scripts/idle.exe", + "path_type": "hardlink", + "sha256": "f24d102084620e54fe68d07f6e9169118b283f8d33d0c8f4b974c2e05a306059", + "size_in_bytes": 54032 + }, + { + "_path": "Scripts/pydoc-script.py", + "path_type": "hardlink", + "sha256": "61515cdba67a1834887d8dc57507788ef40253c58c2c8c95596d52a80694ae06", + "size_in_bytes": 57 + }, + { + "_path": "Scripts/pydoc.exe", + "path_type": "hardlink", + "sha256": "f24d102084620e54fe68d07f6e9169118b283f8d33d0c8f4b974c2e05a306059", + "size_in_bytes": 54032 + }, + { + "_path": "Tools/demo/__pycache__/beer.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "bf819fb93e9b21d3cc7211bec91aad62c1e9e1881485e7810ce171e527091d81", + "size_in_bytes": 1184 + }, + { + "_path": "Tools/demo/__pycache__/eiffel.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3db8837caab16fc639f032dc2879fb2066495fddc31bd3eb5d032ef764dacf82", + "size_in_bytes": 8962 + }, + { + "_path": "Tools/demo/__pycache__/hanoi.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ad0644d7d23bc949636042a907183f9900157852ea7d18ac13579f12211cd2cd", + "size_in_bytes": 7010 + }, + { + "_path": "Tools/demo/__pycache__/life.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6369b6d1b5f256a033726a9deb6fd30c20f2e96ee1a9fe4b6f575db348bbb8a3", + "size_in_bytes": 13370 + }, + { + "_path": "Tools/demo/__pycache__/markov.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "af428c60abbb7de86517976bc703bdf4ea4983ac2705ba0110145e402ef7839c", + "size_in_bytes": 6771 + }, + { + "_path": "Tools/demo/__pycache__/mcast.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c4c2f7c96a5bc02704e9a4d1572a33a783dd6014f164af0cbcf12e3aac762892", + "size_in_bytes": 3945 + }, + { + "_path": "Tools/demo/__pycache__/queens.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4ba852f3e24ae691ae5dce2259e35c3961f142b4720bc3e19393abe18ea58462", + "size_in_bytes": 4304 + }, + { + "_path": "Tools/demo/__pycache__/redemo.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "588ba4dca9703e65571863588836612bf0230d84d31092203d5078bfeaffe13e", + "size_in_bytes": 9639 + }, + { + "_path": "Tools/demo/__pycache__/rpython.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "eb5a8d3693eed7a39162b5757c32001d42d92f80d12e70ae687752c5ba01ec07", + "size_in_bytes": 2025 + }, + { + "_path": "Tools/demo/__pycache__/rpythond.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "67345ea1a940127716ed80f2bd93ea4b20f5b5a22229bf8c2293421f4b852168", + "size_in_bytes": 2798 + }, + { + "_path": "Tools/demo/__pycache__/sortvisu.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ba9dd6b54e08c4ae47a41d8b9c2c9e818c11a133851fae4f54265d675988fe86", + "size_in_bytes": 40264 + }, + { + "_path": "Tools/demo/__pycache__/spreadsheet.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "645d4ece95e7406495263b6488610ac996add2fcafb2fe1b11c003b3e8ad70ec", + "size_in_bytes": 46404 + }, + { + "_path": "Tools/demo/__pycache__/vector.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "218ab1879a5ff503dee0b75be82370c06fe78603327f1ce1c0bab97b80ff5041", + "size_in_bytes": 5072 + }, + { + "_path": "Tools/demo/beer.py", + "path_type": "hardlink", + "sha256": "ad664a7ea177192866b365f05528d2f67ee85f52da720ff84776dd082122767e", + "size_in_bytes": 566 + }, + { + "_path": "Tools/demo/eiffel.py", + "path_type": "hardlink", + "sha256": "00a896d378b3749d27cc05322e6dfb6243edf79feec6ca2e0f0f0e23ebf60d62", + "size_in_bytes": 3911 + }, + { + "_path": "Tools/demo/hanoi.py", + "path_type": "hardlink", + "sha256": "b2006267403cd4b97a8d289d343bb82cc34c03bd357f1aefc441135b05c6a41f", + "size_in_bytes": 4611 + }, + { + "_path": "Tools/demo/life.py", + "path_type": "hardlink", + "sha256": "6a5a27e3028d4a5ff7a57d950d98d7ef71052bfb2fb2bd10d7bf648f9f217aa9", + "size_in_bytes": 8987 + }, + { + "_path": "Tools/demo/markov.py", + "path_type": "hardlink", + "sha256": "58f6474aeaec81fd0f15fe0757f0ffc15fcf9a31e102c95931c9d1f2cab2b77b", + "size_in_bytes": 3691 + }, + { + "_path": "Tools/demo/mcast.py", + "path_type": "hardlink", + "sha256": "748f27fbf0678c2624b990c4523c071b3bf8fdc06a1e93dbbaf29c90dd92a210", + "size_in_bytes": 2223 + }, + { + "_path": "Tools/demo/queens.py", + "path_type": "hardlink", + "sha256": "fa92dfad7091c7b9c6cc53db28881613887f046b43b648a8aa33a60d664416ac", + "size_in_bytes": 2270 + }, + { + "_path": "Tools/demo/redemo.py", + "path_type": "hardlink", + "sha256": "ae01f5ba375b31b2e028f4696cb01d32061366e111f9fa3187474f6a9bce09a5", + "size_in_bytes": 5749 + }, + { + "_path": "Tools/demo/rpython.py", + "path_type": "hardlink", + "sha256": "56ef31c650cd1894473f3feb1a06015bddb1b5b8c87ba044776abcc64267d031", + "size_in_bytes": 811 + }, + { + "_path": "Tools/demo/rpythond.py", + "path_type": "hardlink", + "sha256": "56ebd8bf60c1373802f91e5499e4e40d9ae4df1c269db2a49d239edf103d22e4", + "size_in_bytes": 1323 + }, + { + "_path": "Tools/demo/sortvisu.py", + "path_type": "hardlink", + "sha256": "0d18f75930a6940d43bb4921f17a76bb9f60a532f033045f09b8e4e3dd3d4083", + "size_in_bytes": 19987 + }, + { + "_path": "Tools/demo/spreadsheet.py", + "path_type": "hardlink", + "sha256": "e2ce5c8d4c44cc2dbc67453ea1c9ea62e467bb0d2ff46742430b7c6e977cddf0", + "size_in_bytes": 25623 + }, + { + "_path": "Tools/demo/vector.py", + "path_type": "hardlink", + "sha256": "11a3444d9a46232eba288093cbb12e356427b238cf17a7e4304521d543eee607", + "size_in_bytes": 1877 + }, + { + "_path": "Tools/i18n/__pycache__/makelocalealias.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c60b43ceda2481f6524ab5ebebdacd185a063e9bc70ba9cee213777ceb1c1868", + "size_in_bytes": 7430 + }, + { + "_path": "Tools/i18n/__pycache__/msgfmt.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "33a5555999cf162faba041f1af6f49d4ab5f67c36335468445b2b56f4d615035", + "size_in_bytes": 9462 + }, + { + "_path": "Tools/i18n/__pycache__/pygettext.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "990a60da9bb1c050e65ed985b350b5876c09f7cb99efbbf0cd446e1017c93868", + "size_in_bytes": 29970 + }, + { + "_path": "Tools/i18n/makelocalealias.py", + "path_type": "hardlink", + "sha256": "8cfc9a27d3cc32cf3b8a8f58b6d5b18717e6e1786a958312c168b741d485ed9d", + "size_in_bytes": 5029 + }, + { + "_path": "Tools/i18n/msgfmt.py", + "path_type": "hardlink", + "sha256": "79c83d2646e7cf742226b52c989431cea1b08749adbb599fba001bb0203efe1f", + "size_in_bytes": 7592 + }, + { + "_path": "Tools/i18n/pygettext.py", + "path_type": "hardlink", + "sha256": "41504d19c3bd05bd6b274ece89e071857a52f3b1fae2c5d825da36f6f5b5db67", + "size_in_bytes": 24225 + }, + { + "_path": "Tools/scripts/2to3.py", + "path_type": "hardlink", + "sha256": "20033343a6830afdb6824aea0963201af5b42b81ff9ac576826190f3e56437b6", + "size_in_bytes": 96 + }, + { + "_path": "Tools/scripts/__pycache__/2to3.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "fa7d9ee961c60df3f3262900417b19c048ac5c8c4d8a7afe0ee79d487155ecfb", + "size_in_bytes": 306 + }, + { + "_path": "Tools/scripts/__pycache__/abitype.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "649174c764083ee9e06e5ce7adcd3677a58a802da14a180af6060fc01d3a6fb5", + "size_in_bytes": 7351 + }, + { + "_path": "Tools/scripts/__pycache__/analyze_dxp.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4edf372b4822feeb3a6c4aa1b62cf00edc918803d35ebf3cbdecf2a657d678bf", + "size_in_bytes": 6744 + }, + { + "_path": "Tools/scripts/__pycache__/byext.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4be850919b6d9b0fcd869607c5a681ad44b5c5f82826a8b2989fc410192d192f", + "size_in_bytes": 7726 + }, + { + "_path": "Tools/scripts/__pycache__/byteyears.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "90c64352dc609bad2f27270ba94f24cd52d12d11dcd0d79d894fa6c604387990", + "size_in_bytes": 2410 + }, + { + "_path": "Tools/scripts/__pycache__/checkpip.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7dad1a2b7d0c225f28c62919b51a2dd654e6477dc3cb4d0f195bf4723036245a", + "size_in_bytes": 1490 + }, + { + "_path": "Tools/scripts/__pycache__/cleanfuture.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "733b8c3a6ddf054ea6c6a27e31f4921b2e68a714d5631e2f3733f6d1681ac243", + "size_in_bytes": 11407 + }, + { + "_path": "Tools/scripts/__pycache__/combinerefs.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "294577732d9a092c8e5986e8da456032b771b3329e070a970fb4e91c630bfbdc", + "size_in_bytes": 5485 + }, + { + "_path": "Tools/scripts/__pycache__/copytime.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "86f86667897dd63deacf8e104c3ca85412e84c93a3ffeb7960795334a4429465", + "size_in_bytes": 1603 + }, + { + "_path": "Tools/scripts/__pycache__/crlf.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "15ae4f2cf00b97449204018edb3f7abadfbae5f32fe4470e015da19d5821d58d", + "size_in_bytes": 1517 + }, + { + "_path": "Tools/scripts/__pycache__/db2pickle.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8ea89640978e66f48b1cb314ce7bb8c15dfbcac78bd0307f653d4a3931859274", + "size_in_bytes": 5825 + }, + { + "_path": "Tools/scripts/__pycache__/deepfreeze.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "99180f24d773ef8765d8242d417daf4e67812f7c9f0c24fc8f3431f64ac92dba", + "size_in_bytes": 40470 + }, + { + "_path": "Tools/scripts/__pycache__/diff.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a55e64c57fce107a9eade01808de03adb17b0d8f50e0bf116932f69d0016af33", + "size_in_bytes": 3824 + }, + { + "_path": "Tools/scripts/__pycache__/dutree.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "61aa9792e3ae2b066ff059ef0e47b69cf8929f05d4997f2fb9ffdc9ba4419365", + "size_in_bytes": 3550 + }, + { + "_path": "Tools/scripts/__pycache__/eptags.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d4f93a69022868ff7377c378d8ef68054d67ef9caadd5ee7d99c50cb3dbff869", + "size_in_bytes": 2841 + }, + { + "_path": "Tools/scripts/__pycache__/find-uname.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "79c55845148ad4aa415d7c4b961929a61589e729fea894f7d3179647075cd85f", + "size_in_bytes": 2135 + }, + { + "_path": "Tools/scripts/__pycache__/find_recursionlimit.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "ec9bfad360514403a7be402c1e96ebcd73287a7684102098ff8da22e237d6840", + "size_in_bytes": 7213 + }, + { + "_path": "Tools/scripts/__pycache__/finddiv.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3be930f0ba3205df3fa676ec51b56838ff96c9f0a474dee8937464b9c7c217cf", + "size_in_bytes": 4873 + }, + { + "_path": "Tools/scripts/__pycache__/findlinksto.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0cbc4ee8f039add354ce8c04aa31eb0903bf529afef9e3d83385b2076733aaaa", + "size_in_bytes": 2275 + }, + { + "_path": "Tools/scripts/__pycache__/findnocoding.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e9c22aa31aa281cf56e4aaaeabb466c3506f99c2b5bb403f0f1d80c32fd38d92", + "size_in_bytes": 4966 + }, + { + "_path": "Tools/scripts/__pycache__/fixcid.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0ff1b1dd9ff52132151c2cb7685ba3402a9d84840b5adac19ac5b7988f3ab4b0", + "size_in_bytes": 13070 + }, + { + "_path": "Tools/scripts/__pycache__/fixdiv.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c5c0f3c11bdc1f3dbcacaac04ce5796a2f6555bb57633a420596d5bd8b37e59a", + "size_in_bytes": 19421 + }, + { + "_path": "Tools/scripts/__pycache__/fixheader.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e5cc2008113ff9ef1325907f57a8284d43e4d582b0e5656d32a216e02a652a37", + "size_in_bytes": 3095 + }, + { + "_path": "Tools/scripts/__pycache__/fixnotice.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0278f61a39eae16922f6377f0e0b12262bcdc30c574d383b97102137bcbf30a7", + "size_in_bytes": 4986 + }, + { + "_path": "Tools/scripts/__pycache__/fixps.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "13e2b77fd1f391781897eab5871ab349b772a9da14ff0d68f481171cdf2973f0", + "size_in_bytes": 1839 + }, + { + "_path": "Tools/scripts/__pycache__/freeze_modules.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b7192b03f8db726884b9b00e95d5bcfac5a4c6dae286bd06bf8865193da3fca6", + "size_in_bytes": 33050 + }, + { + "_path": "Tools/scripts/__pycache__/generate_global_objects.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "c9f795ee7b89c33c000240f27b0598b9f301f5ac6f21e474e1fcb4b50dfccade", + "size_in_bytes": 8302 + }, + { + "_path": "Tools/scripts/__pycache__/generate_global_objects.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d7546f50ccfd0ea2c4f254851554a06f9f4d17305cf88f21fd3800e085e0879c", + "size_in_bytes": 19022 + }, + { + "_path": "Tools/scripts/__pycache__/generate_opcode_h.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "28b9cbea125a6d2423d98108ba6c6af2f47dc3eade4d7d5e4fac04be99dd5af8", + "size_in_bytes": 8565 + }, + { + "_path": "Tools/scripts/__pycache__/generate_re_casefix.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e5560a60dd377b3ffbd977c5908639561391affc4add006f67e7d57e704b280c", + "size_in_bytes": 6567 + }, + { + "_path": "Tools/scripts/__pycache__/generate_sre_constants.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "86d84579daa22ea34fc5ce537f1dfab0afa519b2d2bb5b4c955bfc6e657a2451", + "size_in_bytes": 4901 + }, + { + "_path": "Tools/scripts/__pycache__/generate_stdlib_module_names.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8bb96d8d555dfc16c09f697c652851375b88346608c47c9b7a138a62017e4cc3", + "size_in_bytes": 7720 + }, + { + "_path": "Tools/scripts/__pycache__/generate_token.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c4816dd601176c8e61b8575bf34eaaadccb4f6d9dcf88e7b53440cb8be19be8f", + "size_in_bytes": 10806 + }, + { + "_path": "Tools/scripts/__pycache__/get-remote-certificate.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "850fe392fe5026b10730f17941924eedac30211514270b87383d43925af041f7", + "size_in_bytes": 3965 + }, + { + "_path": "Tools/scripts/__pycache__/google.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6c7f1988722185cfec0977043cff2b8901ff34caae42093930e2630a2dc6b456", + "size_in_bytes": 1415 + }, + { + "_path": "Tools/scripts/__pycache__/gprof2html.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "73c72a00ee448e97b00b647d663043259fb3469143dc6c937ca2c8669620474a", + "size_in_bytes": 4157 + }, + { + "_path": "Tools/scripts/__pycache__/highlight.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b77c11f175f34e454834904ca7ab87e1742cbbe51af76954bcf30d7d1af6a973", + "size_in_bytes": 12368 + }, + { + "_path": "Tools/scripts/__pycache__/ifdef.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "977236986977aa3b381aaed7fb2f23e31550893b1586c646ad39a564a7aecfa8", + "size_in_bytes": 3755 + }, + { + "_path": "Tools/scripts/__pycache__/import_diagnostics.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "683518152a57f238aa17cc3d3f8e147a68d0a856d482985efb7f2e4bc90acb07", + "size_in_bytes": 2277 + }, + { + "_path": "Tools/scripts/__pycache__/lfcr.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8c318f83f7638d60d40931191072c3f7520b255da3b72f8be4ba6d4ff9da498d", + "size_in_bytes": 1554 + }, + { + "_path": "Tools/scripts/__pycache__/linktree.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "48adf4dd29879c8be7a44aa7df8300ffbaee488395188d603049a6fbbe866afd", + "size_in_bytes": 3925 + }, + { + "_path": "Tools/scripts/__pycache__/lll.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "1c2bb6514242fddde3103ba929dd43f9b0c6cca06e897cbc609e00c7f433e494", + "size_in_bytes": 1384 + }, + { + "_path": "Tools/scripts/__pycache__/mailerdaemon.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3e5a3b1c6c267b4aaccc082694537ac6ead9f3a6dbf1b03d300c404a5ac53a3d", + "size_in_bytes": 11505 + }, + { + "_path": "Tools/scripts/__pycache__/make_ctype.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "2502cb1f0f1522af89daaa68dc0227bce72096afc807ec567f7e54f4333ae403", + "size_in_bytes": 4005 + }, + { + "_path": "Tools/scripts/__pycache__/md5sum.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0fb3100edfc3ea3a1d45be0ca585f5b81611ff44f49c72e1445506ccba83df9b", + "size_in_bytes": 4750 + }, + { + "_path": "Tools/scripts/__pycache__/mkreal.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "4032c9cafafc7697f10e331057d473eef1d4e28e60799b9548d465f9a4ab20bc", + "size_in_bytes": 3559 + }, + { + "_path": "Tools/scripts/__pycache__/ndiff.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "befb106401a04bd2f28e9230ff095bf0892b3d7894eeeb3774589bc94d8ce522", + "size_in_bytes": 5237 + }, + { + "_path": "Tools/scripts/__pycache__/nm2def.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e9606dd8716a0c2f9c55c27e65c645b783c1f91b5e4eecd3451729f608334d44", + "size_in_bytes": 4102 + }, + { + "_path": "Tools/scripts/__pycache__/objgraph.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "25d60323a0f96880cfcbf9da22165496caa90062116ae90180e0c1817941f388", + "size_in_bytes": 8047 + }, + { + "_path": "Tools/scripts/__pycache__/parse_html5_entities.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "3d9ec7b38c197600071e56d10c52e08e3ef3ed52408a0de3e27333538079a423", + "size_in_bytes": 6085 + }, + { + "_path": "Tools/scripts/__pycache__/parseentities.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "99e50bd71222671bae39afa8f5a3be885c4f286b2ca76df7c99dd80eacd50fd9", + "size_in_bytes": 3252 + }, + { + "_path": "Tools/scripts/__pycache__/patchcheck.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b87d367c788c70692e38e78ba4c80c62c6d91e2130a70d391336003904398a0e", + "size_in_bytes": 16969 + }, + { + "_path": "Tools/scripts/__pycache__/pathfix.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "22879d237738cc4156968ca0aed3ae4d08226df1027e8086a2c4d12340f5ec47", + "size_in_bytes": 8991 + }, + { + "_path": "Tools/scripts/__pycache__/pdeps.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "7b45c00e20f81968bd44111ded5938c67ca5231e7ca7d9fa6145599046768a19", + "size_in_bytes": 5275 + }, + { + "_path": "Tools/scripts/__pycache__/pep384_macrocheck.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "aed16185af62ab61020e173a450f1e99a872faa3988826f00f0fdab2d2e07132", + "size_in_bytes": 6962 + }, + { + "_path": "Tools/scripts/__pycache__/pickle2db.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "277b7e92e2f4a21cd9e7638d2c14356d815742a7187c12f8b8cfdd82cd11943a", + "size_in_bytes": 6254 + }, + { + "_path": "Tools/scripts/__pycache__/pindent.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "8018862543317e6b6e9c5a1fe445ae1b7379da6537b99b0d8db142ee7aacde02", + "size_in_bytes": 18094 + }, + { + "_path": "Tools/scripts/__pycache__/ptags.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "47713a2a04d796306c983e1d18236cd872cbe3bb3aeb74c38ee6f0eec5055226", + "size_in_bytes": 2534 + }, + { + "_path": "Tools/scripts/__pycache__/pydoc3.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "752b1bda5e145d3fc7c711127473e519e926eb0654630cf32f4dbf085ee7f58c", + "size_in_bytes": 257 + }, + { + "_path": "Tools/scripts/__pycache__/pysource.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c23e6e7897372bb7bbc52529c2839ff1094546d83ebb8337ccd7f8da4ed6d5cf", + "size_in_bytes": 5725 + }, + { + "_path": "Tools/scripts/__pycache__/reindent-rst.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c61018fc973d63a6944da6dff37f31ac3c94fc084217ab13f6f6ce301a4ef9f0", + "size_in_bytes": 589 + }, + { + "_path": "Tools/scripts/__pycache__/reindent.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "6d6ba929205cc8634399bc486a109235dfa1fb6d15e9b01befa2440751d1686c", + "size_in_bytes": 14988 + }, + { + "_path": "Tools/scripts/__pycache__/rgrep.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "e0f6f71d2461637abb8ac6a6f731c63d0e0ea5a647d9a486c3d96521958c3259", + "size_in_bytes": 3099 + }, + { + "_path": "Tools/scripts/__pycache__/run_tests.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "5565c24d3b2238a799277f07d418be68e9667c280ffe65a37329f6a97a11cf00", + "size_in_bytes": 4961 + }, + { + "_path": "Tools/scripts/__pycache__/smelly.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "f3937689e19184b433004aeaf588935038999ecd291d5dfde3a8cb1f9a673498", + "size_in_bytes": 7286 + }, + { + "_path": "Tools/scripts/__pycache__/sortperf.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "aec1af54c018f5e4b9b15634946eceb6ca48cf4e3988131443de8f728b83487f", + "size_in_bytes": 9139 + }, + { + "_path": "Tools/scripts/__pycache__/stable_abi.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "da349ab054d67317fe83a5e8d4e219830bb6e1c7e4ad670238f2b83b9eddcd15", + "size_in_bytes": 35470 + }, + { + "_path": "Tools/scripts/__pycache__/startuptime.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "72cd1cefa29b4c758e9ac7f9b7b1469403eb0914afb984897907233c99712625", + "size_in_bytes": 1040 + }, + { + "_path": "Tools/scripts/__pycache__/suff.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "0003927bdf553923cf3c0932ec50161d12fb6ab473de24f46089cf86201f7cdf", + "size_in_bytes": 1213 + }, + { + "_path": "Tools/scripts/__pycache__/summarize_stats.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "a54ed465b296211582aa687aed8602d33c637836246d8044bd551d4ba17d20e5", + "size_in_bytes": 23380 + }, + { + "_path": "Tools/scripts/__pycache__/texi2html.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "20f5e43052601949034daa7d5fcaa246b3ee664314380596375338e533994dfc", + "size_in_bytes": 116195 + }, + { + "_path": "Tools/scripts/__pycache__/umarshal.cpython-310.pyc", + "path_type": "hardlink", + "sha256": "98b4210d283ec0e79b5280efa0229f7079336deb2624c1367262886a71b85f48", + "size_in_bytes": 8681 + }, + { + "_path": "Tools/scripts/__pycache__/umarshal.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "15398f4300e18a4be91fc80870092dbc7ae82081eb231b069630204883bab669", + "size_in_bytes": 18478 + }, + { + "_path": "Tools/scripts/__pycache__/untabify.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "b0e3ff29c6308dc29520fba2aa6b0f88bddade3fa00116b048bbb9f5c333707a", + "size_in_bytes": 2895 + }, + { + "_path": "Tools/scripts/__pycache__/update_file.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "55fd546245f92d6e26e04be914f46e3a0a701467ecc819cec5b8d8e7a0b5e52c", + "size_in_bytes": 4773 + }, + { + "_path": "Tools/scripts/__pycache__/var_access_benchmark.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "d7aa35955c8adc4326027804a9476a9e0ccba7d93eabebf18ea932d994151807", + "size_in_bytes": 22401 + }, + { + "_path": "Tools/scripts/__pycache__/verify_ensurepip_wheels.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "64129e98e75ca2953daae86968f7fcba768964ff6ba10f2f397c9b0062dfdba4", + "size_in_bytes": 4741 + }, + { + "_path": "Tools/scripts/__pycache__/which.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "39546f482b8eaf764527746db9608b762e6bf87c1737fff1e1faef3d277735be", + "size_in_bytes": 2691 + }, + { + "_path": "Tools/scripts/__pycache__/win_add2path.cpython-311.pyc", + "path_type": "hardlink", + "sha256": "c1d928ec782a9c349e81839f36f958ffd78ac56884e9bb849dfa31a8552b58e0", + "size_in_bytes": 3461 + }, + { + "_path": "Tools/scripts/abitype.py", + "path_type": "hardlink", + "sha256": "e50b3874ab3d89544b9971a7e21c662acc6566f3fb14ad9e082829c6ad975a3f", + "size_in_bytes": 5572 + }, + { + "_path": "Tools/scripts/analyze_dxp.py", + "path_type": "hardlink", + "sha256": "6b452cd913fe7bd8ab9eb6b00e2c3639161a0ec5337039d7effe50dee278a5da", + "size_in_bytes": 4183 + }, + { + "_path": "Tools/scripts/byext.py", + "path_type": "hardlink", + "sha256": "6ee9217c93e6f5585bf83a86d7e2fc798f0eac6234fd9a361e0391b44cca84da", + "size_in_bytes": 3904 + }, + { + "_path": "Tools/scripts/byteyears.py", + "path_type": "hardlink", + "sha256": "c5d951197c74d4d4717f186097a46771f337cd0337fbf68b8470cbc22b792a28", + "size_in_bytes": 1650 + }, + { + "_path": "Tools/scripts/checkpip.py", + "path_type": "hardlink", + "sha256": "86383ad3550750bdaf6d84585a94797521b6819901adf2ede9f2b20bfbf0151d", + "size_in_bytes": 793 + }, + { + "_path": "Tools/scripts/cleanfuture.py", + "path_type": "hardlink", + "sha256": "bd2b01ca608607bb563f18475a562193a40c9a7e46d17f262f058da98f349313", + "size_in_bytes": 8626 + }, + { + "_path": "Tools/scripts/combinerefs.py", + "path_type": "hardlink", + "sha256": "9bca73b526b8a765145e1388b3c0bffdf5dd9a3ceeb2f8b2df369a3835940cd7", + "size_in_bytes": 4454 + }, + { + "_path": "Tools/scripts/copytime.py", + "path_type": "hardlink", + "sha256": "d6ab4b778507420c244663df2fb2d5fe2ee5ee078d502a6da6026e1791eb34de", + "size_in_bytes": 663 + }, + { + "_path": "Tools/scripts/crlf.py", + "path_type": "hardlink", + "sha256": "188bb160b9b1262a4772e5d9dfc0374f5170e359c1867d3d7287967b58d2b2cb", + "size_in_bytes": 632 + }, + { + "_path": "Tools/scripts/db2pickle.py", + "path_type": "hardlink", + "sha256": "004cf775fda2783974afc1599c33b77228f04f7c053760f4a9552927207a064e", + "size_in_bytes": 3630 + }, + { + "_path": "Tools/scripts/deepfreeze.py", + "path_type": "hardlink", + "sha256": "b3a79ae268439aac83bb801aaba5000c653c562bd13d308d6faca0a4562e4f5b", + "size_in_bytes": 19826 + }, + { + "_path": "Tools/scripts/diff.py", + "path_type": "hardlink", + "sha256": "103e18c5d4a0d24d3c0da99d1eaee3cbf11bb74430d10c4f7b0fef0ad3dc19c3", + "size_in_bytes": 2256 + }, + { + "_path": "Tools/scripts/dutree.py", + "path_type": "hardlink", + "sha256": "a7c4a2fe730e950a6fc9fab50b328f925585e005afe52e4fa524027f8bf990b5", + "size_in_bytes": 1638 + }, + { + "_path": "Tools/scripts/eptags.py", + "path_type": "hardlink", + "sha256": "54aa93343d6e6bd8b0f8d035eefe4aa28489b0579af2894a505e225c8290ef8f", + "size_in_bytes": 1581 + }, + { + "_path": "Tools/scripts/find-uname.py", + "path_type": "hardlink", + "sha256": "332a86b31df9c0a0241963e9a127756cc2fbb73febcedb2c75225f16d9f7cbab", + "size_in_bytes": 1207 + }, + { + "_path": "Tools/scripts/find_recursionlimit.py", + "path_type": "hardlink", + "sha256": "4e4412d9176fa44b09de646ce52907f86c278dafab36f7f112a417ca1782f2f4", + "size_in_bytes": 3995 + }, + { + "_path": "Tools/scripts/finddiv.py", + "path_type": "hardlink", + "sha256": "17dad9fbca640261e2e4a749bd56391a5bb14d1a3a643b690a581f3bbd7374d6", + "size_in_bytes": 2535 + }, + { + "_path": "Tools/scripts/findlinksto.py", + "path_type": "hardlink", + "sha256": "9511528eb787d474d5e38c8f73e9c0023f49805f104b2b588be5df65a88a519f", + "size_in_bytes": 1071 + }, + { + "_path": "Tools/scripts/findnocoding.py", + "path_type": "hardlink", + "sha256": "0d829b2f82e65726a370c3b8afb75a193e58eeadba4e1f1f412107ff9102be4e", + "size_in_bytes": 2952 + }, + { + "_path": "Tools/scripts/fixcid.py", + "path_type": "hardlink", + "sha256": "99b58221231a292e056a135f76a6f0e3a0f146d8263b0072e2bb97d4d144b717", + "size_in_bytes": 10165 + }, + { + "_path": "Tools/scripts/fixdiv.py", + "path_type": "hardlink", + "sha256": "24caaf3cdc7fe677cfb8886a8fea7a0a878f7c96019fbca04ff4b92c934f64be", + "size_in_bytes": 14241 + }, + { + "_path": "Tools/scripts/fixheader.py", + "path_type": "hardlink", + "sha256": "beaf5ca8ab28058fadb6a817a07dffe521eb60a032cb2e60719af3374da9819a", + "size_in_bytes": 1359 + }, + { + "_path": "Tools/scripts/fixnotice.py", + "path_type": "hardlink", + "sha256": "61f827456acfa99c2dd97be8c59109b58bec738cbd11e126a1926f1419bf2100", + "size_in_bytes": 3029 + }, + { + "_path": "Tools/scripts/fixps.py", + "path_type": "hardlink", + "sha256": "10bd8f27f521985a72a1b10d9122da00f89ed685bc079bebeeb5095b5463fc8e", + "size_in_bytes": 892 + }, + { + "_path": "Tools/scripts/freeze_modules.py", + "path_type": "hardlink", + "sha256": "b47bee07b52b83b165d4ba2cf568df4027d29dcafa4871ca605ba30223a59605", + "size_in_bytes": 24267 + }, + { + "_path": "Tools/scripts/generate_global_objects.py", + "path_type": "hardlink", + "sha256": "55d8e6b04f17ac4e6310dba4e22c0a8811c66fa6ffc977e3b400144adaf92a66", + "size_in_bytes": 10038 + }, + { + "_path": "Tools/scripts/generate_opcode_h.py", + "path_type": "hardlink", + "sha256": "5158bfd668ddec6cd42fe3a338804df88f25e7b14c24ae1835105cb15d8f02cb", + "size_in_bytes": 5128 + }, + { + "_path": "Tools/scripts/generate_re_casefix.py", + "path_type": "hardlink", + "sha256": "21f3f9365223887913c2d924f74bce7a2c2a3e08ae4a49efde994532e7c78a9f", + "size_in_bytes": 2703 + }, + { + "_path": "Tools/scripts/generate_sre_constants.py", + "path_type": "hardlink", + "sha256": "695464e17d4d0091dfd3004c2cbaf999ca138a2b059f93c0468c04d8bbdeed34", + "size_in_bytes": 2200 + }, + { + "_path": "Tools/scripts/generate_stdlib_module_names.py", + "path_type": "hardlink", + "sha256": "34ef644b4d8f81b33677995f671090cebdad171ec43311c0f56b54531cadcda1", + "size_in_bytes": 4862 + }, + { + "_path": "Tools/scripts/generate_token.py", + "path_type": "hardlink", + "sha256": "30185edbeca159086761c95068c053aca0fd4ff0f3bc58d46c09437e49063510", + "size_in_bytes": 6977 + }, + { + "_path": "Tools/scripts/get-remote-certificate.py", + "path_type": "hardlink", + "sha256": "8b8140346f970586094e630dae61aabae03b55cc3e447ddb4e39ff723d8c5f03", + "size_in_bytes": 2307 + }, + { + "_path": "Tools/scripts/google.py", + "path_type": "hardlink", + "sha256": "2866723cafa9519ea0f7292b6663bf84f3b933f6bf5b78184117efee85dd447d", + "size_in_bytes": 501 + }, + { + "_path": "Tools/scripts/gprof2html.py", + "path_type": "hardlink", + "sha256": "139a16077028e99a08984d9aa129f0e420b67f9e481d8a3eaeddfbb378829312", + "size_in_bytes": 2339 + }, + { + "_path": "Tools/scripts/highlight.py", + "path_type": "hardlink", + "sha256": "fe757329d020804bf031ed7b7cc1d49d825ddbb715065dce58d33531d4de2bd2", + "size_in_bytes": 9162 + }, + { + "_path": "Tools/scripts/ifdef.py", + "path_type": "hardlink", + "sha256": "496e621f9cee8f12894743fb767cfc5493442141f347990bc054878662ec22a5", + "size_in_bytes": 3704 + }, + { + "_path": "Tools/scripts/import_diagnostics.py", + "path_type": "hardlink", + "sha256": "390a3d8d9c09f4ed63d5cba06a997448424176011b16d5e1b371f24b6bc465b6", + "size_in_bytes": 999 + }, + { + "_path": "Tools/scripts/lfcr.py", + "path_type": "hardlink", + "sha256": "62142195e8e5ab3a89606f27d41bd77b65abb59b463c446d6e577bfd55f47da3", + "size_in_bytes": 640 + }, + { + "_path": "Tools/scripts/linktree.py", + "path_type": "hardlink", + "sha256": "496ec0a36a0c669808f70d3b411cae6b3806371d04cfa3435c9a96c7ef807c37", + "size_in_bytes": 2440 + }, + { + "_path": "Tools/scripts/lll.py", + "path_type": "hardlink", + "sha256": "7615e8b5f4b9a880c6431247daaccc984068cec6d896c9b2e950efb040571ef1", + "size_in_bytes": 748 + }, + { + "_path": "Tools/scripts/mailerdaemon.py", + "path_type": "hardlink", + "sha256": "65d82c2eb82783290c8ba1faaf4d01d203e2a5adefbccfdb8fc211dd84975ca5", + "size_in_bytes": 8040 + }, + { + "_path": "Tools/scripts/make_ctype.py", + "path_type": "hardlink", + "sha256": "c450fefe8ccec1eb7bed7799ea750d2669a204024b336e0815fd2c7060225a94", + "size_in_bytes": 2280 + }, + { + "_path": "Tools/scripts/md5sum.py", + "path_type": "hardlink", + "sha256": "0071503614d8ab66fb51278f60573153fe8694e2de8bcf3f10ea955355368734", + "size_in_bytes": 2518 + }, + { + "_path": "Tools/scripts/mkreal.py", + "path_type": "hardlink", + "sha256": "c45b34ba3e1b5d6c5f9b4eac79858a0bd89575056ed6c7f8e64716c7c7965df8", + "size_in_bytes": 1631 + }, + { + "_path": "Tools/scripts/ndiff.py", + "path_type": "hardlink", + "sha256": "b6cdad1690b6c50a43b19239e119eb3fe5755453548b804268a3cdd83bbed7da", + "size_in_bytes": 3820 + }, + { + "_path": "Tools/scripts/nm2def.py", + "path_type": "hardlink", + "sha256": "1674f9e4ca0f8d1253cdee2bd0ee491a7cd6899143d29249a7f1200fa59becb7", + "size_in_bytes": 2483 + }, + { + "_path": "Tools/scripts/objgraph.py", + "path_type": "hardlink", + "sha256": "449b5fdd4d45d1568ab834e19eebca618baacf568f0c4ff4b8c8a7c5c0925939", + "size_in_bytes": 5942 + }, + { + "_path": "Tools/scripts/parse_html5_entities.py", + "path_type": "hardlink", + "sha256": "1d0d62cdc5aae0b6091f79cd942b64d6b00373e9a30b93da7f03c3fdc4647307", + "size_in_bytes": 3999 + }, + { + "_path": "Tools/scripts/parseentities.py", + "path_type": "hardlink", + "sha256": "eb781e21cb5c8e66b433bff4471ee8cabc7a66f173b1b559455dddbdfdd6e22e", + "size_in_bytes": 1740 + }, + { + "_path": "Tools/scripts/patchcheck.py", + "path_type": "hardlink", + "sha256": "cecdb7e7574997037169ffdcce8e52260ea5a3593fcb8a8dd9b2dd17af278839", + "size_in_bytes": 10048 + }, + { + "_path": "Tools/scripts/pathfix.py", + "path_type": "hardlink", + "sha256": "7a2ff222346d3c95b08814e3372975823e099c17dddaa73a459a3d840e6e9c1b", + "size_in_bytes": 6787 + }, + { + "_path": "Tools/scripts/pdeps.py", + "path_type": "hardlink", + "sha256": "034bca275f172d7e67ff3e504bb5314765619e24943480321a2838be58acf403", + "size_in_bytes": 4004 + }, + { + "_path": "Tools/scripts/pep384_macrocheck.py", + "path_type": "hardlink", + "sha256": "c0619417bc16fc80128048e8751c5261f2afd61f7a87fdc350a63936fcaf8d20", + "size_in_bytes": 4719 + }, + { + "_path": "Tools/scripts/pickle2db.py", + "path_type": "hardlink", + "sha256": "e89c4eab0b199eb58ec21c2506eda27d46f838e1d0f84565b7cabfc8054fcb70", + "size_in_bytes": 4021 + }, + { + "_path": "Tools/scripts/pindent.py", + "path_type": "hardlink", + "sha256": "298ba6ff015bb3b43abd7012bf33e5a57786da99db45741d0687c4914a3b3664", + "size_in_bytes": 17127 + }, + { + "_path": "Tools/scripts/ptags.py", + "path_type": "hardlink", + "sha256": "ef7b450c4feb07bb8a4087c4d5824c05297a71fea72a1b4c265d83ffeb9475d6", + "size_in_bytes": 1315 + }, + { + "_path": "Tools/scripts/pydoc3.py", + "path_type": "hardlink", + "sha256": "f03ae1cf496ad34a2cf82e33ff0a975878cccf769475015e95a7e0955d6e7063", + "size_in_bytes": 80 + }, + { + "_path": "Tools/scripts/pysource.py", + "path_type": "hardlink", + "sha256": "bdc639db52bab3683adf8748f902a4d30346eb12b8a085f92a6090ad6d71d564", + "size_in_bytes": 3864 + }, + { + "_path": "Tools/scripts/reindent-rst.py", + "path_type": "hardlink", + "sha256": "4d367080ae5c83b172071956bb4f0cea333d9506e8bc8a418844ae38959f9b33", + "size_in_bytes": 279 + }, + { + "_path": "Tools/scripts/reindent.py", + "path_type": "hardlink", + "sha256": "79afa4e2ef0cfca510d852a2a0e22ff15c0e5a0455a9d4f416f9761cd548c6d9", + "size_in_bytes": 11647 + }, + { + "_path": "Tools/scripts/rgrep.py", + "path_type": "hardlink", + "sha256": "54e415c277df5a94b6fbc4c7400f0aa4213d830750f169b0999369a5c9b7608e", + "size_in_bytes": 1580 + }, + { + "_path": "Tools/scripts/run_tests.py", + "path_type": "hardlink", + "sha256": "630c15b1414d7a61becffd15c6164030c0425f9449522301fd8284df4323a8df", + "size_in_bytes": 3218 + }, + { + "_path": "Tools/scripts/smelly.py", + "path_type": "hardlink", + "sha256": "9ab33ff7e784bd87c937a3b398ed9703c5ff5d85878f182abd50b955d41c6f6c", + "size_in_bytes": 5022 + }, + { + "_path": "Tools/scripts/sortperf.py", + "path_type": "hardlink", + "sha256": "0eb887f3a10e084a1e97f1ff565aa8233ee302c28d3eb2bef4e24ede2dcad4d9", + "size_in_bytes": 5870 + }, + { + "_path": "Tools/scripts/stable_abi.py", + "path_type": "hardlink", + "sha256": "e9255bcca702fcdc31ee01bf640bc5491f8eed5446a22c8122b0d89489705d29", + "size_in_bytes": 25117 + }, + { + "_path": "Tools/scripts/startuptime.py", + "path_type": "hardlink", + "sha256": "0a8953e19976a3fc32c98521928116c5edc988943c64765daf4ea85bc197ce3a", + "size_in_bytes": 435 + }, + { + "_path": "Tools/scripts/suff.py", + "path_type": "hardlink", + "sha256": "7c9c5a591ee590d70caeadd38ad53675412a934fadc15f798529c42c7889cac0", + "size_in_bytes": 510 + }, + { + "_path": "Tools/scripts/summarize_stats.py", + "path_type": "hardlink", + "sha256": "0e2eb29d52fbd4ab13026892065891233996b08f0b8e698fa74a743353a1e6cb", + "size_in_bytes": 13058 + }, + { + "_path": "Tools/scripts/texi2html.py", + "path_type": "hardlink", + "sha256": "b7a3601b21a0c7d5b18302930762e5740a9e199e07075067df0381cf69501f81", + "size_in_bytes": 70373 + }, + { + "_path": "Tools/scripts/umarshal.py", + "path_type": "hardlink", + "sha256": "acc928a877ba357bd1bf72caa4476e7546383c3a6fbea4fac5acd361f90dde7b", + "size_in_bytes": 9818 + }, + { + "_path": "Tools/scripts/untabify.py", + "path_type": "hardlink", + "sha256": "a713c21b82c7118b85ed38c1e78840afac50d8c67d205bbeb2197170c5f750b5", + "size_in_bytes": 1296 + }, + { + "_path": "Tools/scripts/update_file.py", + "path_type": "hardlink", + "sha256": "94f01b432ec47a5d675a50c8e44051d1629dde33186ee2c62e4bbc6ea2fd49e6", + "size_in_bytes": 2764 + }, + { + "_path": "Tools/scripts/var_access_benchmark.py", + "path_type": "hardlink", + "sha256": "ff0fd735a9a548cebce4380d9e1e7660f5f86a3d2ca3c240e4314a1231a27ea9", + "size_in_bytes": 11912 + }, + { + "_path": "Tools/scripts/verify_ensurepip_wheels.py", + "path_type": "hardlink", + "sha256": "e16936f8170020bdfb18e6b9e977f3f99fd250dc9e69aa79b25a7cea0b8ea749", + "size_in_bytes": 3391 + }, + { + "_path": "Tools/scripts/which.py", + "path_type": "hardlink", + "sha256": "11b2b81ac4ee9076a0d9c0ccc789d047c9a1467f2763d12297f31b521a36cf28", + "size_in_bytes": 1686 + }, + { + "_path": "Tools/scripts/win_add2path.py", + "path_type": "hardlink", + "sha256": "30034ace8427493f3169bb46d870d6f0224eea86e0e1a3e85bc5faed1d398553", + "size_in_bytes": 1658 + }, + { + "_path": "include/Python.h", + "path_type": "hardlink", + "sha256": "0996602e0860a811d9a526c410e5acf04c1ec91c0a27bc5edef3ea077ad46a27", + "size_in_bytes": 2854 + }, + { + "_path": "include/README.rst", + "path_type": "hardlink", + "sha256": "31c964da8d863bf741337858945c8fea551a6a4f3b4e1478fed3210960f445a2", + "size_in_bytes": 344 + }, + { + "_path": "include/abstract.h", + "path_type": "hardlink", + "sha256": "2fd8611515ee97170e36b95c145ff0c11cf891a1d366bb13f383560f6c21f50d", + "size_in_bytes": 31404 + }, + { + "_path": "include/bltinmodule.h", + "path_type": "hardlink", + "sha256": "1b5101b4b85409fd910032713906800bbb83580503036469c2a60ac8e80b8f72", + "size_in_bytes": 264 + }, + { + "_path": "include/boolobject.h", + "path_type": "hardlink", + "sha256": "16f0ae0c513cd9f14369eb89197b78688ed586ca79bb8f9e0eb2e55819fbd078", + "size_in_bytes": 1212 + }, + { + "_path": "include/bytearrayobject.h", + "path_type": "hardlink", + "sha256": "1d0bd1f641421bb850376c9e07d1463ed57882ccbd15254c1fcb3d39680b3b5c", + "size_in_bytes": 1462 + }, + { + "_path": "include/bytesobject.h", + "path_type": "hardlink", + "sha256": "1deca8ea6efa46bb615b8808334047ea8b8fe90f3251bdee2c1e213249646082", + "size_in_bytes": 2617 + }, + { + "_path": "include/ceval.h", + "path_type": "hardlink", + "sha256": "e7c5564a1bed0781aab2ba5aba767e8ed4719c69f8e5768d26754274b907a504", + "size_in_bytes": 6255 + }, + { + "_path": "include/codecs.h", + "path_type": "hardlink", + "sha256": "0ca3c6e55e7ff62872b47aeeb7379d784b03ebfc61bbd029b67485fe783baac5", + "size_in_bytes": 7071 + }, + { + "_path": "include/compile.h", + "path_type": "hardlink", + "sha256": "28676e6ff63848c7e812c34bb79cd81dfccbc0a9ffc56d5b1439b304df3771ea", + "size_in_bytes": 520 + }, + { + "_path": "include/complexobject.h", + "path_type": "hardlink", + "sha256": "4f05e5d985c433629ac37fe38e913630f047880c81e888bfb7832c76e25953c3", + "size_in_bytes": 724 + }, + { + "_path": "include/cpython/abstract.h", + "path_type": "hardlink", + "sha256": "ed257bda05f5eeda5b412c31dc076ced73e57adfea61dc95ec5182dad6527a1c", + "size_in_bytes": 8229 + }, + { + "_path": "include/cpython/bytearrayobject.h", + "path_type": "hardlink", + "sha256": "2e31ae1760c2f47ad12cebd98b458ec64ee3d910ec15955d243cc5f21160e189", + "size_in_bytes": 1305 + }, + { + "_path": "include/cpython/bytesobject.h", + "path_type": "hardlink", + "sha256": "9c5e3576333819037c9ad38d09f8420a8c20487ce20d14ffc513da077312321c", + "size_in_bytes": 4802 + }, + { + "_path": "include/cpython/cellobject.h", + "path_type": "hardlink", + "sha256": "2fe156bd8d3a78ce60e44a9fc345191318a9cdcfb3faa6ab21008f6fa7fdac63", + "size_in_bytes": 723 + }, + { + "_path": "include/cpython/ceval.h", + "path_type": "hardlink", + "sha256": "623c20252e1b0d37fdff39202971d3fb7d4a53380afa07c53dd6edfff2fb50d2", + "size_in_bytes": 1239 + }, + { + "_path": "include/cpython/classobject.h", + "path_type": "hardlink", + "sha256": "e7107ef9f720327da6806f053e55c784e58a0099689e0a850811f69dee4b3ce9", + "size_in_bytes": 1656 + }, + { + "_path": "include/cpython/code.h", + "path_type": "hardlink", + "sha256": "45bd9ac22a8a1145bc50f5cc5ae3f2687c27efdd48dcadaea298297fd6be6a79", + "size_in_bytes": 11484 + }, + { + "_path": "include/cpython/compile.h", + "path_type": "hardlink", + "sha256": "87cc83e0e8b89cb0db751222e8104ce05ae694e90affc82c46a78a1f33b59560", + "size_in_bytes": 2218 + }, + { + "_path": "include/cpython/complexobject.h", + "path_type": "hardlink", + "sha256": "a4c110008e4d791a4577ce6ebee33bc512ec3e3db918bd2c296f00dd79379fcb", + "size_in_bytes": 1248 + }, + { + "_path": "include/cpython/context.h", + "path_type": "hardlink", + "sha256": "1a56db7a89a75edf2692489ccc42f932a1c113d31e2ccbfa0c5bce3d58fe463c", + "size_in_bytes": 1959 + }, + { + "_path": "include/cpython/descrobject.h", + "path_type": "hardlink", + "sha256": "a1ee0124142fe91204d0c5e85169b55341b2167111a1447e3a8ed50f9bd5a12f", + "size_in_bytes": 1642 + }, + { + "_path": "include/cpython/dictobject.h", + "path_type": "hardlink", + "sha256": "dd71748f24dcb817cab41a0fd730f7d45c132c1107e301b48547dd980c282df2", + "size_in_bytes": 3324 + }, + { + "_path": "include/cpython/fileobject.h", + "path_type": "hardlink", + "sha256": "16ab872cbe2bb3351ce3090873440903b1460c1d68aed483c70c31edc4140ba2", + "size_in_bytes": 818 + }, + { + "_path": "include/cpython/fileutils.h", + "path_type": "hardlink", + "sha256": "d7a2f703c6fba2efabd0b1cc916ad36074363a27a000987cfad17e21f04d44f1", + "size_in_bytes": 232 + }, + { + "_path": "include/cpython/floatobject.h", + "path_type": "hardlink", + "sha256": "095f6ad590a760b86546ba901c6a2b7752c04e45e4f30be3a5a3df1a1dbcdf72", + "size_in_bytes": 702 + }, + { + "_path": "include/cpython/frameobject.h", + "path_type": "hardlink", + "sha256": "e1421b58c6a25efb56f423a749c313e3f5392f58cc0c7f4f09b0412217a4a734", + "size_in_bytes": 1108 + }, + { + "_path": "include/cpython/funcobject.h", + "path_type": "hardlink", + "sha256": "25f0b1217df076762e0f0e88e8a340ee1243445df26fa781a19be287a3c95df4", + "size_in_bytes": 4424 + }, + { + "_path": "include/cpython/genobject.h", + "path_type": "hardlink", + "sha256": "4e7a4e5698fc0249047fa214377ff024b6daaaf43f43086d0e0db7f94484e774", + "size_in_bytes": 3279 + }, + { + "_path": "include/cpython/import.h", + "path_type": "hardlink", + "sha256": "87db6aea2bb2ab2e22285ba57f24326b5254cbbbbb41503bb007263f6acfaf2e", + "size_in_bytes": 1526 + }, + { + "_path": "include/cpython/initconfig.h", + "path_type": "hardlink", + "sha256": "b134762b4a480ef2708ef759fc540ea306cb088575575c40496aca631f9cd0c3", + "size_in_bytes": 7817 + }, + { + "_path": "include/cpython/listobject.h", + "path_type": "hardlink", + "sha256": "764f3157364c32e279d7a047f3d5821c3f7fe3b9529d45768901fab8f0552f3f", + "size_in_bytes": 1769 + }, + { + "_path": "include/cpython/longintrepr.h", + "path_type": "hardlink", + "sha256": "696758e019b859a4595b165c3dad33bfae4598a855b9118d021e24a6dd026ecd", + "size_in_bytes": 3817 + }, + { + "_path": "include/cpython/longobject.h", + "path_type": "hardlink", + "sha256": "c534b0c884683666dec90fc34551b0d6d579664c174e1c8f6eecf9744669dc72", + "size_in_bytes": 4532 + }, + { + "_path": "include/cpython/methodobject.h", + "path_type": "hardlink", + "sha256": "d90fca55e197b2e2a3cbf2af8074ab0ae817e1e4bd39b1b2df2f083347ad1a89", + "size_in_bytes": 2556 + }, + { + "_path": "include/cpython/modsupport.h", + "path_type": "hardlink", + "sha256": "e76c6c1d9366c98a19363c24036fbebb8cb155fd10e27199782452943d3708fa", + "size_in_bytes": 4303 + }, + { + "_path": "include/cpython/object.h", + "path_type": "hardlink", + "sha256": "b5324193c68f9a3ffb37d36df8ca776c25926d7b973fb100a20fdc8756fcc3e1", + "size_in_bytes": 18305 + }, + { + "_path": "include/cpython/objimpl.h", + "path_type": "hardlink", + "sha256": "20c3a5c7c989472d84bd7af93e0002292943eae7e46f8d8cb0c64addfac848b0", + "size_in_bytes": 2998 + }, + { + "_path": "include/cpython/odictobject.h", + "path_type": "hardlink", + "sha256": "ff2b0d77aea871c1edd6f63209489fe70c7c11d4da9c3e2f6ef6858cdb004a0d", + "size_in_bytes": 1299 + }, + { + "_path": "include/cpython/picklebufobject.h", + "path_type": "hardlink", + "sha256": "da3dd5626150aa4e00a4a0199baa582b4db9b9362412a44f9ac20ca80b0086ca", + "size_in_bytes": 846 + }, + { + "_path": "include/cpython/pthread_stubs.h", + "path_type": "hardlink", + "sha256": "0f3108e0430ee937098c86352d2ced6e3ec7f5cb5bc7e06eebee58cf779fcd89", + "size_in_bytes": 3505 + }, + { + "_path": "include/cpython/pyctype.h", + "path_type": "hardlink", + "sha256": "10b5ccbc210fd2832e9c34849a3952e8db75f0016add89188358b1da6a8f3dbb", + "size_in_bytes": 1387 + }, + { + "_path": "include/cpython/pydebug.h", + "path_type": "hardlink", + "sha256": "3e63cb7d18785b0efda166a0ea540a02104dd883fb2f754100c198295cc09107", + "size_in_bytes": 1073 + }, + { + "_path": "include/cpython/pyerrors.h", + "path_type": "hardlink", + "sha256": "44bbb2538cb221f0fa4bb2b0140ca57a163508399cc910ec40ba0719c56b3aa4", + "size_in_bytes": 4522 + }, + { + "_path": "include/cpython/pyfpe.h", + "path_type": "hardlink", + "sha256": "ea7bfa7d891a0b5372d8b40a57d1b466b7824296e5c3f8d50b1a7cde084429b7", + "size_in_bytes": 444 + }, + { + "_path": "include/cpython/pyframe.h", + "path_type": "hardlink", + "sha256": "f24bbe196b29bf392af44a149fb194a8b20ca008de3b98996c9ee8ea146ce67e", + "size_in_bytes": 582 + }, + { + "_path": "include/cpython/pylifecycle.h", + "path_type": "hardlink", + "sha256": "f139a33fbe7d217e0a054f892f839c8f44e215d7e5a99043912c6e8ad8543307", + "size_in_bytes": 2099 + }, + { + "_path": "include/cpython/pymem.h", + "path_type": "hardlink", + "sha256": "8a3795a9350b10548e8ad6d37dad69be2abd3870a751e67faa32a19a090608db", + "size_in_bytes": 3379 + }, + { + "_path": "include/cpython/pystate.h", + "path_type": "hardlink", + "sha256": "d1921e3b825c4d500cfd5965d47a4033498fd5a5a1ddefec4c267240564161d0", + "size_in_bytes": 14351 + }, + { + "_path": "include/cpython/pythonrun.h", + "path_type": "hardlink", + "sha256": "da9ac8ec2ae5ac970ca607a1779c0cb519b2fa67992a70171689191ffa4bfc8c", + "size_in_bytes": 4811 + }, + { + "_path": "include/cpython/pythread.h", + "path_type": "hardlink", + "sha256": "7239113064e41ba5a678b665af17bee1f878d51076f6d82f89d5d52151ebf573", + "size_in_bytes": 1426 + }, + { + "_path": "include/cpython/pytime.h", + "path_type": "hardlink", + "sha256": "4ac3a5492b9418319098cf3ab7458104cb84f47baebd6f716c259ebdfa4c439f", + "size_in_bytes": 12158 + }, + { + "_path": "include/cpython/setobject.h", + "path_type": "hardlink", + "sha256": "1edc179e283bd4f3cfab16a58759b41c78ec90365615510baf7087dd8535084e", + "size_in_bytes": 1997 + }, + { + "_path": "include/cpython/sysmodule.h", + "path_type": "hardlink", + "sha256": "d4936db24692cccadb19c11accda260787f95e5658f88cfc752d9a49344ee051", + "size_in_bytes": 489 + }, + { + "_path": "include/cpython/traceback.h", + "path_type": "hardlink", + "sha256": "7898a3c168973e1119fb3b57f144be627c1468082ab0b91d001dd876dd1dbcb6", + "size_in_bytes": 444 + }, + { + "_path": "include/cpython/tupleobject.h", + "path_type": "hardlink", + "sha256": "8165ac967454724ea46f94697ab9fc09be9bf27e982087ac10d2fc0b642b2ba5", + "size_in_bytes": 1513 + }, + { + "_path": "include/cpython/unicodeobject.h", + "path_type": "hardlink", + "sha256": "9183d40b4aec778c4f59d2091b4374722f635116a33ae6fc66c16e0b5fa700b5", + "size_in_bytes": 42739 + }, + { + "_path": "include/cpython/warnings.h", + "path_type": "hardlink", + "sha256": "f06f074847ee630ea57c9fdb019ba6aa57805ac7712ef227fd7f2a97a08a3a28", + "size_in_bytes": 560 + }, + { + "_path": "include/cpython/weakrefobject.h", + "path_type": "hardlink", + "sha256": "60c1b95d2ad6b61b00b603292cda75d5e3ad23dc11d3238366479aaf5ad89ecf", + "size_in_bytes": 2103 + }, + { + "_path": "include/datetime.h", + "path_type": "hardlink", + "sha256": "7cd737123510f5ddc334cc2550c832bd1ecc1be73b47e46f4c4a5c3ccb9ac1f5", + "size_in_bytes": 9635 + }, + { + "_path": "include/descrobject.h", + "path_type": "hardlink", + "sha256": "92f1781f93decc091dbf7adba602c54cef155a3336790b5f60fc87c2d6d0eaf4", + "size_in_bytes": 1256 + }, + { + "_path": "include/dictobject.h", + "path_type": "hardlink", + "sha256": "bc910b4a8564ed71320aa8044c27e98313a1be28e44ab80891e37e6fdea375b1", + "size_in_bytes": 3852 + }, + { + "_path": "include/dynamic_annotations.h", + "path_type": "hardlink", + "sha256": "3e4366f7d082835049730358d277a5ad7a60e16d1601f5622f0a045a37c152ac", + "size_in_bytes": 22471 + }, + { + "_path": "include/enumobject.h", + "path_type": "hardlink", + "sha256": "2244fe250db9995068fe74dce0e23fd70c12b03fd94751d98b773be8f64896b6", + "size_in_bytes": 253 + }, + { + "_path": "include/errcode.h", + "path_type": "hardlink", + "sha256": "eb5cade85e015fb8c69166b87a764753c76901e2f74aaa6064aa09d3a88271d2", + "size_in_bytes": 1780 + }, + { + "_path": "include/exports.h", + "path_type": "hardlink", + "sha256": "f9242de8f731846164d4446745dd2a737ccdf83f754099018edc90485b1cd445", + "size_in_bytes": 1098 + }, + { + "_path": "include/fileobject.h", + "path_type": "hardlink", + "sha256": "d08b73856c506c76996a40e3aa8b67b3e92d8ed0b1c96ee04ecd841287c59057", + "size_in_bytes": 1570 + }, + { + "_path": "include/fileutils.h", + "path_type": "hardlink", + "sha256": "51ae1c2ca70a8005206f653121d1ba3247f59421c96399739845d687980e9b01", + "size_in_bytes": 507 + }, + { + "_path": "include/floatobject.h", + "path_type": "hardlink", + "sha256": "2803fe6d1df3f01c4147c90fd09701fb293ae929cd798864a5b217e5143f0fdf", + "size_in_bytes": 1530 + }, + { + "_path": "include/frameobject.h", + "path_type": "hardlink", + "sha256": "969cd93065ce79b81bbc67a65d31b742e23f30bf79d6e44a306963d552ed0c35", + "size_in_bytes": 336 + }, + { + "_path": "include/genericaliasobject.h", + "path_type": "hardlink", + "sha256": "0e53a0b18c114be68eccea9ffd1dd577e204b1f0ada4d3aedc8e7ee0c80fc7f8", + "size_in_bytes": 334 + }, + { + "_path": "include/import.h", + "path_type": "hardlink", + "sha256": "151e564ed3638ddf76b20269ad16d0463410b4f6c903955184babbd775ca0a5b", + "size_in_bytes": 3025 + }, + { + "_path": "include/internal/pycore_abstract.h", + "path_type": "hardlink", + "sha256": "75ecd34cdcd06fc64fcfa550f66975d755619e7cf06fdae8ecbe2de6ec49ce39", + "size_in_bytes": 611 + }, + { + "_path": "include/internal/pycore_accu.h", + "path_type": "hardlink", + "sha256": "0af5cf048f515646d68566bd8786e973c45a501f23782d80961e390b116adb2b", + "size_in_bytes": 1126 + }, + { + "_path": "include/internal/pycore_asdl.h", + "path_type": "hardlink", + "sha256": "2651055732e780bf011e3c770ccc24a64f9c696af3d393da2876c2c2a2cce494", + "size_in_bytes": 3031 + }, + { + "_path": "include/internal/pycore_ast.h", + "path_type": "hardlink", + "sha256": "e1392767a1037d537c568a8be8a04da2418278caa5cc99c4b340bd7922f455e9", + "size_in_bytes": 29315 + }, + { + "_path": "include/internal/pycore_ast_state.h", + "path_type": "hardlink", + "sha256": "acdbe919bc3d000b89fb54209582c87fd9820ca52a216712c051e1f875010c74", + "size_in_bytes": 6549 + }, + { + "_path": "include/internal/pycore_atomic.h", + "path_type": "hardlink", + "sha256": "95e7118e799ad3faafc8e58a29b2d1f1a4bb94e1aac3273e042f379f8e12d4e6", + "size_in_bytes": 16979 + }, + { + "_path": "include/internal/pycore_atomic_funcs.h", + "path_type": "hardlink", + "sha256": "9d5cfa13ad863a0cc1b0ab06861c1f8cfbdc7d730b9c4603e5777a608263d399", + "size_in_bytes": 2438 + }, + { + "_path": "include/internal/pycore_bitutils.h", + "path_type": "hardlink", + "sha256": "86628b9cbefe4ff000e1190cd36f37b70a2dad6a4e9231cc2466a84579cc2139", + "size_in_bytes": 6062 + }, + { + "_path": "include/internal/pycore_blocks_output_buffer.h", + "path_type": "hardlink", + "sha256": "03fed5054d0d78e3711e73995e484fefb81495c063a5b9ef555c0395d7fc1ebc", + "size_in_bytes": 8688 + }, + { + "_path": "include/internal/pycore_bytes_methods.h", + "path_type": "hardlink", + "sha256": "1534326dbf027e9bb472be5ccf8b82fab48f3282cc7f6a61629b801fc80afc00", + "size_in_bytes": 3384 + }, + { + "_path": "include/internal/pycore_bytesobject.h", + "path_type": "hardlink", + "sha256": "3740f631b73c61dc70fb0869e945e52c85a651cb1956a92c115ec64311cf9a7a", + "size_in_bytes": 1424 + }, + { + "_path": "include/internal/pycore_call.h", + "path_type": "hardlink", + "sha256": "03d329dcabb7739bc1952f7371dbdf74f07b04b4a06d20ce823021269b308c53", + "size_in_bytes": 3475 + }, + { + "_path": "include/internal/pycore_ceval.h", + "path_type": "hardlink", + "sha256": "266927ead7a38b28ffc9063610666ff4eff60f31e5ee12ea3d617a9c7899f477", + "size_in_bytes": 4409 + }, + { + "_path": "include/internal/pycore_code.h", + "path_type": "hardlink", + "sha256": "1daa51db7e64726a8ebfa631c18aff4576af173927fedc94b5c9e96e790c4834", + "size_in_bytes": 15930 + }, + { + "_path": "include/internal/pycore_compile.h", + "path_type": "hardlink", + "sha256": "21506bc00cb04a89618141c76e31b831c0fafdade423c3e5273b98560e0a6d72", + "size_in_bytes": 1045 + }, + { + "_path": "include/internal/pycore_condvar.h", + "path_type": "hardlink", + "sha256": "89a5d9c366c2e1c312e1ace5067d184380242c944deb698b6a4f53b51abd5826", + "size_in_bytes": 2839 + }, + { + "_path": "include/internal/pycore_context.h", + "path_type": "hardlink", + "sha256": "0dafde3ccfdd286dbcbdf51ca8dcdc35a09e52c0243df973276df1a2b2d879a7", + "size_in_bytes": 1239 + }, + { + "_path": "include/internal/pycore_dict.h", + "path_type": "hardlink", + "sha256": "60be02c4ae93ef6ac0ee3d4e1ab5e0310d61054018b1760a68c85e496eb05c6e", + "size_in_bytes": 5684 + }, + { + "_path": "include/internal/pycore_dtoa.h", + "path_type": "hardlink", + "sha256": "7935ef05bff91b43d94a6bdc06db16dc04c5b8ef34841af22a9922af9f4f86d3", + "size_in_bytes": 704 + }, + { + "_path": "include/internal/pycore_emscripten_signal.h", + "path_type": "hardlink", + "sha256": "1acd47a1c09e365be8c7fa51db31307021cc2e471471fc199e26f317df58c4b8", + "size_in_bytes": 562 + }, + { + "_path": "include/internal/pycore_exceptions.h", + "path_type": "hardlink", + "sha256": "4590af737d53afcbd7d559434190d2d8ff4f5cd0e923837721aea5ebb000ef68", + "size_in_bytes": 842 + }, + { + "_path": "include/internal/pycore_fileutils.h", + "path_type": "hardlink", + "sha256": "c32c84745970b7b4a6adbeff7cbfb9fe773611840ecd18b63341e7d5c8b96428", + "size_in_bytes": 7403 + }, + { + "_path": "include/internal/pycore_floatobject.h", + "path_type": "hardlink", + "sha256": "8a000c1df83b7ba58492375ad7a22c64f9b06bf4ddc84f3fbd4beaf689b5e4fb", + "size_in_bytes": 1307 + }, + { + "_path": "include/internal/pycore_format.h", + "path_type": "hardlink", + "sha256": "253cc77e6d11ba20d297813e064650fa965b3653f150bd85f805b94db5f3a98d", + "size_in_bytes": 480 + }, + { + "_path": "include/internal/pycore_frame.h", + "path_type": "hardlink", + "sha256": "dbebda00d2d2da2bae4c590413e5231b09b8414a40e08d555a195584be3d79c4", + "size_in_bytes": 7567 + }, + { + "_path": "include/internal/pycore_function.h", + "path_type": "hardlink", + "sha256": "385e3befb2ab108b7339f29b1a894bde276d885d294da46850710af30984b641", + "size_in_bytes": 413 + }, + { + "_path": "include/internal/pycore_gc.h", + "path_type": "hardlink", + "sha256": "6a5452e7360224a40b464651f9bc91c72e13903bac625375ac7556605e82d595", + "size_in_bytes": 6895 + }, + { + "_path": "include/internal/pycore_genobject.h", + "path_type": "hardlink", + "sha256": "448db1951cf78cfe29d2bee49eae9ff2b8e7c7eb425358f23919594c75790ba4", + "size_in_bytes": 1164 + }, + { + "_path": "include/internal/pycore_getopt.h", + "path_type": "hardlink", + "sha256": "e93393067b66b557b0300e05c10ee904d4be54cadfb214c5328a9225ad199452", + "size_in_bytes": 490 + }, + { + "_path": "include/internal/pycore_gil.h", + "path_type": "hardlink", + "sha256": "cf455aacd5651e5b43547ebe69bb324eab84238d92665df53c1df32434bd0d9b", + "size_in_bytes": 1565 + }, + { + "_path": "include/internal/pycore_global_objects.h", + "path_type": "hardlink", + "sha256": "214d514eb920729847fdb059131fb72bae986186234b94ae67091ad440974b16", + "size_in_bytes": 1436 + }, + { + "_path": "include/internal/pycore_global_strings.h", + "path_type": "hardlink", + "sha256": "94d19e0f8e681eaa1cb40b66989275380f5d8db4bd385871b5923162645b2bcf", + "size_in_bytes": 12980 + }, + { + "_path": "include/internal/pycore_hamt.h", + "path_type": "hardlink", + "sha256": "8f5112c59fd0360bbb19339c50707fa7c847d645ebcfaf23c2d9a12290223ade", + "size_in_bytes": 3696 + }, + { + "_path": "include/internal/pycore_hashtable.h", + "path_type": "hardlink", + "sha256": "75e903486d6b6e0468770a6bc3895d8b9423c1b64614e38b29a1d65a1d5bfdf7", + "size_in_bytes": 4197 + }, + { + "_path": "include/internal/pycore_import.h", + "path_type": "hardlink", + "sha256": "4b2879615759c0de49c75f22e3b753526e82851a3f094bc7dd1b6820e4c984c5", + "size_in_bytes": 743 + }, + { + "_path": "include/internal/pycore_initconfig.h", + "path_type": "hardlink", + "sha256": "c51149145b12c76be364c085d4e067a6615e6fe799e0dee939e6475b0541e75e", + "size_in_bytes": 5800 + }, + { + "_path": "include/internal/pycore_interp.h", + "path_type": "hardlink", + "sha256": "0dc773a1e6e48a32c58b2d475d9199ebddafaf07c00d971a06d5c18afa923fae", + "size_in_bytes": 6671 + }, + { + "_path": "include/internal/pycore_interpreteridobject.h", + "path_type": "hardlink", + "sha256": "288067f6522dec60448601f4e614d6f4c68f0842c964e8ad4c5d98b4a1d61a95", + "size_in_bytes": 562 + }, + { + "_path": "include/internal/pycore_list.h", + "path_type": "hardlink", + "sha256": "00d15f3dadd7fcde6f52f2a5b1be740638b41c653b133bce1ce03e96b3afac40", + "size_in_bytes": 1352 + }, + { + "_path": "include/internal/pycore_long.h", + "path_type": "hardlink", + "sha256": "c19924def7de6a0dcc0c3d8893e281980bd265932aa79400af685f5f5e0b1b3b", + "size_in_bytes": 3516 + }, + { + "_path": "include/internal/pycore_moduleobject.h", + "path_type": "hardlink", + "sha256": "a38bcae58f44456220f9cb5e5a6b0aca02d316ec4d662bd31f0c7cae6539d6a6", + "size_in_bytes": 1040 + }, + { + "_path": "include/internal/pycore_namespace.h", + "path_type": "hardlink", + "sha256": "466fe0e3f48e954d8bfe9e0c73fc9378cf79ca37710778ba6698e1c365304956", + "size_in_bytes": 392 + }, + { + "_path": "include/internal/pycore_object.h", + "path_type": "hardlink", + "sha256": "0ad16deb45ea2e272f4b6a079be576ac9cb266195d6314b8fdc5f043003ccb45", + "size_in_bytes": 10037 + }, + { + "_path": "include/internal/pycore_opcode.h", + "path_type": "hardlink", + "sha256": "a46476368811d3ecf7d50a7e6b53357cdbe7a1685d69d4c2bdf70e6b9b157e6a", + "size_in_bytes": 18986 + }, + { + "_path": "include/internal/pycore_parser.h", + "path_type": "hardlink", + "sha256": "05260556eb3974a843ef4528f0b2d287fe0271260d40a901139fca5840585409", + "size_in_bytes": 626 + }, + { + "_path": "include/internal/pycore_pathconfig.h", + "path_type": "hardlink", + "sha256": "ff96c74aae60eba62bec8c6d52f34471caf07792186bc16d76e7a783f61aa0ed", + "size_in_bytes": 606 + }, + { + "_path": "include/internal/pycore_pyarena.h", + "path_type": "hardlink", + "sha256": "d4f4e513bae78ff985f51ca48fb7d1a4d57055c59393a1eb661e55e6ec3ba61f", + "size_in_bytes": 2733 + }, + { + "_path": "include/internal/pycore_pyerrors.h", + "path_type": "hardlink", + "sha256": "1af229602b642df7549165e422b5af23fce1f7b702362f2321a932891f0f3f84", + "size_in_bytes": 2494 + }, + { + "_path": "include/internal/pycore_pyhash.h", + "path_type": "hardlink", + "sha256": "6e9db9d3e7d7245b10e33598b995fc9b51b3952ce17225830d0248c6fa62dd51", + "size_in_bytes": 206 + }, + { + "_path": "include/internal/pycore_pylifecycle.h", + "path_type": "hardlink", + "sha256": "366770bfe34a2ba8e4fc4603a43aff7648ccb60976522f68d29a36c51422d2c3", + "size_in_bytes": 3507 + }, + { + "_path": "include/internal/pycore_pymath.h", + "path_type": "hardlink", + "sha256": "740162cd6a7cc0b0d8edd910244f9006a819f87393ec8f2da2a4fae607f3a243", + "size_in_bytes": 9435 + }, + { + "_path": "include/internal/pycore_pymem.h", + "path_type": "hardlink", + "sha256": "031901cfd66eaceaa9d31fa0240f0e8cdf3ddf336a54e1d32eb3a655b852750e", + "size_in_bytes": 3708 + }, + { + "_path": "include/internal/pycore_pystate.h", + "path_type": "hardlink", + "sha256": "5796ade83ce06ffb0ad1d5893628b3a3117ad3f1dbb37398735121f2feade93d", + "size_in_bytes": 4250 + }, + { + "_path": "include/internal/pycore_runtime.h", + "path_type": "hardlink", + "sha256": "e921f6a25b7b06fd807e7d03b09237a743472939d3aadb3da902278c553d826d", + "size_in_bytes": 5988 + }, + { + "_path": "include/internal/pycore_runtime_init.h", + "path_type": "hardlink", + "sha256": "135b483b701c038a4f1e59cbf1b10a9b4a8656bfce357c7271ad77be724c438a", + "size_in_bytes": 49092 + }, + { + "_path": "include/internal/pycore_signal.h", + "path_type": "hardlink", + "sha256": "dbb3ece35c895e4128cd0d569b755d1ddb5f0582cafa79781fcd211b91eb7d65", + "size_in_bytes": 937 + }, + { + "_path": "include/internal/pycore_sliceobject.h", + "path_type": "hardlink", + "sha256": "62e29d803ea3d6d5fb39bd7b9565ba1c01cbf56b174e75303fad7781b6554b69", + "size_in_bytes": 336 + }, + { + "_path": "include/internal/pycore_strhex.h", + "path_type": "hardlink", + "sha256": "45783d1137fc33a8d9e457692227e8395a93b27c76205f50ad7bd8f00fe7aefb", + "size_in_bytes": 937 + }, + { + "_path": "include/internal/pycore_structseq.h", + "path_type": "hardlink", + "sha256": "31f3fb0132dcb0e3e426bbd953c148a46c06c7ab5c17941b38ca9fefe0f6025f", + "size_in_bytes": 580 + }, + { + "_path": "include/internal/pycore_symtable.h", + "path_type": "hardlink", + "sha256": "4cae3b7fd940bd618973649b28f3d8e7b9bde3959bf91b9eb4f59f17075a01fa", + "size_in_bytes": 5638 + }, + { + "_path": "include/internal/pycore_sysmodule.h", + "path_type": "hardlink", + "sha256": "e14148da858295b073e9fde5377ead18dd04ba75b6ed108b413ad6ca71c940ad", + "size_in_bytes": 605 + }, + { + "_path": "include/internal/pycore_traceback.h", + "path_type": "hardlink", + "sha256": "3f9dfb009dc161f2d979f5af76d660611264b5d0b1b4adeeae10d30ee0999ede", + "size_in_bytes": 3501 + }, + { + "_path": "include/internal/pycore_tuple.h", + "path_type": "hardlink", + "sha256": "7ac373dd63eb6da68142ee0b4fc523471274d367a30fa70d8c311a64c0d9db5d", + "size_in_bytes": 2089 + }, + { + "_path": "include/internal/pycore_typeobject.h", + "path_type": "hardlink", + "sha256": "b1c3517b4e52b7c0079ed7719e3fe60350decf4fe2217f241c1b2bc1694ae68d", + "size_in_bytes": 1158 + }, + { + "_path": "include/internal/pycore_ucnhash.h", + "path_type": "hardlink", + "sha256": "6d9077e875703e5db7daf293a6c7ea3d43d1ee84dec137a950f17a26e9348eb5", + "size_in_bytes": 898 + }, + { + "_path": "include/internal/pycore_unicodeobject.h", + "path_type": "hardlink", + "sha256": "0f50c146e2755e5aa5db5477337d850e248ad262042afdb4fbe44fae02da81f9", + "size_in_bytes": 1716 + }, + { + "_path": "include/internal/pycore_unionobject.h", + "path_type": "hardlink", + "sha256": "13ec1ecbd06c099c0c8ecb8f110220bb4790e2493668d6453217a44f92fdcfe4", + "size_in_bytes": 678 + }, + { + "_path": "include/internal/pycore_warnings.h", + "path_type": "hardlink", + "sha256": "3229b207245cb9442f09991df7084c8e4cb87cb073a14a2d520bd92634371fcb", + "size_in_bytes": 740 + }, + { + "_path": "include/intrcheck.h", + "path_type": "hardlink", + "sha256": "696fe17618c579a8cbaad9b86175f60d43ea0b9e8aaaa1d65ad256d53dc163c1", + "size_in_bytes": 772 + }, + { + "_path": "include/iterobject.h", + "path_type": "hardlink", + "sha256": "fab74e0f2a2cd185f846ade3247b1e348b9ed5b72f875cec7ff6f90e8f167dc3", + "size_in_bytes": 593 + }, + { + "_path": "include/listobject.h", + "path_type": "hardlink", + "sha256": "21ddf0f6161c840cfa5e5dae69959147a8e149b21c25324dcda15a25472c080c", + "size_in_bytes": 1780 + }, + { + "_path": "include/longobject.h", + "path_type": "hardlink", + "sha256": "492cd8c4a560738f08c2c16c16e08baeea9da049bb8eca78d6b00d1204a27b60", + "size_in_bytes": 3736 + }, + { + "_path": "include/marshal.h", + "path_type": "hardlink", + "sha256": "d7f5760ef6496776cee99aca5491789f6ab261a78b156b5758538ea15e1827e5", + "size_in_bytes": 827 + }, + { + "_path": "include/memoryobject.h", + "path_type": "hardlink", + "sha256": "2fb32f3bea71d83752aaca4fba77acc22379c1b6d2235ea889e12bb07472800c", + "size_in_bytes": 2810 + }, + { + "_path": "include/methodobject.h", + "path_type": "hardlink", + "sha256": "776cbbdcb05998d8d6ce90dda8292fb85068536857c1ff4d374d46c48736d239", + "size_in_bytes": 5072 + }, + { + "_path": "include/modsupport.h", + "path_type": "hardlink", + "sha256": "876ebaa8ffd41d5a7498abbfc3cf3b758d94bf572a24ce1facf977b3129ed35b", + "size_in_bytes": 6541 + }, + { + "_path": "include/moduleobject.h", + "path_type": "hardlink", + "sha256": "78211effd6218657a4ede00174fa69bd07793ece986d7aad402b2472d29f76c7", + "size_in_bytes": 2374 + }, + { + "_path": "include/object.h", + "path_type": "hardlink", + "sha256": "3b7adffb2b34984d5663a363fc46ece5dfb6ab831aade93d795071077d08590c", + "size_in_bytes": 29800 + }, + { + "_path": "include/objimpl.h", + "path_type": "hardlink", + "sha256": "2d4acd73eae836fd0146c47282a9c0041643a828580eeeafe5cd06ae0b744ef1", + "size_in_bytes": 8428 + }, + { + "_path": "include/opcode.h", + "path_type": "hardlink", + "sha256": "7c57894c9118a8ca60d02d0089a33da3b5cabeb69f55e936d3abea44228f26a0", + "size_in_bytes": 11187 + }, + { + "_path": "include/osdefs.h", + "path_type": "hardlink", + "sha256": "8372e9c507949a88ed3cad5fd0a830190d60a1655e9a3f59ef4d0832c06a041c", + "size_in_bytes": 737 + }, + { + "_path": "include/osmodule.h", + "path_type": "hardlink", + "sha256": "c013935b48f48ca8ce249a4d482c55e3fb6f1cfe786c5a32a57969bb74a779d9", + "size_in_bytes": 291 + }, + { + "_path": "include/patchlevel.h", + "path_type": "hardlink", + "sha256": "0530c98356ee3f51e7506292a558c698ea658623f492527fe54caf439b8a63ad", + "size_in_bytes": 1301 + }, + { + "_path": "include/py_curses.h", + "path_type": "hardlink", + "sha256": "3eff287cd1c4224544dd8ef4b57298c9ad2dd0af25ca0294ee3b38431b8b03b4", + "size_in_bytes": 2471 + }, + { + "_path": "include/pybuffer.h", + "path_type": "hardlink", + "sha256": "8d27e9a6268bbac7d4eb596dc546cdb06ca21d35f85300c591f25060255e8e6c", + "size_in_bytes": 5115 + }, + { + "_path": "include/pycapsule.h", + "path_type": "hardlink", + "sha256": "8fed74eb81e83720caae346011dd6deedb147fd462bf94e679eac5065dfa92aa", + "size_in_bytes": 1725 + }, + { + "_path": "include/pyconfig.h", + "path_type": "hardlink", + "sha256": "9a20df57d025c8dc41bf70668ea48d266ff8b8e9c4158a88cfcaf06a45a88f5c", + "size_in_bytes": 21000 + }, + { + "_path": "include/pydtrace.d", + "path_type": "hardlink", + "sha256": "9dd7071fac51ba3a1cf21cd24183d285d46176f795fce62c3575555f10f4cad0", + "size_in_bytes": 1008 + }, + { + "_path": "include/pydtrace.h", + "path_type": "hardlink", + "sha256": "d342948372e46cb0124ba1311ce5ba9941837ac8a137a76b5a532bca03c696e8", + "size_in_bytes": 2413 + }, + { + "_path": "include/pyerrors.h", + "path_type": "hardlink", + "sha256": "dc629354f5548508a0d4cbc140a0700a7efff67c4a90627eee3b8da87812f084", + "size_in_bytes": 12782 + }, + { + "_path": "include/pyexpat.h", + "path_type": "hardlink", + "sha256": "91b3b4f199a074a44504bf914c96d5a1c525eeffd1726c218f38195979bf43fb", + "size_in_bytes": 2850 + }, + { + "_path": "include/pyframe.h", + "path_type": "hardlink", + "sha256": "58513e7017805ee5c49a329a552f72a6be6d88ce2bcfa344f5130582fa75ecb6", + "size_in_bytes": 551 + }, + { + "_path": "include/pyhash.h", + "path_type": "hardlink", + "sha256": "a6ea755ff42ec955feaf49b1d234a5c2935899309ea59925d1d30f3e62fed67d", + "size_in_bytes": 4154 + }, + { + "_path": "include/pylifecycle.h", + "path_type": "hardlink", + "sha256": "d313c5f3fe805606061ea78982ca5d5a9f09e687210c8b0fbcb50db596106691", + "size_in_bytes": 2249 + }, + { + "_path": "include/pymacconfig.h", + "path_type": "hardlink", + "sha256": "06a284cd2ccccbac21c5aa2ce5ea1d05d04a4b5e5038e5d55c7fab260ab30e2c", + "size_in_bytes": 2989 + }, + { + "_path": "include/pymacro.h", + "path_type": "hardlink", + "sha256": "8a4eee1df652eacefa61c0098b1280e7944377f05ce91b11667edf3e11d3b7f0", + "size_in_bytes": 6064 + }, + { + "_path": "include/pymath.h", + "path_type": "hardlink", + "sha256": "3251ec556f936a16aedb19efe08c53aac683ebc678a143f6183a057503dd3324", + "size_in_bytes": 1979 + }, + { + "_path": "include/pymem.h", + "path_type": "hardlink", + "sha256": "35881783332e1149da499f8efd0741fbaa8718592424e5bb9dc0b92a53895b47", + "size_in_bytes": 3890 + }, + { + "_path": "include/pyport.h", + "path_type": "hardlink", + "sha256": "f8fa1c9299295b22feae7654cdae6122a27f6db0f4eb158c53b7677105bed4f0", + "size_in_bytes": 24452 + }, + { + "_path": "include/pystate.h", + "path_type": "hardlink", + "sha256": "065426aaa5fada90d61a17757fbc2e8ce3fb9cc203992990c4ca3cee7f9f80be", + "size_in_bytes": 4635 + }, + { + "_path": "include/pystrcmp.h", + "path_type": "hardlink", + "sha256": "f401d8338fb6ecf5f12768ee95cd09c262f880b2ee522ca344b890dbdcde4c88", + "size_in_bytes": 436 + }, + { + "_path": "include/pystrtod.h", + "path_type": "hardlink", + "sha256": "8c8e9d1d279216f1c08f0aedac5de49a9b8852a3f838f21e298300e969474ef4", + "size_in_bytes": 1557 + }, + { + "_path": "include/pythonrun.h", + "path_type": "hardlink", + "sha256": "83a9561503b277834bc57fa1955d552b1f4da3b892e44a47ca3ecbc461277d0d", + "size_in_bytes": 1189 + }, + { + "_path": "include/pythread.h", + "path_type": "hardlink", + "sha256": "d397980529d640fbeea0d7ab0266ba51b1adf3ac8415340ba541dbd00bfb542d", + "size_in_bytes": 4833 + }, + { + "_path": "include/pytypedefs.h", + "path_type": "hardlink", + "sha256": "26d09a78c44998e8c0a74ed2d14e5346e4b922892eb79288049b7ac5b6a1e751", + "size_in_bytes": 851 + }, + { + "_path": "include/rangeobject.h", + "path_type": "hardlink", + "sha256": "eb9bbb31cf628ffa8c4452aa7d136941b3e93e43e04d44b51c68ba0b16d56381", + "size_in_bytes": 628 + }, + { + "_path": "include/setobject.h", + "path_type": "hardlink", + "sha256": "ba584a42f8d9e74fedb333506ced21eae18803a95588ee5c2a92202776e68602", + "size_in_bytes": 1543 + }, + { + "_path": "include/sliceobject.h", + "path_type": "hardlink", + "sha256": "3215a02de59673a950b8941a0224474cf0bcb62f617d9afc402f1e17713f9c28", + "size_in_bytes": 2516 + }, + { + "_path": "include/structmember.h", + "path_type": "hardlink", + "sha256": "24a83952ae37457df88dddcb824320c43e3d25fc3d8b0977eeef228f6be79144", + "size_in_bytes": 2040 + }, + { + "_path": "include/structseq.h", + "path_type": "hardlink", + "sha256": "d138e422358e4221e60e7fd0ec0f13ed7b93adada26a4e162d7424a8ddef5110", + "size_in_bytes": 1388 + }, + { + "_path": "include/sysmodule.h", + "path_type": "hardlink", + "sha256": "b460ed4c24ab3f2e3ef31f811982aa859071e2b39c390e203ed223aa34ff6ad1", + "size_in_bytes": 1381 + }, + { + "_path": "include/token.h", + "path_type": "hardlink", + "sha256": "754b9f53780c030f72b1d0ac10f13b89d0da1ad955c07c4eb3bcbc3406347b02", + "size_in_bytes": 2669 + }, + { + "_path": "include/traceback.h", + "path_type": "hardlink", + "sha256": "480c9d1ee9e338660a1e1671c5b530029b96fdbf4653b3cffd129db20b51769b", + "size_in_bytes": 583 + }, + { + "_path": "include/tracemalloc.h", + "path_type": "hardlink", + "sha256": "0e5e535fbb5e66400b4dcb3d404ff532971ae964b4a11ac4abb6d73991ad24fe", + "size_in_bytes": 1114 + }, + { + "_path": "include/tupleobject.h", + "path_type": "hardlink", + "sha256": "37d034dcd5a4181ba5202ecb311fe4cf3d1675e83daf35a1e74416ab8e2f4c78", + "size_in_bytes": 1613 + }, + { + "_path": "include/typeslots.h", + "path_type": "hardlink", + "sha256": "77fe4a71f5e5974c40fd3485d3c9aeb8b7ccf33969cd26feb58c64eda5f86f1d", + "size_in_bytes": 2342 + }, + { + "_path": "include/unicodeobject.h", + "path_type": "hardlink", + "sha256": "204eafc767ea9396d319b0897a55b67738ddf33659a63b0701941afaab330a86", + "size_in_bytes": 36032 + }, + { + "_path": "include/warnings.h", + "path_type": "hardlink", + "sha256": "18fde34b12247460de805fc259ea7f14305fce4779d244c0a7bdc7c73b8f6b51", + "size_in_bytes": 1129 + }, + { + "_path": "include/weakrefobject.h", + "path_type": "hardlink", + "sha256": "14b445d05b36d90484001a133a0ed41f2336979e2d4ae2bb5cd5084545285a8c", + "size_in_bytes": 1226 + }, + { + "_path": "libs/_tkinter.lib", + "path_type": "hardlink", + "sha256": "edcb24a3a2ce97d26fcbe90bce7051d9a4717f140e1839c93f59344e61436ee4", + "size_in_bytes": 1750 + }, + { + "_path": "libs/python3.lib", + "path_type": "hardlink", + "sha256": "b806528399141e8016fb0f035fc139f06cb90a49bc2f623950a2e8227efd01e1", + "size_in_bytes": 183544 + }, + { + "_path": "libs/python311.lib", + "path_type": "hardlink", + "sha256": "488e97b1344d40181e99c27bcec2c0814f271ef4d9fed7fee773cf3cf0926442", + "size_in_bytes": 361192 + }, + { + "_path": "python.exe", + "path_type": "hardlink", + "sha256": "5ce9617b7b1f66b1b967e28d543cc7b9e589860fe997dff11401688ff2be87e6", + "size_in_bytes": 93184 + }, + { + "_path": "python.pdb", + "file_mode": "binary", + "path_type": "hardlink", + "prefix_placeholder": "D:\\bld\\python-split_1772728140663\\_h_env", + "sha256": "0e508dc580be9b440b496db7e1b15c8c350ded451a668b9e9abf49266f53397d", + "size_in_bytes": 544768 + }, + { + "_path": "python3.dll", + "path_type": "hardlink", + "sha256": "848161affae410e91960e8547488b436aa1de72ba28a533a8158371bcb381e35", + "size_in_bytes": 55296 + }, + { + "_path": "python311.dll", + "path_type": "hardlink", + "sha256": "f97cf1ad8d02b04d28c7e5b7824a6b8473474bd53312fde12cd254b5187a8574", + "size_in_bytes": 6193664 + }, + { + "_path": "python311.pdb", + "file_mode": "binary", + "path_type": "hardlink", + "prefix_placeholder": "D:\\bld\\python-split_1772728140663\\_h_env", + "sha256": "0486fe1ead0e28b579c63babcbc48d6ca4dbfe1cf5e869d339ca0d4c15b17680", + "size_in_bytes": 17068032 + }, + { + "_path": "pythonw.exe", + "path_type": "hardlink", + "sha256": "a6c79ff381a2c5a14e7652bd5d29769989035dd399200c14bf036dcca1b5a6fc", + "size_in_bytes": 91648 + }, + { + "_path": "pythonw.pdb", + "file_mode": "binary", + "path_type": "hardlink", + "prefix_placeholder": "D:\\bld\\python-split_1772728140663\\_h_env", + "sha256": "471da840b31d661699b6e41486af37b81b9a6dba4e1bae1a6d72d92e695a153d", + "size_in_bytes": 561152 + } + ], + "paths_version": 1 +} \ No newline at end of file diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_asyncio.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_asyncio.pyd new file mode 100644 index 0000000000000000000000000000000000000000..1048810c15418171585fd87108763afd0669d181 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_asyncio.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_bz2.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_bz2.pyd new file mode 100644 index 0000000000000000000000000000000000000000..a393e8344e6df88fa8f5192b4bd599b48c628431 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_bz2.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_elementtree.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_elementtree.pyd new file mode 100644 index 0000000000000000000000000000000000000000..6520946de4404cccdbe1f3a813052c99fa190918 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_elementtree.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_hashlib.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_hashlib.pyd new file mode 100644 index 0000000000000000000000000000000000000000..faf41fb91fe2d1daf54f9723d1dfcbce0e377f95 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_hashlib.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_lzma.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_lzma.pyd new file mode 100644 index 0000000000000000000000000000000000000000..a0adec45fbe99c49f0c388bb978936728587fa5f Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_lzma.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_multiprocessing.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_multiprocessing.pyd new file mode 100644 index 0000000000000000000000000000000000000000..b783e9d5f93d52441f248dcc26e2d14fc41037b7 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_multiprocessing.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_overlapped.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_overlapped.pyd new file mode 100644 index 0000000000000000000000000000000000000000..3d7a8313692f12803dd5e7d524d2528f3200014e Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_overlapped.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_queue.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_queue.pyd new file mode 100644 index 0000000000000000000000000000000000000000..aa61fe50a9fcaffdfb03408088374f5afccd71ae Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_queue.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_remote_debugging.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_remote_debugging.pyd new file mode 100644 index 0000000000000000000000000000000000000000..3ab37874298cab5c5a66775fcd6db6b8a2ec7113 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_remote_debugging.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_socket.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_socket.pyd new file mode 100644 index 0000000000000000000000000000000000000000..7ac74ece77fe7dfb154dcdf8c0be483b756ce8cc Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_socket.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testbuffer.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testbuffer.pyd new file mode 100644 index 0000000000000000000000000000000000000000..b9708042d557ccd0ad65452900fbfea32c6d3f05 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testbuffer.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testclinic.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testclinic.pyd new file mode 100644 index 0000000000000000000000000000000000000000..1679020bdb46f2885b72cb00f4112ec94cad5fee Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testclinic.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testclinic_limited.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testclinic_limited.pyd new file mode 100644 index 0000000000000000000000000000000000000000..aad2269c838cecee1e453dad8deb952a42a382fc Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testclinic_limited.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testconsole.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testconsole.pyd new file mode 100644 index 0000000000000000000000000000000000000000..328d243841b02560bcce1a49ed3aa8a9fe8258d2 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testconsole.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testimportmultiple.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testimportmultiple.pyd new file mode 100644 index 0000000000000000000000000000000000000000..01226444528d64a2a03eb3ebd8761bdda59b9197 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testimportmultiple.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testinternalcapi.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testinternalcapi.pyd new file mode 100644 index 0000000000000000000000000000000000000000..ad15ba661ebae48c96ef8f9f83065571791f8b0a Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testinternalcapi.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testmultiphase.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testmultiphase.pyd new file mode 100644 index 0000000000000000000000000000000000000000..c5732ae7c988fba2f1f972a8cc0114b0ca657426 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testmultiphase.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testsinglephase.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testsinglephase.pyd new file mode 100644 index 0000000000000000000000000000000000000000..7864af6afc71ea8f437f23cb8fc56061d67f9f15 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_testsinglephase.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_tkinter.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_tkinter.pyd new file mode 100644 index 0000000000000000000000000000000000000000..914f819cecf6fb9f545c4ec12c72ac678fa0c9a7 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_tkinter.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_uuid.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_uuid.pyd new file mode 100644 index 0000000000000000000000000000000000000000..32a84f4ec85fcd832d652efb376bf4262e1fc52b Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_uuid.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_wmi.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_wmi.pyd new file mode 100644 index 0000000000000000000000000000000000000000..324db0b4c6b7143212e78a4f81ab099631d8dbba Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_wmi.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_zoneinfo.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_zoneinfo.pyd new file mode 100644 index 0000000000000000000000000000000000000000..92f492fa71655ef4312ab4a3cf6ae2841056f232 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_zoneinfo.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_zstd.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_zstd.pyd new file mode 100644 index 0000000000000000000000000000000000000000..293a7312b23cbe089eab76ef867a0b6a0508cdef Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/_zstd.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/pyexpat.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/pyexpat.pyd new file mode 100644 index 0000000000000000000000000000000000000000..df1c42cf5c6432cc5b2321659aae2a1122fbd281 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/pyexpat.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/select.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/select.pyd new file mode 100644 index 0000000000000000000000000000000000000000..f86541ea1ccb0874cbac913240893c51bc8247b4 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/select.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/winsound.pyd b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/winsound.pyd new file mode 100644 index 0000000000000000000000000000000000000000..083c387d61f17afb75aa837cc0d72be9c3be149d Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/DLLs/instrumented/winsound.pyd differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/__init__.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/__init__.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..abd9c8aca7e4b6c5a7213292c52480b4beffdeb2 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/__init__.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/__main__.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/__main__.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ea6cc25354a93d920a4d668999a5fec4b0bf041b Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/__main__.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/base_events.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/base_events.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e68d4dd48bccc3f1a31f86e6c6526aac8a75a651 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/base_events.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/base_futures.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/base_futures.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c85d6564252fd1577ad765b72d345cdf7e242570 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/base_futures.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/base_subprocess.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/base_subprocess.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..11d832f89a0ebf99a62bc216b16561e15cc43cd8 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/base_subprocess.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/base_tasks.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/base_tasks.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..95fc66370174cc403b87d22b5ef6a8d5d92aac69 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/base_tasks.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/constants.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/constants.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9b24b1312a15ef395131a1cdd755280312614a49 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/constants.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/coroutines.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/coroutines.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..834f470bfa78f225e8154b9fd6bb8a3cfad366f7 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/coroutines.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/events.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/events.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8340158e5bc22526f3313094a9ddbdcfecc9f730 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/events.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/exceptions.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/exceptions.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0e321307eed880f8ee005e1f70353e461567b29a Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/exceptions.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/format_helpers.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/format_helpers.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..013aa950790cf0cf8c2ad70910409216efca5c85 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/format_helpers.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/futures.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/futures.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ecd355d705d0ea45f4b0864bece7d22f3d5eb466 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/futures.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/graph.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/graph.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6b29ccf578992e485fc563ba00baac5fc6a5ab08 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/graph.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/locks.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/locks.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..786d65bf6cf23bda16cdab6057040faf65f1e43e Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/locks.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/log.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/log.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0c708efb29dc3d4e0b39151a61a33788fc8262f3 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/log.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/mixins.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/mixins.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0174cbc043af2cd230dcd76b982848d7760c53ff Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/mixins.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/proactor_events.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/proactor_events.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8e6f5b4681cfcc1f2cc407be4ff827749a0a31a6 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/proactor_events.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/protocols.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/protocols.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7568150e4b4a6c0daea52100c879cfd1d7cab63a Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/protocols.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/queues.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/queues.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..618905ab2723735b98278fd0d26c6de31061b7e1 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/queues.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/runners.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/runners.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3b7caabe89bd7a1be7e730250b8055266393dfa7 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/runners.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/selector_events.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/selector_events.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..076670ae2e71b3907a0fed433134403842fbb28c Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/selector_events.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/sslproto.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/sslproto.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..43f67445d00071611064ec05c2b64ecda9b4cead Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/sslproto.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/staggered.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/staggered.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..df2ee600d25180447cdd539073c13ecfa09d7d59 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/staggered.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/streams.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/streams.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2255e09901aa57f3fb75bdc6b59e55734ae87c9b Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/streams.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/subprocess.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/subprocess.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f6e7c5fa886519ee1fc00184acb5e26635443a28 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/subprocess.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/taskgroups.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/taskgroups.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..870ff2ecd6de1c849e24d81aedbf98ad1ece44ab Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/taskgroups.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/tasks.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/tasks.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ee40cb8a1781676d58fdc268eb31dcf1fbd19f63 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/tasks.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/threads.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/threads.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..197a4a0afc529ed397232e80de501b4aed189d14 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/threads.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/timeouts.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/timeouts.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c69813f70c06cfb966320d38400f4aa9bb0e08c7 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/timeouts.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/tools.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/tools.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cba80b347fd07d1edf5ced8f368c5c1e6da25dd2 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/tools.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/transports.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/transports.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..649b20d5e270291574e3546ead204feeaabc3ca7 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/transports.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/trsock.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/trsock.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b05e431a10ea7a143ae323704e077fc655b99b38 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/trsock.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/unix_events.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/unix_events.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5c09e290c78d1a9737814b7a27917fc6001967c9 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/unix_events.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/windows_events.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/windows_events.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d5202abd10a702c4963deda13f582cca86f48f80 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/windows_events.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/windows_utils.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/windows_utils.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..634e4dfe9848d178f200ee9f034b0dae6a2ae983 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/asyncio/__pycache__/windows_utils.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/collections/__pycache__/__init__.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/collections/__pycache__/__init__.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8e66bcfc47f4b533b1a67b25bf9bf7f2bdeea7d0 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/collections/__pycache__/__init__.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/__pycache__/__init__.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/__pycache__/__init__.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..250de8fbc33886e3c3b7b08abf164ebd03e5a6e6 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/__pycache__/__init__.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/__pycache__/bz2.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/__pycache__/bz2.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2cf037436645283b51d76b465dad0e37c28a04f7 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/__pycache__/bz2.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/__pycache__/gzip.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/__pycache__/gzip.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eb571e1a1e8fa72f4a4f8ae32f4816ad76b3313c Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/__pycache__/gzip.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/__pycache__/lzma.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/__pycache__/lzma.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..833bab409c0059e8cb0b647d0851cb6f50cf0c24 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/__pycache__/lzma.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/__pycache__/zlib.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/__pycache__/zlib.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aff18a028391efcddb93884c91e31a6203b97121 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/__pycache__/zlib.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/_common/__init__.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/_common/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/_common/__pycache__/__init__.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/_common/__pycache__/__init__.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d76e27c8bdad34ee469229e175e7a07f97763e01 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/_common/__pycache__/__init__.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/_common/__pycache__/_streams.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/_common/__pycache__/_streams.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f60cb1efc66f078640487114751b671f1f5f8019 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/_common/__pycache__/_streams.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/_common/_streams.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/_common/_streams.py new file mode 100644 index 0000000000000000000000000000000000000000..9f367d4e30440f75d9a32c035713b281f3fbb26a --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/_common/_streams.py @@ -0,0 +1,162 @@ +"""Internal classes used by compression modules""" + +import io +import sys + +BUFFER_SIZE = io.DEFAULT_BUFFER_SIZE # Compressed data read chunk size + + +class BaseStream(io.BufferedIOBase): + """Mode-checking helper functions.""" + + def _check_not_closed(self): + if self.closed: + raise ValueError("I/O operation on closed file") + + def _check_can_read(self): + if not self.readable(): + raise io.UnsupportedOperation("File not open for reading") + + def _check_can_write(self): + if not self.writable(): + raise io.UnsupportedOperation("File not open for writing") + + def _check_can_seek(self): + if not self.readable(): + raise io.UnsupportedOperation("Seeking is only supported " + "on files open for reading") + if not self.seekable(): + raise io.UnsupportedOperation("The underlying file object " + "does not support seeking") + + +class DecompressReader(io.RawIOBase): + """Adapts the decompressor API to a RawIOBase reader API""" + + def readable(self): + return True + + def __init__(self, fp, decomp_factory, trailing_error=(), **decomp_args): + self._fp = fp + self._eof = False + self._pos = 0 # Current offset in decompressed stream + + # Set to size of decompressed stream once it is known, for SEEK_END + self._size = -1 + + # Save the decompressor factory and arguments. + # If the file contains multiple compressed streams, each + # stream will need a separate decompressor object. A new decompressor + # object is also needed when implementing a backwards seek(). + self._decomp_factory = decomp_factory + self._decomp_args = decomp_args + self._decompressor = self._decomp_factory(**self._decomp_args) + + # Exception class to catch from decompressor signifying invalid + # trailing data to ignore + self._trailing_error = trailing_error + + def close(self): + self._decompressor = None + return super().close() + + def seekable(self): + return self._fp.seekable() + + def readinto(self, b): + with memoryview(b) as view, view.cast("B") as byte_view: + data = self.read(len(byte_view)) + byte_view[:len(data)] = data + return len(data) + + def read(self, size=-1): + if size < 0: + return self.readall() + + if not size or self._eof: + return b"" + data = None # Default if EOF is encountered + # Depending on the input data, our call to the decompressor may not + # return any data. In this case, try again after reading another block. + while True: + if self._decompressor.eof: + rawblock = (self._decompressor.unused_data or + self._fp.read(BUFFER_SIZE)) + if not rawblock: + break + # Continue to next stream. + self._decompressor = self._decomp_factory( + **self._decomp_args) + try: + data = self._decompressor.decompress(rawblock, size) + except self._trailing_error: + # Trailing data isn't a valid compressed stream; ignore it. + break + else: + if self._decompressor.needs_input: + rawblock = self._fp.read(BUFFER_SIZE) + if not rawblock: + raise EOFError("Compressed file ended before the " + "end-of-stream marker was reached") + else: + rawblock = b"" + data = self._decompressor.decompress(rawblock, size) + if data: + break + if not data: + self._eof = True + self._size = self._pos + return b"" + self._pos += len(data) + return data + + def readall(self): + chunks = [] + # sys.maxsize means the max length of output buffer is unlimited, + # so that the whole input buffer can be decompressed within one + # .decompress() call. + while data := self.read(sys.maxsize): + chunks.append(data) + + return b"".join(chunks) + + # Rewind the file to the beginning of the data stream. + def _rewind(self): + self._fp.seek(0) + self._eof = False + self._pos = 0 + self._decompressor = self._decomp_factory(**self._decomp_args) + + def seek(self, offset, whence=io.SEEK_SET): + # Recalculate offset as an absolute file position. + if whence == io.SEEK_SET: + pass + elif whence == io.SEEK_CUR: + offset = self._pos + offset + elif whence == io.SEEK_END: + # Seeking relative to EOF - we need to know the file's size. + if self._size < 0: + while self.read(io.DEFAULT_BUFFER_SIZE): + pass + offset = self._size + offset + else: + raise ValueError("Invalid value for whence: {}".format(whence)) + + # Make it so that offset is the number of bytes to skip forward. + if offset < self._pos: + self._rewind() + else: + offset -= self._pos + + # Read and discard data until we reach the desired position. + while offset > 0: + data = self.read(min(io.DEFAULT_BUFFER_SIZE, offset)) + if not data: + break + offset -= len(data) + + return self._pos + + def tell(self): + """Return the current file position.""" + return self._pos diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/zstd/__init__.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/zstd/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..84b25914b0aa93a6c0f0aba6dc02bc8be077ece5 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/zstd/__init__.py @@ -0,0 +1,242 @@ +"""Python bindings to the Zstandard (zstd) compression library (RFC-8878).""" + +__all__ = ( + # compression.zstd + 'COMPRESSION_LEVEL_DEFAULT', + 'compress', + 'CompressionParameter', + 'decompress', + 'DecompressionParameter', + 'finalize_dict', + 'get_frame_info', + 'Strategy', + 'train_dict', + + # compression.zstd._zstdfile + 'open', + 'ZstdFile', + + # _zstd + 'get_frame_size', + 'zstd_version', + 'zstd_version_info', + 'ZstdCompressor', + 'ZstdDecompressor', + 'ZstdDict', + 'ZstdError', +) + +import _zstd +import enum +from _zstd import (ZstdCompressor, ZstdDecompressor, ZstdDict, ZstdError, + get_frame_size, zstd_version) +from compression.zstd._zstdfile import ZstdFile, open, _nbytes + +# zstd_version_number is (MAJOR * 100 * 100 + MINOR * 100 + RELEASE) +zstd_version_info = (*divmod(_zstd.zstd_version_number // 100, 100), + _zstd.zstd_version_number % 100) +"""Version number of the runtime zstd library as a tuple of integers.""" + +COMPRESSION_LEVEL_DEFAULT = _zstd.ZSTD_CLEVEL_DEFAULT +"""The default compression level for Zstandard, currently '3'.""" + + +class FrameInfo: + """Information about a Zstandard frame.""" + + __slots__ = 'decompressed_size', 'dictionary_id' + + def __init__(self, decompressed_size, dictionary_id): + super().__setattr__('decompressed_size', decompressed_size) + super().__setattr__('dictionary_id', dictionary_id) + + def __repr__(self): + return (f'FrameInfo(decompressed_size={self.decompressed_size}, ' + f'dictionary_id={self.dictionary_id})') + + def __setattr__(self, name, _): + raise AttributeError(f"can't set attribute {name!r}") + + +def get_frame_info(frame_buffer): + """Get Zstandard frame information from a frame header. + + *frame_buffer* is a bytes-like object. It should start from the beginning + of a frame, and needs to include at least the frame header (6 to 18 bytes). + + The returned FrameInfo object has two attributes. + 'decompressed_size' is the size in bytes of the data in the frame when + decompressed, or None when the decompressed size is unknown. + 'dictionary_id' is an int in the range (0, 2**32). The special value 0 + means that the dictionary ID was not recorded in the frame header, + the frame may or may not need a dictionary to be decoded, + and the ID of such a dictionary is not specified. + """ + return FrameInfo(*_zstd.get_frame_info(frame_buffer)) + + +def train_dict(samples, dict_size): + """Return a ZstdDict representing a trained Zstandard dictionary. + + *samples* is an iterable of samples, where a sample is a bytes-like + object representing a file. + + *dict_size* is the dictionary's maximum size, in bytes. + """ + if not isinstance(dict_size, int): + ds_cls = type(dict_size).__qualname__ + raise TypeError(f'dict_size must be an int object, not {ds_cls!r}.') + + samples = tuple(samples) + chunks = b''.join(samples) + chunk_sizes = tuple(_nbytes(sample) for sample in samples) + if not chunks: + raise ValueError("samples contained no data; can't train dictionary.") + dict_content = _zstd.train_dict(chunks, chunk_sizes, dict_size) + return ZstdDict(dict_content) + + +def finalize_dict(zstd_dict, /, samples, dict_size, level): + """Return a ZstdDict representing a finalized Zstandard dictionary. + + Given a custom content as a basis for dictionary, and a set of samples, + finalize *zstd_dict* by adding headers and statistics according to the + Zstandard dictionary format. + + You may compose an effective dictionary content by hand, which is used as + basis dictionary, and use some samples to finalize a dictionary. The basis + dictionary may be a "raw content" dictionary. See *is_raw* in ZstdDict. + + *samples* is an iterable of samples, where a sample is a bytes-like object + representing a file. + *dict_size* is the dictionary's maximum size, in bytes. + *level* is the expected compression level. The statistics for each + compression level differ, so tuning the dictionary to the compression level + can provide improvements. + """ + + if not isinstance(zstd_dict, ZstdDict): + raise TypeError('zstd_dict argument should be a ZstdDict object.') + if not isinstance(dict_size, int): + raise TypeError('dict_size argument should be an int object.') + if not isinstance(level, int): + raise TypeError('level argument should be an int object.') + + samples = tuple(samples) + chunks = b''.join(samples) + chunk_sizes = tuple(_nbytes(sample) for sample in samples) + if not chunks: + raise ValueError("The samples are empty content, can't finalize the " + "dictionary.") + dict_content = _zstd.finalize_dict(zstd_dict.dict_content, chunks, + chunk_sizes, dict_size, level) + return ZstdDict(dict_content) + + +def compress(data, level=None, options=None, zstd_dict=None): + """Return Zstandard compressed *data* as bytes. + + *level* is an int specifying the compression level to use, defaulting to + COMPRESSION_LEVEL_DEFAULT ('3'). + *options* is a dict object that contains advanced compression + parameters. See CompressionParameter for more on options. + *zstd_dict* is a ZstdDict object, a pre-trained Zstandard dictionary. See + the function train_dict for how to train a ZstdDict on sample data. + + For incremental compression, use a ZstdCompressor instead. + """ + comp = ZstdCompressor(level=level, options=options, zstd_dict=zstd_dict) + return comp.compress(data, mode=ZstdCompressor.FLUSH_FRAME) + + +def decompress(data, zstd_dict=None, options=None): + """Decompress one or more frames of Zstandard compressed *data*. + + *zstd_dict* is a ZstdDict object, a pre-trained Zstandard dictionary. See + the function train_dict for how to train a ZstdDict on sample data. + *options* is a dict object that contains advanced compression + parameters. See DecompressionParameter for more on options. + + For incremental decompression, use a ZstdDecompressor instead. + """ + results = [] + while True: + decomp = ZstdDecompressor(options=options, zstd_dict=zstd_dict) + results.append(decomp.decompress(data)) + if not decomp.eof: + raise ZstdError('Compressed data ended before the ' + 'end-of-stream marker was reached') + data = decomp.unused_data + if not data: + break + return b''.join(results) + + +class CompressionParameter(enum.IntEnum): + """Compression parameters.""" + + compression_level = _zstd.ZSTD_c_compressionLevel + window_log = _zstd.ZSTD_c_windowLog + hash_log = _zstd.ZSTD_c_hashLog + chain_log = _zstd.ZSTD_c_chainLog + search_log = _zstd.ZSTD_c_searchLog + min_match = _zstd.ZSTD_c_minMatch + target_length = _zstd.ZSTD_c_targetLength + strategy = _zstd.ZSTD_c_strategy + + enable_long_distance_matching = _zstd.ZSTD_c_enableLongDistanceMatching + ldm_hash_log = _zstd.ZSTD_c_ldmHashLog + ldm_min_match = _zstd.ZSTD_c_ldmMinMatch + ldm_bucket_size_log = _zstd.ZSTD_c_ldmBucketSizeLog + ldm_hash_rate_log = _zstd.ZSTD_c_ldmHashRateLog + + content_size_flag = _zstd.ZSTD_c_contentSizeFlag + checksum_flag = _zstd.ZSTD_c_checksumFlag + dict_id_flag = _zstd.ZSTD_c_dictIDFlag + + nb_workers = _zstd.ZSTD_c_nbWorkers + job_size = _zstd.ZSTD_c_jobSize + overlap_log = _zstd.ZSTD_c_overlapLog + + def bounds(self): + """Return the (lower, upper) int bounds of a compression parameter. + + Both the lower and upper bounds are inclusive. + """ + return _zstd.get_param_bounds(self.value, is_compress=True) + + +class DecompressionParameter(enum.IntEnum): + """Decompression parameters.""" + + window_log_max = _zstd.ZSTD_d_windowLogMax + + def bounds(self): + """Return the (lower, upper) int bounds of a decompression parameter. + + Both the lower and upper bounds are inclusive. + """ + return _zstd.get_param_bounds(self.value, is_compress=False) + + +class Strategy(enum.IntEnum): + """Compression strategies, listed from fastest to strongest. + + Note that new strategies might be added in the future. + Only the order (from fast to strong) is guaranteed, + the numeric value might change. + """ + + fast = _zstd.ZSTD_fast + dfast = _zstd.ZSTD_dfast + greedy = _zstd.ZSTD_greedy + lazy = _zstd.ZSTD_lazy + lazy2 = _zstd.ZSTD_lazy2 + btlazy2 = _zstd.ZSTD_btlazy2 + btopt = _zstd.ZSTD_btopt + btultra = _zstd.ZSTD_btultra + btultra2 = _zstd.ZSTD_btultra2 + + +# Check validity of the CompressionParameter & DecompressionParameter types +_zstd.set_parameter_types(CompressionParameter, DecompressionParameter) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/zstd/__pycache__/__init__.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/zstd/__pycache__/__init__.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..79196e928d6aa205b2e104a7f80857dab5c46254 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/zstd/__pycache__/__init__.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/zstd/__pycache__/_zstdfile.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/zstd/__pycache__/_zstdfile.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..99d78a79e126ec5c029c3c3c5686c21cbc5972b6 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/zstd/__pycache__/_zstdfile.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/zstd/_zstdfile.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/zstd/_zstdfile.py new file mode 100644 index 0000000000000000000000000000000000000000..d709f5efc658fa45aaba751081781ceee8a69b3b --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/compression/zstd/_zstdfile.py @@ -0,0 +1,345 @@ +import io +from os import PathLike +from _zstd import ZstdCompressor, ZstdDecompressor, ZSTD_DStreamOutSize +from compression._common import _streams + +__all__ = ('ZstdFile', 'open') + +_MODE_CLOSED = 0 +_MODE_READ = 1 +_MODE_WRITE = 2 + + +def _nbytes(dat, /): + if isinstance(dat, (bytes, bytearray)): + return len(dat) + with memoryview(dat) as mv: + return mv.nbytes + + +class ZstdFile(_streams.BaseStream): + """A file-like object providing transparent Zstandard (de)compression. + + A ZstdFile can act as a wrapper for an existing file object, or refer + directly to a named file on disk. + + ZstdFile provides a *binary* file interface. Data is read and returned as + bytes, and may only be written to objects that support the Buffer Protocol. + """ + + FLUSH_BLOCK = ZstdCompressor.FLUSH_BLOCK + FLUSH_FRAME = ZstdCompressor.FLUSH_FRAME + + def __init__(self, file, /, mode='r', *, + level=None, options=None, zstd_dict=None): + """Open a Zstandard compressed file in binary mode. + + *file* can be either an file-like object, or a file name to open. + + *mode* can be 'r' for reading (default), 'w' for (over)writing, 'x' for + creating exclusively, or 'a' for appending. These can equivalently be + given as 'rb', 'wb', 'xb' and 'ab' respectively. + + *level* is an optional int specifying the compression level to use, + or COMPRESSION_LEVEL_DEFAULT if not given. + + *options* is an optional dict for advanced compression parameters. + See CompressionParameter and DecompressionParameter for the possible + options. + + *zstd_dict* is an optional ZstdDict object, a pre-trained Zstandard + dictionary. See train_dict() to train ZstdDict on sample data. + """ + self._fp = None + self._close_fp = False + self._mode = _MODE_CLOSED + self._buffer = None + + if not isinstance(mode, str): + raise ValueError('mode must be a str') + if options is not None and not isinstance(options, dict): + raise TypeError('options must be a dict or None') + mode = mode.removesuffix('b') # handle rb, wb, xb, ab + if mode == 'r': + if level is not None: + raise TypeError('level is illegal in read mode') + self._mode = _MODE_READ + elif mode in {'w', 'a', 'x'}: + if level is not None and not isinstance(level, int): + raise TypeError('level must be int or None') + self._mode = _MODE_WRITE + self._compressor = ZstdCompressor(level=level, options=options, + zstd_dict=zstd_dict) + self._pos = 0 + else: + raise ValueError(f'Invalid mode: {mode!r}') + + if isinstance(file, (str, bytes, PathLike)): + self._fp = io.open(file, f'{mode}b') + self._close_fp = True + elif ((mode == 'r' and hasattr(file, 'read')) + or (mode != 'r' and hasattr(file, 'write'))): + self._fp = file + else: + raise TypeError('file must be a file-like object ' + 'or a str, bytes, or PathLike object') + + if self._mode == _MODE_READ: + raw = _streams.DecompressReader( + self._fp, + ZstdDecompressor, + zstd_dict=zstd_dict, + options=options, + ) + self._buffer = io.BufferedReader(raw) + + def close(self): + """Flush and close the file. + + May be called multiple times. Once the file has been closed, + any other operation on it will raise ValueError. + """ + if self._fp is None: + return + try: + if self._mode == _MODE_READ: + if getattr(self, '_buffer', None): + self._buffer.close() + self._buffer = None + elif self._mode == _MODE_WRITE: + self.flush(self.FLUSH_FRAME) + self._compressor = None + finally: + self._mode = _MODE_CLOSED + try: + if self._close_fp: + self._fp.close() + finally: + self._fp = None + self._close_fp = False + + def write(self, data, /): + """Write a bytes-like object *data* to the file. + + Returns the number of uncompressed bytes written, which is + always the length of data in bytes. Note that due to buffering, + the file on disk may not reflect the data written until .flush() + or .close() is called. + """ + self._check_can_write() + + length = _nbytes(data) + + compressed = self._compressor.compress(data) + self._fp.write(compressed) + self._pos += length + return length + + def flush(self, mode=FLUSH_BLOCK): + """Flush remaining data to the underlying stream. + + The mode argument can be FLUSH_BLOCK or FLUSH_FRAME. Abuse of this + method will reduce compression ratio, use it only when necessary. + + If the program is interrupted afterwards, all data can be recovered. + To ensure saving to disk, also need to use os.fsync(fd). + + This method does nothing in reading mode. + """ + if self._mode == _MODE_READ: + return + self._check_not_closed() + if mode not in {self.FLUSH_BLOCK, self.FLUSH_FRAME}: + raise ValueError('Invalid mode argument, expected either ' + 'ZstdFile.FLUSH_FRAME or ' + 'ZstdFile.FLUSH_BLOCK') + if self._compressor.last_mode == mode: + return + # Flush zstd block/frame, and write. + data = self._compressor.flush(mode) + self._fp.write(data) + if hasattr(self._fp, 'flush'): + self._fp.flush() + + def read(self, size=-1): + """Read up to size uncompressed bytes from the file. + + If size is negative or omitted, read until EOF is reached. + Returns b'' if the file is already at EOF. + """ + if size is None: + size = -1 + self._check_can_read() + return self._buffer.read(size) + + def read1(self, size=-1): + """Read up to size uncompressed bytes, while trying to avoid + making multiple reads from the underlying stream. Reads up to a + buffer's worth of data if size is negative. + + Returns b'' if the file is at EOF. + """ + self._check_can_read() + if size < 0: + # Note this should *not* be io.DEFAULT_BUFFER_SIZE. + # ZSTD_DStreamOutSize is the minimum amount to read guaranteeing + # a full block is read. + size = ZSTD_DStreamOutSize + return self._buffer.read1(size) + + def readinto(self, b): + """Read bytes into b. + + Returns the number of bytes read (0 for EOF). + """ + self._check_can_read() + return self._buffer.readinto(b) + + def readinto1(self, b): + """Read bytes into b, while trying to avoid making multiple reads + from the underlying stream. + + Returns the number of bytes read (0 for EOF). + """ + self._check_can_read() + return self._buffer.readinto1(b) + + def readline(self, size=-1): + """Read a line of uncompressed bytes from the file. + + The terminating newline (if present) is retained. If size is + non-negative, no more than size bytes will be read (in which + case the line may be incomplete). Returns b'' if already at EOF. + """ + self._check_can_read() + return self._buffer.readline(size) + + def seek(self, offset, whence=io.SEEK_SET): + """Change the file position. + + The new position is specified by offset, relative to the + position indicated by whence. Possible values for whence are: + + 0: start of stream (default): offset must not be negative + 1: current stream position + 2: end of stream; offset must not be positive + + Returns the new file position. + + Note that seeking is emulated, so depending on the arguments, + this operation may be extremely slow. + """ + self._check_can_read() + + # BufferedReader.seek() checks seekable + return self._buffer.seek(offset, whence) + + def peek(self, size=-1): + """Return buffered data without advancing the file position. + + Always returns at least one byte of data, unless at EOF. + The exact number of bytes returned is unspecified. + """ + # Relies on the undocumented fact that BufferedReader.peek() always + # returns at least one byte (except at EOF) + self._check_can_read() + return self._buffer.peek(size) + + def __next__(self): + if ret := self._buffer.readline(): + return ret + raise StopIteration + + def tell(self): + """Return the current file position.""" + self._check_not_closed() + if self._mode == _MODE_READ: + return self._buffer.tell() + elif self._mode == _MODE_WRITE: + return self._pos + + def fileno(self): + """Return the file descriptor for the underlying file.""" + self._check_not_closed() + return self._fp.fileno() + + @property + def name(self): + self._check_not_closed() + return self._fp.name + + @property + def mode(self): + return 'wb' if self._mode == _MODE_WRITE else 'rb' + + @property + def closed(self): + """True if this file is closed.""" + return self._mode == _MODE_CLOSED + + def seekable(self): + """Return whether the file supports seeking.""" + return self.readable() and self._buffer.seekable() + + def readable(self): + """Return whether the file was opened for reading.""" + self._check_not_closed() + return self._mode == _MODE_READ + + def writable(self): + """Return whether the file was opened for writing.""" + self._check_not_closed() + return self._mode == _MODE_WRITE + + +def open(file, /, mode='rb', *, level=None, options=None, zstd_dict=None, + encoding=None, errors=None, newline=None): + """Open a Zstandard compressed file in binary or text mode. + + file can be either a file name (given as a str, bytes, or PathLike object), + in which case the named file is opened, or it can be an existing file object + to read from or write to. + + The mode parameter can be 'r', 'rb' (default), 'w', 'wb', 'x', 'xb', 'a', + 'ab' for binary mode, or 'rt', 'wt', 'xt', 'at' for text mode. + + The level, options, and zstd_dict parameters specify the settings the same + as ZstdFile. + + When using read mode (decompression), the options parameter is a dict + representing advanced decompression options. The level parameter is not + supported in this case. When using write mode (compression), only one of + level, an int representing the compression level, or options, a dict + representing advanced compression options, may be passed. In both modes, + zstd_dict is a ZstdDict instance containing a trained Zstandard dictionary. + + For binary mode, this function is equivalent to the ZstdFile constructor: + ZstdFile(filename, mode, ...). In this case, the encoding, errors and + newline parameters must not be provided. + + For text mode, an ZstdFile object is created, and wrapped in an + io.TextIOWrapper instance with the specified encoding, error handling + behavior, and line ending(s). + """ + + text_mode = 't' in mode + mode = mode.replace('t', '') + + if text_mode: + if 'b' in mode: + raise ValueError(f'Invalid mode: {mode!r}') + else: + if encoding is not None: + raise ValueError('Argument "encoding" not supported in binary mode') + if errors is not None: + raise ValueError('Argument "errors" not supported in binary mode') + if newline is not None: + raise ValueError('Argument "newline" not supported in binary mode') + + binary_file = ZstdFile(file, mode, level=level, options=options, + zstd_dict=zstd_dict) + + if text_mode: + return io.TextIOWrapper(binary_file, encoding, errors, newline) + else: + return binary_file diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/__pycache__/__init__.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/__pycache__/__init__.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..17ac2ac381e16ae104a822727075cd21f8e15bd8 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/__pycache__/__init__.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/__init__.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d6ac4b3e0b675f60cfdaa949ddba883a160298c8 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/__init__.py @@ -0,0 +1,65 @@ +# Copyright 2009 Brian Quinlan. All Rights Reserved. +# Licensed to PSF under a Contributor Agreement. + +"""Execute computations asynchronously using threads or processes.""" + +__author__ = 'Brian Quinlan (brian@sweetapp.com)' + +from concurrent.futures._base import (FIRST_COMPLETED, + FIRST_EXCEPTION, + ALL_COMPLETED, + CancelledError, + TimeoutError, + InvalidStateError, + BrokenExecutor, + Future, + Executor, + wait, + as_completed) + +__all__ = [ + 'FIRST_COMPLETED', + 'FIRST_EXCEPTION', + 'ALL_COMPLETED', + 'CancelledError', + 'TimeoutError', + 'InvalidStateError', + 'BrokenExecutor', + 'Future', + 'Executor', + 'wait', + 'as_completed', + 'ProcessPoolExecutor', + 'ThreadPoolExecutor', +] + + +try: + import _interpreters +except ImportError: + _interpreters = None + +if _interpreters: + __all__.append('InterpreterPoolExecutor') + + +def __dir__(): + return __all__ + ['__author__', '__doc__'] + + +def __getattr__(name): + global ProcessPoolExecutor, ThreadPoolExecutor, InterpreterPoolExecutor + + if name == 'ProcessPoolExecutor': + from .process import ProcessPoolExecutor + return ProcessPoolExecutor + + if name == 'ThreadPoolExecutor': + from .thread import ThreadPoolExecutor + return ThreadPoolExecutor + + if _interpreters and name == 'InterpreterPoolExecutor': + from .interpreter import InterpreterPoolExecutor + return InterpreterPoolExecutor + + raise AttributeError(f"module {__name__!r} has no attribute {name!r}") diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/__pycache__/__init__.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/__pycache__/__init__.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..81ad09c3be9e301e464af7678d36a93b81f9d6f9 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/__pycache__/__init__.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/__pycache__/_base.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/__pycache__/_base.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..41e14d40a5549c6aca3d0422a77c87474338b815 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/__pycache__/_base.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/__pycache__/interpreter.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/__pycache__/interpreter.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9edb7d3383b3df6d8895d98e9b6b66fd80ab8373 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/__pycache__/interpreter.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/__pycache__/process.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/__pycache__/process.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a673d761d674624ef21b969e6001cf570b8805a0 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/__pycache__/process.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/__pycache__/thread.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/__pycache__/thread.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6530a67792bbd712e822631bf322b672ec0f9e1b Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/__pycache__/thread.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/_base.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/_base.py new file mode 100644 index 0000000000000000000000000000000000000000..d98b1ebdd584b5a331c4925c5d80fbb2e1dc9552 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/_base.py @@ -0,0 +1,674 @@ +# Copyright 2009 Brian Quinlan. All Rights Reserved. +# Licensed to PSF under a Contributor Agreement. + +__author__ = 'Brian Quinlan (brian@sweetapp.com)' + +import collections +import logging +import threading +import time +import types +import weakref +from itertools import islice + +FIRST_COMPLETED = 'FIRST_COMPLETED' +FIRST_EXCEPTION = 'FIRST_EXCEPTION' +ALL_COMPLETED = 'ALL_COMPLETED' +_AS_COMPLETED = '_AS_COMPLETED' + +# Possible future states (for internal use by the futures package). +PENDING = 'PENDING' +RUNNING = 'RUNNING' +# The future was cancelled by the user... +CANCELLED = 'CANCELLED' +# ...and _Waiter.add_cancelled() was called by a worker. +CANCELLED_AND_NOTIFIED = 'CANCELLED_AND_NOTIFIED' +FINISHED = 'FINISHED' + +_STATE_TO_DESCRIPTION_MAP = { + PENDING: "pending", + RUNNING: "running", + CANCELLED: "cancelled", + CANCELLED_AND_NOTIFIED: "cancelled", + FINISHED: "finished" +} + +# Logger for internal use by the futures package. +LOGGER = logging.getLogger("concurrent.futures") + +class Error(Exception): + """Base class for all future-related exceptions.""" + pass + +class CancelledError(Error): + """The Future was cancelled.""" + pass + +TimeoutError = TimeoutError # make local alias for the standard exception + +class InvalidStateError(Error): + """The operation is not allowed in this state.""" + pass + +class _Waiter(object): + """Provides the event that wait() and as_completed() block on.""" + def __init__(self): + self.event = threading.Event() + self.finished_futures = [] + + def add_result(self, future): + self.finished_futures.append(future) + + def add_exception(self, future): + self.finished_futures.append(future) + + def add_cancelled(self, future): + self.finished_futures.append(future) + +class _AsCompletedWaiter(_Waiter): + """Used by as_completed().""" + + def __init__(self): + super(_AsCompletedWaiter, self).__init__() + self.lock = threading.Lock() + + def add_result(self, future): + with self.lock: + super(_AsCompletedWaiter, self).add_result(future) + self.event.set() + + def add_exception(self, future): + with self.lock: + super(_AsCompletedWaiter, self).add_exception(future) + self.event.set() + + def add_cancelled(self, future): + with self.lock: + super(_AsCompletedWaiter, self).add_cancelled(future) + self.event.set() + +class _FirstCompletedWaiter(_Waiter): + """Used by wait(return_when=FIRST_COMPLETED).""" + + def add_result(self, future): + super().add_result(future) + self.event.set() + + def add_exception(self, future): + super().add_exception(future) + self.event.set() + + def add_cancelled(self, future): + super().add_cancelled(future) + self.event.set() + +class _AllCompletedWaiter(_Waiter): + """Used by wait(return_when=FIRST_EXCEPTION and ALL_COMPLETED).""" + + def __init__(self, num_pending_calls, stop_on_exception): + self.num_pending_calls = num_pending_calls + self.stop_on_exception = stop_on_exception + self.lock = threading.Lock() + super().__init__() + + def _decrement_pending_calls(self): + with self.lock: + self.num_pending_calls -= 1 + if not self.num_pending_calls: + self.event.set() + + def add_result(self, future): + super().add_result(future) + self._decrement_pending_calls() + + def add_exception(self, future): + super().add_exception(future) + if self.stop_on_exception: + self.event.set() + else: + self._decrement_pending_calls() + + def add_cancelled(self, future): + super().add_cancelled(future) + self._decrement_pending_calls() + +class _AcquireFutures(object): + """A context manager that does an ordered acquire of Future conditions.""" + + def __init__(self, futures): + self.futures = sorted(futures, key=id) + + def __enter__(self): + for future in self.futures: + future._condition.acquire() + + def __exit__(self, *args): + for future in self.futures: + future._condition.release() + +def _create_and_install_waiters(fs, return_when): + if return_when == _AS_COMPLETED: + waiter = _AsCompletedWaiter() + elif return_when == FIRST_COMPLETED: + waiter = _FirstCompletedWaiter() + else: + pending_count = sum( + f._state not in [CANCELLED_AND_NOTIFIED, FINISHED] for f in fs) + + if return_when == FIRST_EXCEPTION: + waiter = _AllCompletedWaiter(pending_count, stop_on_exception=True) + elif return_when == ALL_COMPLETED: + waiter = _AllCompletedWaiter(pending_count, stop_on_exception=False) + else: + raise ValueError("Invalid return condition: %r" % return_when) + + for f in fs: + f._waiters.append(waiter) + + return waiter + + +def _yield_finished_futures(fs, waiter, ref_collect): + """ + Iterate on the list *fs*, yielding finished futures one by one in + reverse order. + Before yielding a future, *waiter* is removed from its waiters + and the future is removed from each set in the collection of sets + *ref_collect*. + + The aim of this function is to avoid keeping stale references after + the future is yielded and before the iterator resumes. + """ + while fs: + f = fs[-1] + for futures_set in ref_collect: + futures_set.remove(f) + with f._condition: + f._waiters.remove(waiter) + del f + # Careful not to keep a reference to the popped value + yield fs.pop() + + +def as_completed(fs, timeout=None): + """An iterator over the given futures that yields each as it completes. + + Args: + fs: The sequence of Futures (possibly created by different Executors) to + iterate over. + timeout: The maximum number of seconds to wait. If None, then there + is no limit on the wait time. + + Returns: + An iterator that yields the given Futures as they complete (finished or + cancelled). If any given Futures are duplicated, they will be returned + once. + + Raises: + TimeoutError: If the entire result iterator could not be generated + before the given timeout. + """ + if timeout is not None: + end_time = timeout + time.monotonic() + + fs = set(fs) + total_futures = len(fs) + with _AcquireFutures(fs): + finished = set( + f for f in fs + if f._state in [CANCELLED_AND_NOTIFIED, FINISHED]) + pending = fs - finished + waiter = _create_and_install_waiters(fs, _AS_COMPLETED) + finished = list(finished) + try: + yield from _yield_finished_futures(finished, waiter, + ref_collect=(fs,)) + + while pending: + if timeout is None: + wait_timeout = None + else: + wait_timeout = end_time - time.monotonic() + if wait_timeout < 0: + raise TimeoutError( + '%d (of %d) futures unfinished' % ( + len(pending), total_futures)) + + waiter.event.wait(wait_timeout) + + with waiter.lock: + finished = waiter.finished_futures + waiter.finished_futures = [] + waiter.event.clear() + + # reverse to keep finishing order + finished.reverse() + yield from _yield_finished_futures(finished, waiter, + ref_collect=(fs, pending)) + + finally: + # Remove waiter from unfinished futures + for f in fs: + with f._condition: + f._waiters.remove(waiter) + +DoneAndNotDoneFutures = collections.namedtuple( + 'DoneAndNotDoneFutures', 'done not_done') +def wait(fs, timeout=None, return_when=ALL_COMPLETED): + """Wait for the futures in the given sequence to complete. + + Args: + fs: The sequence of Futures (possibly created by different Executors) to + wait upon. + timeout: The maximum number of seconds to wait. If None, then there + is no limit on the wait time. + return_when: Indicates when this function should return. The options + are: + + FIRST_COMPLETED - Return when any future finishes or is + cancelled. + FIRST_EXCEPTION - Return when any future finishes by raising an + exception. If no future raises an exception + then it is equivalent to ALL_COMPLETED. + ALL_COMPLETED - Return when all futures finish or are cancelled. + + Returns: + A named 2-tuple of sets. The first set, named 'done', contains the + futures that completed (is finished or cancelled) before the wait + completed. The second set, named 'not_done', contains uncompleted + futures. Duplicate futures given to *fs* are removed and will be + returned only once. + """ + fs = set(fs) + with _AcquireFutures(fs): + done = {f for f in fs + if f._state in [CANCELLED_AND_NOTIFIED, FINISHED]} + not_done = fs - done + if (return_when == FIRST_COMPLETED) and done: + return DoneAndNotDoneFutures(done, not_done) + elif (return_when == FIRST_EXCEPTION) and done: + if any(f for f in done + if not f.cancelled() and f.exception() is not None): + return DoneAndNotDoneFutures(done, not_done) + + if len(done) == len(fs): + return DoneAndNotDoneFutures(done, not_done) + + waiter = _create_and_install_waiters(fs, return_when) + + waiter.event.wait(timeout) + for f in fs: + with f._condition: + f._waiters.remove(waiter) + + done.update(waiter.finished_futures) + return DoneAndNotDoneFutures(done, fs - done) + + +def _result_or_cancel(fut, timeout=None): + try: + try: + return fut.result(timeout) + finally: + fut.cancel() + finally: + # Break a reference cycle with the exception in self._exception + del fut + + +class Future(object): + """Represents the result of an asynchronous computation.""" + + def __init__(self): + """Initializes the future. Should not be called by clients.""" + self._condition = threading.Condition() + self._state = PENDING + self._result = None + self._exception = None + self._waiters = [] + self._done_callbacks = [] + + def _invoke_callbacks(self): + for callback in self._done_callbacks: + try: + callback(self) + except Exception: + LOGGER.exception('exception calling callback for %r', self) + + def __repr__(self): + with self._condition: + if self._state == FINISHED: + if self._exception: + return '<%s at %#x state=%s raised %s>' % ( + self.__class__.__name__, + id(self), + _STATE_TO_DESCRIPTION_MAP[self._state], + self._exception.__class__.__name__) + else: + return '<%s at %#x state=%s returned %s>' % ( + self.__class__.__name__, + id(self), + _STATE_TO_DESCRIPTION_MAP[self._state], + self._result.__class__.__name__) + return '<%s at %#x state=%s>' % ( + self.__class__.__name__, + id(self), + _STATE_TO_DESCRIPTION_MAP[self._state]) + + def cancel(self): + """Cancel the future if possible. + + Returns True if the future was cancelled, False otherwise. A future + cannot be cancelled if it is running or has already completed. + """ + with self._condition: + if self._state in [RUNNING, FINISHED]: + return False + + if self._state in [CANCELLED, CANCELLED_AND_NOTIFIED]: + return True + + self._state = CANCELLED + self._condition.notify_all() + + self._invoke_callbacks() + return True + + def cancelled(self): + """Return True if the future was cancelled.""" + with self._condition: + return self._state in [CANCELLED, CANCELLED_AND_NOTIFIED] + + def running(self): + """Return True if the future is currently executing.""" + with self._condition: + return self._state == RUNNING + + def done(self): + """Return True if the future was cancelled or finished executing.""" + with self._condition: + return self._state in [CANCELLED, CANCELLED_AND_NOTIFIED, FINISHED] + + def __get_result(self): + if self._exception is not None: + try: + raise self._exception + finally: + # Break a reference cycle with the exception in self._exception + self = None + else: + return self._result + + def add_done_callback(self, fn): + """Attaches a callable that will be called when the future finishes. + + Args: + fn: A callable that will be called with this future as its only + argument when the future completes or is cancelled. The callable + will always be called by a thread in the same process in which + it was added. If the future has already completed or been + cancelled then the callable will be called immediately. These + callables are called in the order that they were added. + """ + with self._condition: + if self._state not in [CANCELLED, CANCELLED_AND_NOTIFIED, FINISHED]: + self._done_callbacks.append(fn) + return + try: + fn(self) + except Exception: + LOGGER.exception('exception calling callback for %r', self) + + def result(self, timeout=None): + """Return the result of the call that the future represents. + + Args: + timeout: The number of seconds to wait for the result if the future + isn't done. If None, then there is no limit on the wait time. + + Returns: + The result of the call that the future represents. + + Raises: + CancelledError: If the future was cancelled. + TimeoutError: If the future didn't finish executing before the given + timeout. + Exception: If the call raised then that exception will be raised. + """ + try: + with self._condition: + if self._state in [CANCELLED, CANCELLED_AND_NOTIFIED]: + raise CancelledError() + elif self._state == FINISHED: + return self.__get_result() + + self._condition.wait(timeout) + + if self._state in [CANCELLED, CANCELLED_AND_NOTIFIED]: + raise CancelledError() + elif self._state == FINISHED: + return self.__get_result() + else: + raise TimeoutError() + finally: + # Break a reference cycle with the exception in self._exception + self = None + + def exception(self, timeout=None): + """Return the exception raised by the call that the future represents. + + Args: + timeout: The number of seconds to wait for the exception if the + future isn't done. If None, then there is no limit on the wait + time. + + Returns: + The exception raised by the call that the future represents or None + if the call completed without raising. + + Raises: + CancelledError: If the future was cancelled. + TimeoutError: If the future didn't finish executing before the given + timeout. + """ + + with self._condition: + if self._state in [CANCELLED, CANCELLED_AND_NOTIFIED]: + raise CancelledError() + elif self._state == FINISHED: + return self._exception + + self._condition.wait(timeout) + + if self._state in [CANCELLED, CANCELLED_AND_NOTIFIED]: + raise CancelledError() + elif self._state == FINISHED: + return self._exception + else: + raise TimeoutError() + + # The following methods should only be used by Executors and in tests. + def set_running_or_notify_cancel(self): + """Mark the future as running or process any cancel notifications. + + Should only be used by Executor implementations and unit tests. + + If the future has been cancelled (cancel() was called and returned + True) then any threads waiting on the future completing (though calls + to as_completed() or wait()) are notified and False is returned. + + If the future was not cancelled then it is put in the running state + (future calls to running() will return True) and True is returned. + + This method should be called by Executor implementations before + executing the work associated with this future. If this method returns + False then the work should not be executed. + + Returns: + False if the Future was cancelled, True otherwise. + + Raises: + RuntimeError: if this method was already called or if set_result() + or set_exception() was called. + """ + with self._condition: + if self._state == CANCELLED: + self._state = CANCELLED_AND_NOTIFIED + for waiter in self._waiters: + waiter.add_cancelled(self) + # self._condition.notify_all() is not necessary because + # self.cancel() triggers a notification. + return False + elif self._state == PENDING: + self._state = RUNNING + return True + else: + LOGGER.critical('Future %s in unexpected state: %s', + id(self), + self._state) + raise RuntimeError('Future in unexpected state') + + def set_result(self, result): + """Sets the return value of work associated with the future. + + Should only be used by Executor implementations and unit tests. + """ + with self._condition: + if self._state in {CANCELLED, CANCELLED_AND_NOTIFIED, FINISHED}: + raise InvalidStateError('{}: {!r}'.format(self._state, self)) + self._result = result + self._state = FINISHED + for waiter in self._waiters: + waiter.add_result(self) + self._condition.notify_all() + self._invoke_callbacks() + + def set_exception(self, exception): + """Sets the result of the future as being the given exception. + + Should only be used by Executor implementations and unit tests. + """ + with self._condition: + if self._state in {CANCELLED, CANCELLED_AND_NOTIFIED, FINISHED}: + raise InvalidStateError('{}: {!r}'.format(self._state, self)) + self._exception = exception + self._state = FINISHED + for waiter in self._waiters: + waiter.add_exception(self) + self._condition.notify_all() + self._invoke_callbacks() + + __class_getitem__ = classmethod(types.GenericAlias) + +class Executor(object): + """This is an abstract base class for concrete asynchronous executors.""" + + def submit(self, fn, /, *args, **kwargs): + """Submits a callable to be executed with the given arguments. + + Schedules the callable to be executed as fn(*args, **kwargs) and returns + a Future instance representing the execution of the callable. + + Returns: + A Future representing the given call. + """ + raise NotImplementedError() + + def map(self, fn, *iterables, timeout=None, chunksize=1, buffersize=None): + """Returns an iterator equivalent to map(fn, iter). + + Args: + fn: A callable that will take as many arguments as there are + passed iterables. + timeout: The maximum number of seconds to wait. If None, then there + is no limit on the wait time. + chunksize: The size of the chunks the iterable will be broken into + before being passed to a child process. This argument is only + used by ProcessPoolExecutor; it is ignored by + ThreadPoolExecutor. + buffersize: The number of submitted tasks whose results have not + yet been yielded. If the buffer is full, iteration over the + iterables pauses until a result is yielded from the buffer. + If None, all input elements are eagerly collected, and a task is + submitted for each. + + Returns: + An iterator equivalent to: map(func, *iterables) but the calls may + be evaluated out-of-order. + + Raises: + TimeoutError: If the entire result iterator could not be generated + before the given timeout. + Exception: If fn(*args) raises for any values. + """ + if buffersize is not None and not isinstance(buffersize, int): + raise TypeError("buffersize must be an integer or None") + if buffersize is not None and buffersize < 1: + raise ValueError("buffersize must be None or > 0") + + if timeout is not None: + end_time = timeout + time.monotonic() + + zipped_iterables = zip(*iterables) + if buffersize: + fs = collections.deque( + self.submit(fn, *args) for args in islice(zipped_iterables, buffersize) + ) + else: + fs = [self.submit(fn, *args) for args in zipped_iterables] + + # Use a weak reference to ensure that the executor can be garbage + # collected independently of the result_iterator closure. + executor_weakref = weakref.ref(self) + + # Yield must be hidden in closure so that the futures are submitted + # before the first iterator value is required. + def result_iterator(): + try: + # reverse to keep finishing order + fs.reverse() + while fs: + if ( + buffersize + and (executor := executor_weakref()) + and (args := next(zipped_iterables, None)) + ): + fs.appendleft(executor.submit(fn, *args)) + # Careful not to keep a reference to the popped future + if timeout is None: + yield _result_or_cancel(fs.pop()) + else: + yield _result_or_cancel(fs.pop(), end_time - time.monotonic()) + finally: + for future in fs: + future.cancel() + return result_iterator() + + def shutdown(self, wait=True, *, cancel_futures=False): + """Clean-up the resources associated with the Executor. + + It is safe to call this method several times. Otherwise, no other + methods can be called after this one. + + Args: + wait: If True then shutdown will not return until all running + futures have finished executing and the resources used by the + executor have been reclaimed. + cancel_futures: If True then shutdown will cancel all pending + futures. Futures that are completed or running will not be + cancelled. + """ + pass + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + self.shutdown(wait=True) + return False + + +class BrokenExecutor(RuntimeError): + """ + Raised when a executor has become non-functional after a severe failure. + """ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/interpreter.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/interpreter.py new file mode 100644 index 0000000000000000000000000000000000000000..85c1da2c7228943cc168d7430e2ce06898eb6282 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/interpreter.py @@ -0,0 +1,123 @@ +"""Implements InterpreterPoolExecutor.""" + +from concurrent import interpreters +import sys +from . import thread as _thread +import traceback + + +def do_call(results, func, args, kwargs): + try: + return func(*args, **kwargs) + except BaseException as exc: + # Send the captured exception out on the results queue, + # but still leave it unhandled for the interpreter to handle. + try: + results.put(exc) + except interpreters.NotShareableError: + # The exception is not shareable. + print('exception is not shareable:', file=sys.stderr) + traceback.print_exception(exc) + results.put(None) + raise # re-raise + + +class WorkerContext(_thread.WorkerContext): + + @classmethod + def prepare(cls, initializer, initargs): + def resolve_task(fn, args, kwargs): + if isinstance(fn, str): + # XXX Circle back to this later. + raise TypeError('scripts not supported') + else: + task = (fn, args, kwargs) + return task + + if initializer is not None: + try: + initdata = resolve_task(initializer, initargs, {}) + except ValueError: + if isinstance(initializer, str) and initargs: + raise ValueError(f'an initializer script does not take args, got {initargs!r}') + raise # re-raise + else: + initdata = None + def create_context(): + return cls(initdata) + return create_context, resolve_task + + def __init__(self, initdata): + self.initdata = initdata + self.interp = None + self.results = None + + def __del__(self): + if self.interp is not None: + self.finalize() + + def initialize(self): + assert self.interp is None, self.interp + self.interp = interpreters.create() + try: + maxsize = 0 + self.results = interpreters.create_queue(maxsize) + + if self.initdata: + self.run(self.initdata) + except BaseException: + self.finalize() + raise # re-raise + + def finalize(self): + interp = self.interp + results = self.results + self.results = None + self.interp = None + if results is not None: + del results + if interp is not None: + interp.close() + + def run(self, task): + try: + return self.interp.call(do_call, self.results, *task) + except interpreters.ExecutionFailed as wrapper: + # Wait for the exception data to show up. + exc = self.results.get() + if exc is None: + # The exception must have been not shareable. + raise # re-raise + raise exc from wrapper + + +class BrokenInterpreterPool(_thread.BrokenThreadPool): + """ + Raised when a worker thread in an InterpreterPoolExecutor failed initializing. + """ + + +class InterpreterPoolExecutor(_thread.ThreadPoolExecutor): + + BROKEN = BrokenInterpreterPool + + @classmethod + def prepare_context(cls, initializer, initargs): + return WorkerContext.prepare(initializer, initargs) + + def __init__(self, max_workers=None, thread_name_prefix='', + initializer=None, initargs=()): + """Initializes a new InterpreterPoolExecutor instance. + + Args: + max_workers: The maximum number of interpreters that can be used to + execute the given calls. + thread_name_prefix: An optional name prefix to give our threads. + initializer: A callable or script used to initialize + each worker interpreter. + initargs: A tuple of arguments to pass to the initializer. + """ + thread_name_prefix = (thread_name_prefix or + (f"InterpreterPoolExecutor-{self._counter()}")) + super().__init__(max_workers, thread_name_prefix, + initializer, initargs) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/process.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/process.py new file mode 100644 index 0000000000000000000000000000000000000000..a14650bf5fa47cd65037b078a4e6572ace4480c5 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/process.py @@ -0,0 +1,939 @@ +# Copyright 2009 Brian Quinlan. All Rights Reserved. +# Licensed to PSF under a Contributor Agreement. + +"""Implements ProcessPoolExecutor. + +The following diagram and text describe the data-flow through the system: + +|======================= In-process =====================|== Out-of-process ==| + ++----------+ +----------+ +--------+ +-----------+ +---------+ +| | => | Work Ids | | | | Call Q | | Process | +| | +----------+ | | +-----------+ | Pool | +| | | ... | | | | ... | +---------+ +| | | 6 | => | | => | 5, call() | => | | +| | | 7 | | | | ... | | | +| Process | | ... | | Local | +-----------+ | Process | +| Pool | +----------+ | Worker | | #1..n | +| Executor | | Thread | | | +| | +----------- + | | +-----------+ | | +| | <=> | Work Items | <=> | | <= | Result Q | <= | | +| | +------------+ | | +-----------+ | | +| | | 6: call() | | | | ... | | | +| | | future | | | | 4, result | | | +| | | ... | | | | 3, except | | | ++----------+ +------------+ +--------+ +-----------+ +---------+ + +Executor.submit() called: +- creates a uniquely numbered _WorkItem and adds it to the "Work Items" dict +- adds the id of the _WorkItem to the "Work Ids" queue + +Local worker thread: +- reads work ids from the "Work Ids" queue and looks up the corresponding + WorkItem from the "Work Items" dict: if the work item has been cancelled then + it is simply removed from the dict, otherwise it is repackaged as a + _CallItem and put in the "Call Q". New _CallItems are put in the "Call Q" + until "Call Q" is full. NOTE: the size of the "Call Q" is kept small because + calls placed in the "Call Q" can no longer be cancelled with Future.cancel(). +- reads _ResultItems from "Result Q", updates the future stored in the + "Work Items" dict and deletes the dict entry + +Process #1..n: +- reads _CallItems from "Call Q", executes the calls, and puts the resulting + _ResultItems in "Result Q" +""" + +__author__ = 'Brian Quinlan (brian@sweetapp.com)' + +import os +from concurrent.futures import _base +import queue +import multiprocessing as mp +# This import is required to load the multiprocessing.connection submodule +# so that it can be accessed later as `mp.connection` +import multiprocessing.connection +from multiprocessing.queues import Queue +import threading +import weakref +from functools import partial +import itertools +import sys +from traceback import format_exception + + +_threads_wakeups = weakref.WeakKeyDictionary() +_global_shutdown = False + + +class _ThreadWakeup: + def __init__(self): + self._closed = False + self._lock = threading.Lock() + self._reader, self._writer = mp.Pipe(duplex=False) + + def close(self): + # Please note that we do not take the self._lock when + # calling clear() (to avoid deadlocking) so this method can + # only be called safely from the same thread as all calls to + # clear() even if you hold the lock. Otherwise we + # might try to read from the closed pipe. + with self._lock: + if not self._closed: + self._closed = True + self._writer.close() + self._reader.close() + + def wakeup(self): + with self._lock: + if not self._closed: + self._writer.send_bytes(b"") + + def clear(self): + if self._closed: + raise RuntimeError('operation on closed _ThreadWakeup') + while self._reader.poll(): + self._reader.recv_bytes() + + +def _python_exit(): + global _global_shutdown + _global_shutdown = True + items = list(_threads_wakeups.items()) + for _, thread_wakeup in items: + # call not protected by ProcessPoolExecutor._shutdown_lock + thread_wakeup.wakeup() + for t, _ in items: + t.join() + +# Register for `_python_exit()` to be called just before joining all +# non-daemon threads. This is used instead of `atexit.register()` for +# compatibility with subinterpreters, which no longer support daemon threads. +# See bpo-39812 for context. +threading._register_atexit(_python_exit) + +# Controls how many more calls than processes will be queued in the call queue. +# A smaller number will mean that processes spend more time idle waiting for +# work while a larger number will make Future.cancel() succeed less frequently +# (Futures in the call queue cannot be cancelled). +EXTRA_QUEUED_CALLS = 1 + + +# On Windows, WaitForMultipleObjects is used to wait for processes to finish. +# It can wait on, at most, 63 objects. There is an overhead of two objects: +# - the result queue reader +# - the thread wakeup reader +_MAX_WINDOWS_WORKERS = 63 - 2 + +# Hack to embed stringification of remote traceback in local traceback + +class _RemoteTraceback(Exception): + def __init__(self, tb): + self.tb = tb + def __str__(self): + return self.tb + +class _ExceptionWithTraceback: + def __init__(self, exc, tb): + tb = ''.join(format_exception(type(exc), exc, tb)) + self.exc = exc + # Traceback object needs to be garbage-collected as its frames + # contain references to all the objects in the exception scope + self.exc.__traceback__ = None + self.tb = '\n"""\n%s"""' % tb + def __reduce__(self): + return _rebuild_exc, (self.exc, self.tb) + +def _rebuild_exc(exc, tb): + exc.__cause__ = _RemoteTraceback(tb) + return exc + +class _WorkItem(object): + def __init__(self, future, fn, args, kwargs): + self.future = future + self.fn = fn + self.args = args + self.kwargs = kwargs + +class _ResultItem(object): + def __init__(self, work_id, exception=None, result=None, exit_pid=None): + self.work_id = work_id + self.exception = exception + self.result = result + self.exit_pid = exit_pid + +class _CallItem(object): + def __init__(self, work_id, fn, args, kwargs): + self.work_id = work_id + self.fn = fn + self.args = args + self.kwargs = kwargs + + +class _SafeQueue(Queue): + """Safe Queue set exception to the future object linked to a job""" + def __init__(self, max_size=0, *, ctx, pending_work_items, thread_wakeup): + self.pending_work_items = pending_work_items + self.thread_wakeup = thread_wakeup + super().__init__(max_size, ctx=ctx) + + def _on_queue_feeder_error(self, e, obj): + if isinstance(obj, _CallItem): + tb = format_exception(type(e), e, e.__traceback__) + e.__cause__ = _RemoteTraceback('\n"""\n{}"""'.format(''.join(tb))) + work_item = self.pending_work_items.pop(obj.work_id, None) + self.thread_wakeup.wakeup() + # work_item can be None if another process terminated. In this + # case, the executor_manager_thread fails all work_items + # with BrokenProcessPool + if work_item is not None: + work_item.future.set_exception(e) + else: + super()._on_queue_feeder_error(e, obj) + + +def _process_chunk(fn, chunk): + """ Processes a chunk of an iterable passed to map. + + Runs the function passed to map() on a chunk of the + iterable passed to map. + + This function is run in a separate process. + + """ + return [fn(*args) for args in chunk] + + +def _sendback_result(result_queue, work_id, result=None, exception=None, + exit_pid=None): + """Safely send back the given result or exception""" + try: + result_queue.put(_ResultItem(work_id, result=result, + exception=exception, exit_pid=exit_pid)) + except BaseException as e: + exc = _ExceptionWithTraceback(e, e.__traceback__) + result_queue.put(_ResultItem(work_id, exception=exc, + exit_pid=exit_pid)) + + +def _process_worker(call_queue, result_queue, initializer, initargs, max_tasks=None): + """Evaluates calls from call_queue and places the results in result_queue. + + This worker is run in a separate process. + + Args: + call_queue: A ctx.Queue of _CallItems that will be read and + evaluated by the worker. + result_queue: A ctx.Queue of _ResultItems that will written + to by the worker. + initializer: A callable initializer, or None + initargs: A tuple of args for the initializer + """ + if initializer is not None: + try: + initializer(*initargs) + except BaseException: + _base.LOGGER.critical('Exception in initializer:', exc_info=True) + # The parent will notice that the process stopped and + # mark the pool broken + return + num_tasks = 0 + exit_pid = None + while True: + call_item = call_queue.get(block=True) + if call_item is None: + # Wake up queue management thread + result_queue.put(os.getpid()) + return + + if max_tasks is not None: + num_tasks += 1 + if num_tasks >= max_tasks: + exit_pid = os.getpid() + + try: + r = call_item.fn(*call_item.args, **call_item.kwargs) + except BaseException as e: + exc = _ExceptionWithTraceback(e, e.__traceback__) + _sendback_result(result_queue, call_item.work_id, exception=exc, + exit_pid=exit_pid) + else: + _sendback_result(result_queue, call_item.work_id, result=r, + exit_pid=exit_pid) + del r + + # Liberate the resource as soon as possible, to avoid holding onto + # open files or shared memory that is not needed anymore + del call_item + + if exit_pid is not None: + return + + +class _ExecutorManagerThread(threading.Thread): + """Manages the communication between this process and the worker processes. + + The manager is run in a local thread. + + Args: + executor: A reference to the ProcessPoolExecutor that owns + this thread. A weakref will be own by the manager as well as + references to internal objects used to introspect the state of + the executor. + """ + + def __init__(self, executor): + # Store references to necessary internals of the executor. + + # A _ThreadWakeup to allow waking up the queue_manager_thread from the + # main Thread and avoid deadlocks caused by permanently locked queues. + self.thread_wakeup = executor._executor_manager_thread_wakeup + self.shutdown_lock = executor._shutdown_lock + + # A weakref.ref to the ProcessPoolExecutor that owns this thread. Used + # to determine if the ProcessPoolExecutor has been garbage collected + # and that the manager can exit. + # When the executor gets garbage collected, the weakref callback + # will wake up the queue management thread so that it can terminate + # if there is no pending work item. + def weakref_cb(_, + thread_wakeup=self.thread_wakeup, + mp_util_debug=mp.util.debug): + mp_util_debug('Executor collected: triggering callback for' + ' QueueManager wakeup') + thread_wakeup.wakeup() + + self.executor_reference = weakref.ref(executor, weakref_cb) + + # A list of the ctx.Process instances used as workers. + self.processes = executor._processes + + # A ctx.Queue that will be filled with _CallItems derived from + # _WorkItems for processing by the process workers. + self.call_queue = executor._call_queue + + # A ctx.SimpleQueue of _ResultItems generated by the process workers. + self.result_queue = executor._result_queue + + # A queue.Queue of work ids e.g. Queue([5, 6, ...]). + self.work_ids_queue = executor._work_ids + + # Maximum number of tasks a worker process can execute before + # exiting safely + self.max_tasks_per_child = executor._max_tasks_per_child + + # A dict mapping work ids to _WorkItems e.g. + # {5: <_WorkItem...>, 6: <_WorkItem...>, ...} + self.pending_work_items = executor._pending_work_items + + super().__init__() + + def run(self): + # Main loop for the executor manager thread. + + while True: + # gh-109047: During Python finalization, self.call_queue.put() + # creation of a thread can fail with RuntimeError. + try: + self.add_call_item_to_queue() + except BaseException as exc: + cause = format_exception(exc) + self.terminate_broken(cause) + return + + result_item, is_broken, cause = self.wait_result_broken_or_wakeup() + + if is_broken: + self.terminate_broken(cause) + return + if result_item is not None: + self.process_result_item(result_item) + + process_exited = result_item.exit_pid is not None + if process_exited: + p = self.processes.pop(result_item.exit_pid) + p.join() + + # Delete reference to result_item to avoid keeping references + # while waiting on new results. + del result_item + + if executor := self.executor_reference(): + if process_exited: + with self.shutdown_lock: + executor._adjust_process_count() + else: + executor._idle_worker_semaphore.release() + del executor + + if self.is_shutting_down(): + self.flag_executor_shutting_down() + + # When only canceled futures remain in pending_work_items, our + # next call to wait_result_broken_or_wakeup would hang forever. + # This makes sure we have some running futures or none at all. + self.add_call_item_to_queue() + + # Since no new work items can be added, it is safe to shutdown + # this thread if there are no pending work items. + if not self.pending_work_items: + self.join_executor_internals() + return + + def add_call_item_to_queue(self): + # Fills call_queue with _WorkItems from pending_work_items. + # This function never blocks. + while True: + if self.call_queue.full(): + return + try: + work_id = self.work_ids_queue.get(block=False) + except queue.Empty: + return + else: + work_item = self.pending_work_items[work_id] + + if work_item.future.set_running_or_notify_cancel(): + self.call_queue.put(_CallItem(work_id, + work_item.fn, + work_item.args, + work_item.kwargs), + block=True) + else: + del self.pending_work_items[work_id] + continue + + def wait_result_broken_or_wakeup(self): + # Wait for a result to be ready in the result_queue while checking + # that all worker processes are still running, or for a wake up + # signal send. The wake up signals come either from new tasks being + # submitted, from the executor being shutdown/gc-ed, or from the + # shutdown of the python interpreter. + result_reader = self.result_queue._reader + assert not self.thread_wakeup._closed + wakeup_reader = self.thread_wakeup._reader + readers = [result_reader, wakeup_reader] + worker_sentinels = [p.sentinel for p in list(self.processes.values())] + ready = mp.connection.wait(readers + worker_sentinels) + + cause = None + is_broken = True + result_item = None + if result_reader in ready: + try: + result_item = result_reader.recv() + is_broken = False + except BaseException as exc: + cause = format_exception(exc) + + elif wakeup_reader in ready: + is_broken = False + + self.thread_wakeup.clear() + + return result_item, is_broken, cause + + def process_result_item(self, result_item): + # Process the received a result_item. This can be either the PID of a + # worker that exited gracefully or a _ResultItem + + # Received a _ResultItem so mark the future as completed. + work_item = self.pending_work_items.pop(result_item.work_id, None) + # work_item can be None if another process terminated (see above) + if work_item is not None: + if result_item.exception is not None: + work_item.future.set_exception(result_item.exception) + else: + work_item.future.set_result(result_item.result) + + def is_shutting_down(self): + # Check whether we should start shutting down the executor. + executor = self.executor_reference() + # No more work items can be added if: + # - The interpreter is shutting down OR + # - The executor that owns this worker has been collected OR + # - The executor that owns this worker has been shutdown. + return (_global_shutdown or executor is None + or executor._shutdown_thread) + + def _terminate_broken(self, cause): + # Terminate the executor because it is in a broken state. The cause + # argument can be used to display more information on the error that + # lead the executor into becoming broken. + + # Mark the process pool broken so that submits fail right now. + executor = self.executor_reference() + if executor is not None: + executor._broken = ('A child process terminated ' + 'abruptly, the process pool is not ' + 'usable anymore') + executor._shutdown_thread = True + executor = None + + # All pending tasks are to be marked failed with the following + # BrokenProcessPool error + bpe = BrokenProcessPool("A process in the process pool was " + "terminated abruptly while the future was " + "running or pending.") + if cause is not None: + bpe.__cause__ = _RemoteTraceback( + f"\n'''\n{''.join(cause)}'''") + + # Mark pending tasks as failed. + for work_id, work_item in self.pending_work_items.items(): + try: + work_item.future.set_exception(bpe) + except _base.InvalidStateError: + # set_exception() fails if the future is cancelled: ignore it. + # Trying to check if the future is cancelled before calling + # set_exception() would leave a race condition if the future is + # cancelled between the check and set_exception(). + pass + # Delete references to object. See issue16284 + del work_item + self.pending_work_items.clear() + + # Terminate remaining workers forcibly: the queues or their + # locks may be in a dirty state and block forever. + for p in self.processes.values(): + p.terminate() + + self.call_queue._terminate_broken() + + # clean up resources + self._join_executor_internals(broken=True) + + def terminate_broken(self, cause): + with self.shutdown_lock: + self._terminate_broken(cause) + + def flag_executor_shutting_down(self): + # Flag the executor as shutting down and cancel remaining tasks if + # requested as early as possible if it is not gc-ed yet. + executor = self.executor_reference() + if executor is not None: + executor._shutdown_thread = True + # Cancel pending work items if requested. + if executor._cancel_pending_futures: + # Cancel all pending futures and update pending_work_items + # to only have futures that are currently running. + new_pending_work_items = {} + for work_id, work_item in self.pending_work_items.items(): + if not work_item.future.cancel(): + new_pending_work_items[work_id] = work_item + self.pending_work_items = new_pending_work_items + # Drain work_ids_queue since we no longer need to + # add items to the call queue. + while True: + try: + self.work_ids_queue.get_nowait() + except queue.Empty: + break + # Make sure we do this only once to not waste time looping + # on running processes over and over. + executor._cancel_pending_futures = False + + def shutdown_workers(self): + n_children_to_stop = self.get_n_children_alive() + n_sentinels_sent = 0 + # Send the right number of sentinels, to make sure all children are + # properly terminated. + while (n_sentinels_sent < n_children_to_stop + and self.get_n_children_alive() > 0): + for i in range(n_children_to_stop - n_sentinels_sent): + try: + self.call_queue.put_nowait(None) + n_sentinels_sent += 1 + except queue.Full: + break + + def join_executor_internals(self): + with self.shutdown_lock: + self._join_executor_internals() + + def _join_executor_internals(self, broken=False): + # If broken, call_queue was closed and so can no longer be used. + if not broken: + self.shutdown_workers() + + # Release the queue's resources as soon as possible. + self.call_queue.close() + self.call_queue.join_thread() + self.thread_wakeup.close() + + # If .join() is not called on the created processes then + # some ctx.Queue methods may deadlock on Mac OS X. + for p in self.processes.values(): + if broken: + p.terminate() + p.join() + + def get_n_children_alive(self): + # This is an upper bound on the number of children alive. + return sum(p.is_alive() for p in self.processes.values()) + + +_system_limits_checked = False +_system_limited = None + + +def _check_system_limits(): + global _system_limits_checked, _system_limited + if _system_limits_checked: + if _system_limited: + raise NotImplementedError(_system_limited) + _system_limits_checked = True + try: + import multiprocessing.synchronize # noqa: F401 + except ImportError: + _system_limited = ( + "This Python build lacks multiprocessing.synchronize, usually due " + "to named semaphores being unavailable on this platform." + ) + raise NotImplementedError(_system_limited) + try: + nsems_max = os.sysconf("SC_SEM_NSEMS_MAX") + except (AttributeError, ValueError): + # sysconf not available or setting not available + return + if nsems_max == -1: + # indetermined limit, assume that limit is determined + # by available memory only + return + if nsems_max >= 256: + # minimum number of semaphores available + # according to POSIX + return + _system_limited = ("system provides too few semaphores (%d" + " available, 256 necessary)" % nsems_max) + raise NotImplementedError(_system_limited) + + +def _chain_from_iterable_of_lists(iterable): + """ + Specialized implementation of itertools.chain.from_iterable. + Each item in *iterable* should be a list. This function is + careful not to keep references to yielded objects. + """ + for element in iterable: + element.reverse() + while element: + yield element.pop() + + +class BrokenProcessPool(_base.BrokenExecutor): + """ + Raised when a process in a ProcessPoolExecutor terminated abruptly + while a future was in the running state. + """ + +_TERMINATE = "terminate" +_KILL = "kill" + +_SHUTDOWN_CALLBACK_OPERATION = { + _TERMINATE, + _KILL +} + + +class ProcessPoolExecutor(_base.Executor): + def __init__(self, max_workers=None, mp_context=None, + initializer=None, initargs=(), *, max_tasks_per_child=None): + """Initializes a new ProcessPoolExecutor instance. + + Args: + max_workers: The maximum number of processes that can be used to + execute the given calls. If None or not given then as many + worker processes will be created as the machine has processors. + mp_context: A multiprocessing context to launch the workers created + using the multiprocessing.get_context('start method') API. This + object should provide SimpleQueue, Queue and Process. + initializer: A callable used to initialize worker processes. + initargs: A tuple of arguments to pass to the initializer. + max_tasks_per_child: The maximum number of tasks a worker process + can complete before it will exit and be replaced with a fresh + worker process. The default of None means worker process will + live as long as the executor. Requires a non-'fork' mp_context + start method. When given, we default to using 'spawn' if no + mp_context is supplied. + """ + _check_system_limits() + + if max_workers is None: + self._max_workers = os.process_cpu_count() or 1 + if sys.platform == 'win32': + self._max_workers = min(_MAX_WINDOWS_WORKERS, + self._max_workers) + else: + if max_workers <= 0: + raise ValueError("max_workers must be greater than 0") + elif (sys.platform == 'win32' and + max_workers > _MAX_WINDOWS_WORKERS): + raise ValueError( + f"max_workers must be <= {_MAX_WINDOWS_WORKERS}") + + self._max_workers = max_workers + + if mp_context is None: + if max_tasks_per_child is not None: + mp_context = mp.get_context("spawn") + else: + mp_context = mp.get_context() + self._mp_context = mp_context + + # https://github.com/python/cpython/issues/90622 + self._safe_to_dynamically_spawn_children = ( + self._mp_context.get_start_method(allow_none=False) != "fork") + + if initializer is not None and not callable(initializer): + raise TypeError("initializer must be a callable") + self._initializer = initializer + self._initargs = initargs + + if max_tasks_per_child is not None: + if not isinstance(max_tasks_per_child, int): + raise TypeError("max_tasks_per_child must be an integer") + elif max_tasks_per_child <= 0: + raise ValueError("max_tasks_per_child must be >= 1") + if self._mp_context.get_start_method(allow_none=False) == "fork": + # https://github.com/python/cpython/issues/90622 + raise ValueError("max_tasks_per_child is incompatible with" + " the 'fork' multiprocessing start method;" + " supply a different mp_context.") + self._max_tasks_per_child = max_tasks_per_child + + # Management thread + self._executor_manager_thread = None + + # Map of pids to processes + self._processes = {} + + # Shutdown is a two-step process. + self._shutdown_thread = False + self._shutdown_lock = threading.Lock() + self._idle_worker_semaphore = threading.Semaphore(0) + self._broken = False + self._queue_count = 0 + self._pending_work_items = {} + self._cancel_pending_futures = False + + # _ThreadWakeup is a communication channel used to interrupt the wait + # of the main loop of executor_manager_thread from another thread (e.g. + # when calling executor.submit or executor.shutdown). We do not use the + # _result_queue to send wakeup signals to the executor_manager_thread + # as it could result in a deadlock if a worker process dies with the + # _result_queue write lock still acquired. + # + # Care must be taken to only call clear and close from the + # executor_manager_thread, since _ThreadWakeup.clear() is not protected + # by a lock. + self._executor_manager_thread_wakeup = _ThreadWakeup() + + # Create communication channels for the executor + # Make the call queue slightly larger than the number of processes to + # prevent the worker processes from idling. But don't make it too big + # because futures in the call queue cannot be cancelled. + queue_size = self._max_workers + EXTRA_QUEUED_CALLS + self._call_queue = _SafeQueue( + max_size=queue_size, ctx=self._mp_context, + pending_work_items=self._pending_work_items, + thread_wakeup=self._executor_manager_thread_wakeup) + # Killed worker processes can produce spurious "broken pipe" + # tracebacks in the queue's own worker thread. But we detect killed + # processes anyway, so silence the tracebacks. + self._call_queue._ignore_epipe = True + self._result_queue = mp_context.SimpleQueue() + self._work_ids = queue.Queue() + + def _start_executor_manager_thread(self): + if self._executor_manager_thread is None: + # Start the processes so that their sentinels are known. + if not self._safe_to_dynamically_spawn_children: # ie, using fork. + self._launch_processes() + self._executor_manager_thread = _ExecutorManagerThread(self) + self._executor_manager_thread.start() + _threads_wakeups[self._executor_manager_thread] = \ + self._executor_manager_thread_wakeup + + def _adjust_process_count(self): + # gh-132969: avoid error when state is reset and executor is still running, + # which will happen when shutdown(wait=False) is called. + if self._processes is None: + return + + # if there's an idle process, we don't need to spawn a new one. + if self._idle_worker_semaphore.acquire(blocking=False): + return + + process_count = len(self._processes) + if process_count < self._max_workers: + # Assertion disabled as this codepath is also used to replace a + # worker that unexpectedly dies, even when using the 'fork' start + # method. That means there is still a potential deadlock bug. If a + # 'fork' mp_context worker dies, we'll be forking a new one when + # we know a thread is running (self._executor_manager_thread). + #assert self._safe_to_dynamically_spawn_children or not self._executor_manager_thread, 'https://github.com/python/cpython/issues/90622' + self._spawn_process() + + def _launch_processes(self): + # https://github.com/python/cpython/issues/90622 + assert not self._executor_manager_thread, ( + 'Processes cannot be fork()ed after the thread has started, ' + 'deadlock in the child processes could result.') + for _ in range(len(self._processes), self._max_workers): + self._spawn_process() + + def _spawn_process(self): + p = self._mp_context.Process( + target=_process_worker, + args=(self._call_queue, + self._result_queue, + self._initializer, + self._initargs, + self._max_tasks_per_child)) + p.start() + self._processes[p.pid] = p + + def submit(self, fn, /, *args, **kwargs): + with self._shutdown_lock: + if self._broken: + raise BrokenProcessPool(self._broken) + if self._shutdown_thread: + raise RuntimeError('cannot schedule new futures after shutdown') + if _global_shutdown: + raise RuntimeError('cannot schedule new futures after ' + 'interpreter shutdown') + + f = _base.Future() + w = _WorkItem(f, fn, args, kwargs) + + self._pending_work_items[self._queue_count] = w + self._work_ids.put(self._queue_count) + self._queue_count += 1 + # Wake up queue management thread + self._executor_manager_thread_wakeup.wakeup() + + if self._safe_to_dynamically_spawn_children: + self._adjust_process_count() + self._start_executor_manager_thread() + return f + submit.__doc__ = _base.Executor.submit.__doc__ + + def map(self, fn, *iterables, timeout=None, chunksize=1, buffersize=None): + """Returns an iterator equivalent to map(fn, iter). + + Args: + fn: A callable that will take as many arguments as there are + passed iterables. + timeout: The maximum number of seconds to wait. If None, then there + is no limit on the wait time. + chunksize: If greater than one, the iterables will be chopped into + chunks of size chunksize and submitted to the process pool. + If set to one, the items in the list will be sent one at a time. + buffersize: The number of submitted tasks whose results have not + yet been yielded. If the buffer is full, iteration over the + iterables pauses until a result is yielded from the buffer. + If None, all input elements are eagerly collected, and a task is + submitted for each. + + Returns: + An iterator equivalent to: map(func, *iterables) but the calls may + be evaluated out-of-order. + + Raises: + TimeoutError: If the entire result iterator could not be generated + before the given timeout. + Exception: If fn(*args) raises for any values. + """ + if chunksize < 1: + raise ValueError("chunksize must be >= 1.") + + results = super().map(partial(_process_chunk, fn), + itertools.batched(zip(*iterables), chunksize), + timeout=timeout, + buffersize=buffersize) + return _chain_from_iterable_of_lists(results) + + def shutdown(self, wait=True, *, cancel_futures=False): + with self._shutdown_lock: + self._cancel_pending_futures = cancel_futures + self._shutdown_thread = True + if self._executor_manager_thread_wakeup is not None: + # Wake up queue management thread + self._executor_manager_thread_wakeup.wakeup() + + if self._executor_manager_thread is not None and wait: + self._executor_manager_thread.join() + # To reduce the risk of opening too many files, remove references to + # objects that use file descriptors. + self._executor_manager_thread = None + self._call_queue = None + if self._result_queue is not None and wait: + self._result_queue.close() + self._result_queue = None + self._processes = None + self._executor_manager_thread_wakeup = None + + shutdown.__doc__ = _base.Executor.shutdown.__doc__ + + def _force_shutdown(self, operation): + """Attempts to terminate or kill the executor's workers based off the + given operation. Iterates through all of the current processes and + performs the relevant task if the process is still alive. + + After terminating workers, the pool will be in a broken state + and no longer usable (for instance, new tasks should not be + submitted). + """ + if operation not in _SHUTDOWN_CALLBACK_OPERATION: + raise ValueError(f"Unsupported operation: {operation!r}") + + processes = {} + if self._processes: + processes = self._processes.copy() + + # shutdown will invalidate ._processes, so we copy it right before + # calling. If we waited here, we would deadlock if a process decides not + # to exit. + self.shutdown(wait=False, cancel_futures=True) + + if not processes: + return + + for proc in processes.values(): + try: + if not proc.is_alive(): + continue + except ValueError: + # The process is already exited/closed out. + continue + + try: + if operation == _TERMINATE: + proc.terminate() + elif operation == _KILL: + proc.kill() + except ProcessLookupError: + # The process just ended before our signal + continue + + def terminate_workers(self): + """Attempts to terminate the executor's workers. + Iterates through all of the current worker processes and terminates + each one that is still alive. + + After terminating workers, the pool will be in a broken state + and no longer usable (for instance, new tasks should not be + submitted). + """ + return self._force_shutdown(operation=_TERMINATE) + + def kill_workers(self): + """Attempts to kill the executor's workers. + Iterates through all of the current worker processes and kills + each one that is still alive. + + After killing workers, the pool will be in a broken state + and no longer usable (for instance, new tasks should not be + submitted). + """ + return self._force_shutdown(operation=_KILL) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/thread.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/thread.py new file mode 100644 index 0000000000000000000000000000000000000000..909359b648709fe980db610c8834c34f2b2d2e76 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/futures/thread.py @@ -0,0 +1,274 @@ +# Copyright 2009 Brian Quinlan. All Rights Reserved. +# Licensed to PSF under a Contributor Agreement. + +"""Implements ThreadPoolExecutor.""" + +__author__ = 'Brian Quinlan (brian@sweetapp.com)' + +from concurrent.futures import _base +import itertools +import queue +import threading +import types +import weakref +import os + + +_threads_queues = weakref.WeakKeyDictionary() +_shutdown = False +# Lock that ensures that new workers are not created while the interpreter is +# shutting down. Must be held while mutating _threads_queues and _shutdown. +_global_shutdown_lock = threading.Lock() + +def _python_exit(): + global _shutdown + with _global_shutdown_lock: + _shutdown = True + items = list(_threads_queues.items()) + for t, q in items: + q.put(None) + for t, q in items: + t.join() + +# Register for `_python_exit()` to be called just before joining all +# non-daemon threads. This is used instead of `atexit.register()` for +# compatibility with subinterpreters, which no longer support daemon threads. +# See bpo-39812 for context. +threading._register_atexit(_python_exit) + +# At fork, reinitialize the `_global_shutdown_lock` lock in the child process +if hasattr(os, 'register_at_fork'): + os.register_at_fork(before=_global_shutdown_lock.acquire, + after_in_child=_global_shutdown_lock._at_fork_reinit, + after_in_parent=_global_shutdown_lock.release) + os.register_at_fork(after_in_child=_threads_queues.clear) + + +class WorkerContext: + + @classmethod + def prepare(cls, initializer, initargs): + if initializer is not None: + if not callable(initializer): + raise TypeError("initializer must be a callable") + def create_context(): + return cls(initializer, initargs) + def resolve_task(fn, args, kwargs): + return (fn, args, kwargs) + return create_context, resolve_task + + def __init__(self, initializer, initargs): + self.initializer = initializer + self.initargs = initargs + + def initialize(self): + if self.initializer is not None: + self.initializer(*self.initargs) + + def finalize(self): + pass + + def run(self, task): + fn, args, kwargs = task + return fn(*args, **kwargs) + + +class _WorkItem: + def __init__(self, future, task): + self.future = future + self.task = task + + def run(self, ctx): + if not self.future.set_running_or_notify_cancel(): + return + + try: + result = ctx.run(self.task) + except BaseException as exc: + self.future.set_exception(exc) + # Break a reference cycle with the exception 'exc' + self = None + else: + self.future.set_result(result) + + __class_getitem__ = classmethod(types.GenericAlias) + + +def _worker(executor_reference, ctx, work_queue): + try: + ctx.initialize() + except BaseException: + _base.LOGGER.critical('Exception in initializer:', exc_info=True) + executor = executor_reference() + if executor is not None: + executor._initializer_failed() + return + try: + while True: + try: + work_item = work_queue.get_nowait() + except queue.Empty: + # attempt to increment idle count if queue is empty + executor = executor_reference() + if executor is not None: + executor._idle_semaphore.release() + del executor + work_item = work_queue.get(block=True) + + if work_item is not None: + work_item.run(ctx) + # Delete references to object. See GH-60488 + del work_item + continue + + executor = executor_reference() + # Exit if: + # - The interpreter is shutting down OR + # - The executor that owns the worker has been collected OR + # - The executor that owns the worker has been shutdown. + if _shutdown or executor is None or executor._shutdown: + # Flag the executor as shutting down as early as possible if it + # is not gc-ed yet. + if executor is not None: + executor._shutdown = True + # Notice other workers + work_queue.put(None) + return + del executor + except BaseException: + _base.LOGGER.critical('Exception in worker', exc_info=True) + finally: + ctx.finalize() + + +class BrokenThreadPool(_base.BrokenExecutor): + """ + Raised when a worker thread in a ThreadPoolExecutor failed initializing. + """ + + +class ThreadPoolExecutor(_base.Executor): + + BROKEN = BrokenThreadPool + + # Used to assign unique thread names when thread_name_prefix is not supplied. + _counter = itertools.count().__next__ + + @classmethod + def prepare_context(cls, initializer, initargs): + return WorkerContext.prepare(initializer, initargs) + + def __init__(self, max_workers=None, thread_name_prefix='', + initializer=None, initargs=(), **ctxkwargs): + """Initializes a new ThreadPoolExecutor instance. + + Args: + max_workers: The maximum number of threads that can be used to + execute the given calls. + thread_name_prefix: An optional name prefix to give our threads. + initializer: A callable used to initialize worker threads. + initargs: A tuple of arguments to pass to the initializer. + ctxkwargs: Additional arguments to cls.prepare_context(). + """ + if max_workers is None: + # ThreadPoolExecutor is often used to: + # * CPU bound task which releases GIL + # * I/O bound task (which releases GIL, of course) + # + # We use process_cpu_count + 4 for both types of tasks. + # But we limit it to 32 to avoid consuming surprisingly large resource + # on many core machine. + max_workers = min(32, (os.process_cpu_count() or 1) + 4) + if max_workers <= 0: + raise ValueError("max_workers must be greater than 0") + + (self._create_worker_context, + self._resolve_work_item_task, + ) = type(self).prepare_context(initializer, initargs, **ctxkwargs) + + self._max_workers = max_workers + self._work_queue = queue.SimpleQueue() + self._idle_semaphore = threading.Semaphore(0) + self._threads = set() + self._broken = False + self._shutdown = False + self._shutdown_lock = threading.Lock() + self._thread_name_prefix = (thread_name_prefix or + ("ThreadPoolExecutor-%d" % self._counter())) + + def submit(self, fn, /, *args, **kwargs): + with self._shutdown_lock, _global_shutdown_lock: + if self._broken: + raise self.BROKEN(self._broken) + + if self._shutdown: + raise RuntimeError('cannot schedule new futures after shutdown') + if _shutdown: + raise RuntimeError('cannot schedule new futures after ' + 'interpreter shutdown') + + f = _base.Future() + task = self._resolve_work_item_task(fn, args, kwargs) + w = _WorkItem(f, task) + + self._work_queue.put(w) + self._adjust_thread_count() + return f + submit.__doc__ = _base.Executor.submit.__doc__ + + def _adjust_thread_count(self): + # if idle threads are available, don't spin new threads + if self._idle_semaphore.acquire(timeout=0): + return + + # When the executor gets lost, the weakref callback will wake up + # the worker threads. + def weakref_cb(_, q=self._work_queue): + q.put(None) + + num_threads = len(self._threads) + if num_threads < self._max_workers: + thread_name = '%s_%d' % (self._thread_name_prefix or self, + num_threads) + t = threading.Thread(name=thread_name, target=_worker, + args=(weakref.ref(self, weakref_cb), + self._create_worker_context(), + self._work_queue)) + t.start() + self._threads.add(t) + _threads_queues[t] = self._work_queue + + def _initializer_failed(self): + with self._shutdown_lock: + self._broken = ('A thread initializer failed, the thread pool ' + 'is not usable anymore') + # Drain work queue and mark pending futures failed + while True: + try: + work_item = self._work_queue.get_nowait() + except queue.Empty: + break + if work_item is not None: + work_item.future.set_exception(self.BROKEN(self._broken)) + + def shutdown(self, wait=True, *, cancel_futures=False): + with self._shutdown_lock: + self._shutdown = True + if cancel_futures: + # Drain all work items from the queue, and then cancel their + # associated futures. + while True: + try: + work_item = self._work_queue.get_nowait() + except queue.Empty: + break + if work_item is not None: + work_item.future.cancel() + + # Send a wake-up to prevent threads calling + # _work_queue.get(block=True) from permanently blocking. + self._work_queue.put(None) + if wait: + for t in self._threads: + t.join() + shutdown.__doc__ = _base.Executor.shutdown.__doc__ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/interpreters/__init__.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/interpreters/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ea4147ee9a25da554cddc06632e04e620008a6d2 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/interpreters/__init__.py @@ -0,0 +1,247 @@ +"""Subinterpreters High Level Module.""" + +import threading +import weakref +import _interpreters + +# aliases: +from _interpreters import ( + InterpreterError, InterpreterNotFoundError, NotShareableError, + is_shareable, +) +from ._queues import ( + create as create_queue, + Queue, QueueEmpty, QueueFull, +) + + +__all__ = [ + 'get_current', 'get_main', 'create', 'list_all', 'is_shareable', + 'Interpreter', + 'InterpreterError', 'InterpreterNotFoundError', 'ExecutionFailed', + 'NotShareableError', + 'create_queue', 'Queue', 'QueueEmpty', 'QueueFull', +] + + +_EXEC_FAILURE_STR = """ +{superstr} + +Uncaught in the interpreter: + +{formatted} +""".strip() + +class ExecutionFailed(InterpreterError): + """An unhandled exception happened during execution. + + This is raised from Interpreter.exec() and Interpreter.call(). + """ + + def __init__(self, excinfo): + msg = excinfo.formatted + if not msg: + if excinfo.type and excinfo.msg: + msg = f'{excinfo.type.__name__}: {excinfo.msg}' + else: + msg = excinfo.type.__name__ or excinfo.msg + super().__init__(msg) + self.excinfo = excinfo + + def __str__(self): + try: + formatted = self.excinfo.errdisplay + except Exception: + return super().__str__() + else: + return _EXEC_FAILURE_STR.format( + superstr=super().__str__(), + formatted=formatted, + ) + + +def create(): + """Return a new (idle) Python interpreter.""" + id = _interpreters.create(reqrefs=True) + return Interpreter(id, _ownsref=True) + + +def list_all(): + """Return all existing interpreters.""" + return [Interpreter(id, _whence=whence) + for id, whence in _interpreters.list_all(require_ready=True)] + + +def get_current(): + """Return the currently running interpreter.""" + id, whence = _interpreters.get_current() + return Interpreter(id, _whence=whence) + + +def get_main(): + """Return the main interpreter.""" + id, whence = _interpreters.get_main() + assert whence == _interpreters.WHENCE_RUNTIME, repr(whence) + return Interpreter(id, _whence=whence) + + +_known = weakref.WeakValueDictionary() + +class Interpreter: + """A single Python interpreter. + + Attributes: + + "id" - the unique process-global ID number for the interpreter + "whence" - indicates where the interpreter was created + + If the interpreter wasn't created by this module + then any method that modifies the interpreter will fail, + i.e. .close(), .prepare_main(), .exec(), and .call() + """ + + _WHENCE_TO_STR = { + _interpreters.WHENCE_UNKNOWN: 'unknown', + _interpreters.WHENCE_RUNTIME: 'runtime init', + _interpreters.WHENCE_LEGACY_CAPI: 'legacy C-API', + _interpreters.WHENCE_CAPI: 'C-API', + _interpreters.WHENCE_XI: 'cross-interpreter C-API', + _interpreters.WHENCE_STDLIB: '_interpreters module', + } + + def __new__(cls, id, /, _whence=None, _ownsref=None): + # There is only one instance for any given ID. + if not isinstance(id, int): + raise TypeError(f'id must be an int, got {id!r}') + id = int(id) + if _whence is None: + if _ownsref: + _whence = _interpreters.WHENCE_STDLIB + else: + _whence = _interpreters.whence(id) + assert _whence in cls._WHENCE_TO_STR, repr(_whence) + if _ownsref is None: + _ownsref = (_whence == _interpreters.WHENCE_STDLIB) + try: + self = _known[id] + assert hasattr(self, '_ownsref') + except KeyError: + self = super().__new__(cls) + _known[id] = self + self._id = id + self._whence = _whence + self._ownsref = _ownsref + if _ownsref: + # This may raise InterpreterNotFoundError: + _interpreters.incref(id) + return self + + def __repr__(self): + return f'{type(self).__name__}({self.id})' + + def __hash__(self): + return hash(self._id) + + def __del__(self): + self._decref() + + # for pickling: + def __reduce__(self): + return (type(self), (self._id,)) + + # gh-135729: Globals might be destroyed by the time this is called, so we + # need to keep references ourself + def _decref(self, *, + InterpreterNotFoundError=InterpreterNotFoundError, + _interp_decref=_interpreters.decref, + ): + if not self._ownsref: + return + self._ownsref = False + try: + _interp_decref(self._id) + except InterpreterNotFoundError: + pass + + @property + def id(self): + return self._id + + @property + def whence(self): + return self._WHENCE_TO_STR[self._whence] + + def is_running(self): + """Return whether or not the identified interpreter is running.""" + return _interpreters.is_running(self._id) + + # Everything past here is available only to interpreters created by + # interpreters.create(). + + def close(self): + """Finalize and destroy the interpreter. + + Attempting to destroy the current interpreter results + in an InterpreterError. + """ + return _interpreters.destroy(self._id, restrict=True) + + def prepare_main(self, ns=None, /, **kwargs): + """Bind the given values into the interpreter's __main__. + + The values must be shareable. + """ + ns = dict(ns, **kwargs) if ns is not None else kwargs + _interpreters.set___main___attrs(self._id, ns, restrict=True) + + def exec(self, code, /): + """Run the given source code in the interpreter. + + This is essentially the same as calling the builtin "exec" + with this interpreter, using the __dict__ of its __main__ + module as both globals and locals. + + There is no return value. + + If the code raises an unhandled exception then an ExecutionFailed + exception is raised, which summarizes the unhandled exception. + The actual exception is discarded because objects cannot be + shared between interpreters. + + This blocks the current Python thread until done. During + that time, the previous interpreter is allowed to run + in other threads. + """ + excinfo = _interpreters.exec(self._id, code, restrict=True) + if excinfo is not None: + raise ExecutionFailed(excinfo) + + def _call(self, callable, args, kwargs): + res, excinfo = _interpreters.call(self._id, callable, args, kwargs, restrict=True) + if excinfo is not None: + raise ExecutionFailed(excinfo) + return res + + def call(self, callable, /, *args, **kwargs): + """Call the object in the interpreter with given args/kwargs. + + Nearly all callables, args, kwargs, and return values are + supported. All "shareable" objects are supported, as are + "stateless" functions (meaning non-closures that do not use + any globals). This method will fall back to pickle. + + If the callable raises an exception then the error display + (including full traceback) is sent back between the interpreters + and an ExecutionFailed exception is raised, much like what + happens with Interpreter.exec(). + """ + return self._call(callable, args, kwargs) + + def call_in_thread(self, callable, /, *args, **kwargs): + """Return a new thread that calls the object in the interpreter. + + The return value and any raised exception are discarded. + """ + t = threading.Thread(target=self._call, args=(callable, args, kwargs)) + t.start() + return t diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/interpreters/__pycache__/__init__.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/interpreters/__pycache__/__init__.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3da611d5bc830c848baceb6ae294bf1385da34bf Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/interpreters/__pycache__/__init__.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/interpreters/__pycache__/_crossinterp.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/interpreters/__pycache__/_crossinterp.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e52de6a5e4b0e714df8325c365d2958d1a1bea9d Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/interpreters/__pycache__/_crossinterp.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/interpreters/__pycache__/_queues.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/interpreters/__pycache__/_queues.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8c9839a0fa284bfcbc8bcd4064dc409e2b001f51 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/interpreters/__pycache__/_queues.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/interpreters/_crossinterp.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/interpreters/_crossinterp.py new file mode 100644 index 0000000000000000000000000000000000000000..a5f46b20fbb4c561f2878a6bbdc1792ea3b46e4e --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/interpreters/_crossinterp.py @@ -0,0 +1,107 @@ +"""Common code between queues and channels.""" + + +class ItemInterpreterDestroyed(Exception): + """Raised when trying to get an item whose interpreter was destroyed.""" + + +class classonly: + """A non-data descriptor that makes a value only visible on the class. + + This is like the "classmethod" builtin, but does not show up on + instances of the class. It may be used as a decorator. + """ + + def __init__(self, value): + self.value = value + self.getter = classmethod(value).__get__ + self.name = None + + def __set_name__(self, cls, name): + if self.name is not None: + raise TypeError('already used') + self.name = name + + def __get__(self, obj, cls): + if obj is not None: + raise AttributeError(self.name) + # called on the class + return self.getter(None, cls) + + +class UnboundItem: + """Represents a cross-interpreter item no longer bound to an interpreter. + + An item is unbound when the interpreter that added it to the + cross-interpreter container is destroyed. + """ + + __slots__ = () + + @classonly + def singleton(cls, kind, module, name='UNBOUND'): + doc = cls.__doc__ + if doc: + doc = doc.replace( + 'cross-interpreter container', kind, + ).replace( + 'cross-interpreter', kind, + ) + subclass = type( + f'Unbound{kind.capitalize()}Item', + (cls,), + { + "_MODULE": module, + "_NAME": name, + "__doc__": doc, + }, + ) + return object.__new__(subclass) + + _MODULE = __name__ + _NAME = 'UNBOUND' + + def __new__(cls): + raise Exception(f'use {cls._MODULE}.{cls._NAME}') + + def __repr__(self): + return f'{self._MODULE}.{self._NAME}' +# return f'interpreters._queues.UNBOUND' + + +UNBOUND = object.__new__(UnboundItem) +UNBOUND_ERROR = object() +UNBOUND_REMOVE = object() + +_UNBOUND_CONSTANT_TO_FLAG = { + UNBOUND_REMOVE: 1, + UNBOUND_ERROR: 2, + UNBOUND: 3, +} +_UNBOUND_FLAG_TO_CONSTANT = {v: k + for k, v in _UNBOUND_CONSTANT_TO_FLAG.items()} + + +def serialize_unbound(unbound): + op = unbound + try: + flag = _UNBOUND_CONSTANT_TO_FLAG[op] + except KeyError: + raise NotImplementedError(f'unsupported unbound replacement op {op!r}') + return flag, + + +def resolve_unbound(flag, exctype_destroyed): + try: + op = _UNBOUND_FLAG_TO_CONSTANT[flag] + except KeyError: + raise NotImplementedError(f'unsupported unbound replacement op {flag!r}') + if op is UNBOUND_REMOVE: + # "remove" not possible here + raise NotImplementedError + elif op is UNBOUND_ERROR: + raise exctype_destroyed("item's original interpreter destroyed") + elif op is UNBOUND: + return UNBOUND + else: + raise NotImplementedError(repr(op)) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/interpreters/_queues.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/interpreters/_queues.py new file mode 100644 index 0000000000000000000000000000000000000000..81ea1098d7f9f317d82db2b29c23d38f010e8a09 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/concurrent/interpreters/_queues.py @@ -0,0 +1,289 @@ +"""Cross-interpreter Queues High Level Module.""" + +import pickle +import queue +import time +import weakref +import _interpqueues as _queues +from . import _crossinterp + +# aliases: +from _interpqueues import ( + QueueError, QueueNotFoundError, +) +from ._crossinterp import ( + UNBOUND_ERROR, UNBOUND_REMOVE, +) + +__all__ = [ + 'UNBOUND', 'UNBOUND_ERROR', 'UNBOUND_REMOVE', + 'create', 'list_all', + 'Queue', + 'QueueError', 'QueueNotFoundError', 'QueueEmpty', 'QueueFull', + 'ItemInterpreterDestroyed', +] + + +class QueueEmpty(QueueError, queue.Empty): + """Raised from get_nowait() when the queue is empty. + + It is also raised from get() if it times out. + """ + + +class QueueFull(QueueError, queue.Full): + """Raised from put_nowait() when the queue is full. + + It is also raised from put() if it times out. + """ + + +class ItemInterpreterDestroyed(QueueError, + _crossinterp.ItemInterpreterDestroyed): + """Raised from get() and get_nowait().""" + + +_SHARED_ONLY = 0 +_PICKLED = 1 + + +UNBOUND = _crossinterp.UnboundItem.singleton('queue', __name__) + + +def _serialize_unbound(unbound): + if unbound is UNBOUND: + unbound = _crossinterp.UNBOUND + return _crossinterp.serialize_unbound(unbound) + + +def _resolve_unbound(flag): + resolved = _crossinterp.resolve_unbound(flag, ItemInterpreterDestroyed) + if resolved is _crossinterp.UNBOUND: + resolved = UNBOUND + return resolved + + +def create(maxsize=0, *, unbounditems=UNBOUND): + """Return a new cross-interpreter queue. + + The queue may be used to pass data safely between interpreters. + + "unbounditems" sets the default for Queue.put(); see that method for + supported values. The default value is UNBOUND, which replaces + the unbound item. + """ + unbound = _serialize_unbound(unbounditems) + unboundop, = unbound + qid = _queues.create(maxsize, unboundop, -1) + self = Queue(qid) + self._set_unbound(unboundop, unbounditems) + return self + + +def list_all(): + """Return a list of all open queues.""" + queues = [] + for qid, unboundop, _ in _queues.list_all(): + self = Queue(qid) + if not hasattr(self, '_unbound'): + self._set_unbound(unboundop) + else: + assert self._unbound[0] == unboundop + queues.append(self) + return queues + + +_known_queues = weakref.WeakValueDictionary() + +class Queue: + """A cross-interpreter queue.""" + + def __new__(cls, id, /): + # There is only one instance for any given ID. + if isinstance(id, int): + id = int(id) + else: + raise TypeError(f'id must be an int, got {id!r}') + try: + self = _known_queues[id] + except KeyError: + self = super().__new__(cls) + self._id = id + _known_queues[id] = self + _queues.bind(id) + return self + + def __del__(self): + try: + _queues.release(self._id) + except QueueNotFoundError: + pass + try: + del _known_queues[self._id] + except KeyError: + pass + + def __repr__(self): + return f'{type(self).__name__}({self.id})' + + def __hash__(self): + return hash(self._id) + + # for pickling: + def __reduce__(self): + return (type(self), (self._id,)) + + def _set_unbound(self, op, items=None): + assert not hasattr(self, '_unbound') + if items is None: + items = _resolve_unbound(op) + unbound = (op, items) + self._unbound = unbound + return unbound + + @property + def id(self): + return self._id + + @property + def unbounditems(self): + try: + _, items = self._unbound + except AttributeError: + op, _ = _queues.get_queue_defaults(self._id) + _, items = self._set_unbound(op) + return items + + @property + def maxsize(self): + try: + return self._maxsize + except AttributeError: + self._maxsize = _queues.get_maxsize(self._id) + return self._maxsize + + def empty(self): + return self.qsize() == 0 + + def full(self): + return _queues.is_full(self._id) + + def qsize(self): + return _queues.get_count(self._id) + + def put(self, obj, block=True, timeout=None, *, + unbounditems=None, + _delay=10 / 1000, # 10 milliseconds + ): + """Add the object to the queue. + + If "block" is true, this blocks while the queue is full. + + For most objects, the object received through Queue.get() will + be a new one, equivalent to the original and not sharing any + actual underlying data. The notable exceptions include + cross-interpreter types (like Queue) and memoryview, where the + underlying data is actually shared. Furthermore, some types + can be sent through a queue more efficiently than others. This + group includes various immutable types like int, str, bytes, and + tuple (if the items are likewise efficiently shareable). See interpreters.is_shareable(). + + "unbounditems" controls the behavior of Queue.get() for the given + object if the current interpreter (calling put()) is later + destroyed. + + If "unbounditems" is None (the default) then it uses the + queue's default, set with create_queue(), + which is usually UNBOUND. + + If "unbounditems" is UNBOUND_ERROR then get() will raise an + ItemInterpreterDestroyed exception if the original interpreter + has been destroyed. This does not otherwise affect the queue; + the next call to put() will work like normal, returning the next + item in the queue. + + If "unbounditems" is UNBOUND_REMOVE then the item will be removed + from the queue as soon as the original interpreter is destroyed. + Be aware that this will introduce an imbalance between put() + and get() calls. + + If "unbounditems" is UNBOUND then it is returned by get() in place + of the unbound item. + """ + if not block: + return self.put_nowait(obj, unbounditems=unbounditems) + if unbounditems is None: + unboundop = -1 + else: + unboundop, = _serialize_unbound(unbounditems) + if timeout is not None: + timeout = int(timeout) + if timeout < 0: + raise ValueError(f'timeout value must be non-negative') + end = time.time() + timeout + while True: + try: + _queues.put(self._id, obj, unboundop) + except QueueFull as exc: + if timeout is not None and time.time() >= end: + raise # re-raise + time.sleep(_delay) + else: + break + + def put_nowait(self, obj, *, unbounditems=None): + if unbounditems is None: + unboundop = -1 + else: + unboundop, = _serialize_unbound(unbounditems) + _queues.put(self._id, obj, unboundop) + + def get(self, block=True, timeout=None, *, + _delay=10 / 1000, # 10 milliseconds + ): + """Return the next object from the queue. + + If "block" is true, this blocks while the queue is empty. + + If the next item's original interpreter has been destroyed + then the "next object" is determined by the value of the + "unbounditems" argument to put(). + """ + if not block: + return self.get_nowait() + if timeout is not None: + timeout = int(timeout) + if timeout < 0: + raise ValueError(f'timeout value must be non-negative') + end = time.time() + timeout + while True: + try: + obj, unboundop = _queues.get(self._id) + except QueueEmpty as exc: + if timeout is not None and time.time() >= end: + raise # re-raise + time.sleep(_delay) + else: + break + if unboundop is not None: + assert obj is None, repr(obj) + return _resolve_unbound(unboundop) + return obj + + def get_nowait(self): + """Return the next object from the channel. + + If the queue is empty then raise QueueEmpty. Otherwise this + is the same as get(). + """ + try: + obj, unboundop = _queues.get(self._id) + except QueueEmpty as exc: + raise # re-raise + if unboundop is not None: + assert obj is None, repr(obj) + return _resolve_unbound(unboundop) + return obj + + +_queues._register_heap_types(Queue, QueueEmpty, QueueFull) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/__pycache__/__init__.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/__pycache__/__init__.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..03bc932b2e7b8a93eabf2d86daca78b761d17997 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/__pycache__/__init__.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/__pycache__/_aix.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/__pycache__/_aix.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a42d5501be7ea7244299ddc905978dadaa37b1e5 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/__pycache__/_aix.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/__pycache__/_endian.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/__pycache__/_endian.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..106b860cba72a0e55787b7f8955873495d4dadfa Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/__pycache__/_endian.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/__pycache__/_layout.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/__pycache__/_layout.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e2a0ed3533e282188764ccefc3fbb3e4741874b3 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/__pycache__/_layout.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/__pycache__/util.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/__pycache__/util.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e167b8bd45374899b3116f51c6a13af98cf51294 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/__pycache__/util.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/__pycache__/wintypes.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/__pycache__/wintypes.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dd21bac20ea5b8ba46e67783a3f08040a7466142 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/__pycache__/wintypes.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/README.ctypes b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/README.ctypes new file mode 100644 index 0000000000000000000000000000000000000000..2866e9f349288a4059e7bacee8f0ad9ed886d068 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/README.ctypes @@ -0,0 +1,7 @@ +Files in this directory come from Bob Ippolito's py2app. + +License: Any components of the py2app suite may be distributed under +the MIT or PSF open source licenses. + +This is version 1.0, SVN revision 789, from 2006/01/25. +The main repository is http://svn.red-bean.com/bob/macholib/trunk/macholib/ \ No newline at end of file diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/__init__.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5621defccd61d1c4b0c64b8e136ef4357052dcb3 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/__init__.py @@ -0,0 +1,9 @@ +""" +Enough Mach-O to make your head spin. + +See the relevant header files in /usr/include/mach-o + +And also Apple's documentation. +""" + +__version__ = '1.0' diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/__pycache__/__init__.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/__pycache__/__init__.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..05fedf368309ed69831948205cb2b264f591fdaf Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/__pycache__/__init__.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/__pycache__/dyld.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/__pycache__/dyld.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..226f2c4a3b8b7d20483c95f6b8548ab81d25e6a0 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/__pycache__/dyld.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/__pycache__/dylib.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/__pycache__/dylib.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b82b6bc2d20be23551702eb18718ab586a059e2a Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/__pycache__/dylib.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/__pycache__/framework.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/__pycache__/framework.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dc6740a846c01a28137cc705bb122a8f4815c248 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/__pycache__/framework.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/dyld.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/dyld.py new file mode 100644 index 0000000000000000000000000000000000000000..ab9b01c87e27d15d7fc02c2b25270f7d17428780 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/dyld.py @@ -0,0 +1,169 @@ +""" +dyld emulation +""" + +import os +from ctypes.macholib.framework import framework_info +from ctypes.macholib.dylib import dylib_info +from itertools import * +try: + from _ctypes import _dyld_shared_cache_contains_path +except ImportError: + def _dyld_shared_cache_contains_path(*args): + raise NotImplementedError + +__all__ = [ + 'dyld_find', 'framework_find', + 'framework_info', 'dylib_info', +] + +# These are the defaults as per man dyld(1) +# +DEFAULT_FRAMEWORK_FALLBACK = [ + os.path.expanduser("~/Library/Frameworks"), + "/Library/Frameworks", + "/Network/Library/Frameworks", + "/System/Library/Frameworks", +] + +DEFAULT_LIBRARY_FALLBACK = [ + os.path.expanduser("~/lib"), + "/usr/local/lib", + "/lib", + "/usr/lib", +] + +def dyld_env(env, var): + if env is None: + env = os.environ + rval = env.get(var) + if rval is None: + return [] + return rval.split(':') + +def dyld_image_suffix(env=None): + if env is None: + env = os.environ + return env.get('DYLD_IMAGE_SUFFIX') + +def dyld_framework_path(env=None): + return dyld_env(env, 'DYLD_FRAMEWORK_PATH') + +def dyld_library_path(env=None): + return dyld_env(env, 'DYLD_LIBRARY_PATH') + +def dyld_fallback_framework_path(env=None): + return dyld_env(env, 'DYLD_FALLBACK_FRAMEWORK_PATH') + +def dyld_fallback_library_path(env=None): + return dyld_env(env, 'DYLD_FALLBACK_LIBRARY_PATH') + +def dyld_image_suffix_search(iterator, env=None): + """For a potential path iterator, add DYLD_IMAGE_SUFFIX semantics""" + suffix = dyld_image_suffix(env) + if suffix is None: + return iterator + def _inject(iterator=iterator, suffix=suffix): + for path in iterator: + if path.endswith('.dylib'): + yield path[:-len('.dylib')] + suffix + '.dylib' + else: + yield path + suffix + yield path + return _inject() + +def dyld_override_search(name, env=None): + # If DYLD_FRAMEWORK_PATH is set and this dylib_name is a + # framework name, use the first file that exists in the framework + # path if any. If there is none go on to search the DYLD_LIBRARY_PATH + # if any. + + framework = framework_info(name) + + if framework is not None: + for path in dyld_framework_path(env): + yield os.path.join(path, framework['name']) + + # If DYLD_LIBRARY_PATH is set then use the first file that exists + # in the path. If none use the original name. + for path in dyld_library_path(env): + yield os.path.join(path, os.path.basename(name)) + +def dyld_executable_path_search(name, executable_path=None): + # If we haven't done any searching and found a library and the + # dylib_name starts with "@executable_path/" then construct the + # library name. + if not executable_path: + import sys + if sys.prefix: + executable_path = os.path.join(sys.prefix, 'bin') + if name.startswith('@executable_path/') and executable_path is not None: + yield os.path.join(executable_path, name[len('@executable_path/'):]) + +def dyld_default_search(name, env=None): + yield name + + framework = framework_info(name) + + if framework is not None: + fallback_framework_path = dyld_fallback_framework_path(env) + for path in fallback_framework_path: + yield os.path.join(path, framework['name']) + + fallback_library_path = dyld_fallback_library_path(env) + for path in fallback_library_path: + yield os.path.join(path, os.path.basename(name)) + + if framework is not None and not fallback_framework_path: + for path in DEFAULT_FRAMEWORK_FALLBACK: + yield os.path.join(path, framework['name']) + + if not fallback_library_path: + for path in DEFAULT_LIBRARY_FALLBACK: + yield os.path.join(path, os.path.basename(name)) + +def dyld_find(name, executable_path=None, env=None): + """ + Find a library or framework using dyld semantics + """ + for path in dyld_image_suffix_search(chain( + dyld_override_search(name, env), + dyld_executable_path_search(name, executable_path), + dyld_default_search(name, env), + ), env): + + if os.path.isfile(path): + return path + try: + if _dyld_shared_cache_contains_path(path): + return path + except NotImplementedError: + pass + + raise ValueError("dylib %s could not be found" % (name,)) + +def framework_find(fn, executable_path=None, env=None): + """ + Find a framework using dyld semantics in a very loose manner. + + Will take input such as: + Python + Python.framework + Python.framework/Versions/Current + """ + error = None + try: + return dyld_find(fn, executable_path=executable_path, env=env) + except ValueError as e: + error = e + fmwk_index = fn.rfind('.framework') + if fmwk_index == -1: + fmwk_index = len(fn) + fn += '.framework' + fn = os.path.join(fn, os.path.basename(fn[:fmwk_index])) + try: + return dyld_find(fn, executable_path=executable_path, env=env) + except ValueError: + raise error + finally: + error = None diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/dylib.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/dylib.py new file mode 100644 index 0000000000000000000000000000000000000000..0ad4cba8da3521756942a18942bd11aaaad95a58 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/dylib.py @@ -0,0 +1,42 @@ +""" +Generic dylib path manipulation +""" + +import re + +__all__ = ['dylib_info'] + +DYLIB_RE = re.compile(r"""(?x) +(?P^.*)(?:^|/) +(?P + (?P\w+?) + (?:\.(?P[^._]+))? + (?:_(?P[^._]+))? + \.dylib$ +) +""") + +def dylib_info(filename): + """ + A dylib name can take one of the following four forms: + Location/Name.SomeVersion_Suffix.dylib + Location/Name.SomeVersion.dylib + Location/Name_Suffix.dylib + Location/Name.dylib + + returns None if not found or a mapping equivalent to: + dict( + location='Location', + name='Name.SomeVersion_Suffix.dylib', + shortname='Name', + version='SomeVersion', + suffix='Suffix', + ) + + Note that SomeVersion and Suffix are optional and may be None + if not present. + """ + is_dylib = DYLIB_RE.match(filename) + if not is_dylib: + return None + return is_dylib.groupdict() diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/fetch_macholib b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/fetch_macholib new file mode 100644 index 0000000000000000000000000000000000000000..e6d6a2265956293a8ac5eeb0e0e32309694a4a66 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/fetch_macholib @@ -0,0 +1,2 @@ +#!/bin/sh +svn export --force http://svn.red-bean.com/bob/macholib/trunk/macholib/ . diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/fetch_macholib.bat b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/fetch_macholib.bat new file mode 100644 index 0000000000000000000000000000000000000000..f474d5cd0a26f72be2c53228a4465c8b91a0e649 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/fetch_macholib.bat @@ -0,0 +1 @@ +svn export --force http://svn.red-bean.com/bob/macholib/trunk/macholib/ . diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/framework.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/framework.py new file mode 100644 index 0000000000000000000000000000000000000000..495679fff19d418a8248c492bb5959f52787123c --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/ctypes/macholib/framework.py @@ -0,0 +1,42 @@ +""" +Generic framework path manipulation +""" + +import re + +__all__ = ['framework_info'] + +STRICT_FRAMEWORK_RE = re.compile(r"""(?x) +(?P^.*)(?:^|/) +(?P + (?P\w+).framework/ + (?:Versions/(?P[^/]+)/)? + (?P=shortname) + (?:_(?P[^_]+))? +)$ +""") + +def framework_info(filename): + """ + A framework name can take one of the following four forms: + Location/Name.framework/Versions/SomeVersion/Name_Suffix + Location/Name.framework/Versions/SomeVersion/Name + Location/Name.framework/Name_Suffix + Location/Name.framework/Name + + returns None if not found, or a mapping equivalent to: + dict( + location='Location', + name='Name.framework/Versions/SomeVersion/Name_Suffix', + shortname='Name', + version='SomeVersion', + suffix='Suffix', + ) + + Note that SomeVersion and Suffix are optional and may be None + if not present + """ + is_framework = STRICT_FRAMEWORK_RE.match(filename) + if not is_framework: + return None + return is_framework.groupdict() diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/curses/__pycache__/__init__.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/curses/__pycache__/__init__.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5dfe8729d814a857357b6493d99397349391259d Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/curses/__pycache__/__init__.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/curses/__pycache__/ascii.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/curses/__pycache__/ascii.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6726658ff0201ca2f2ada1f1866051fee62ffbce Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/curses/__pycache__/ascii.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/curses/__pycache__/has_key.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/curses/__pycache__/has_key.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c3c36b1fd740784f581527db4faea90fb87cc31c Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/curses/__pycache__/has_key.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/curses/__pycache__/panel.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/curses/__pycache__/panel.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af5371113ea88acc8f6aabc89de98d950b154cbf Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/curses/__pycache__/panel.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/curses/__pycache__/textpad.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/curses/__pycache__/textpad.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4dfb261849fe39ba93472840545caa5b9a50d462 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/curses/__pycache__/textpad.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/dbm/__pycache__/__init__.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/dbm/__pycache__/__init__.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..643c6e7793611c8d71a36e7b22f420fda1ba59c3 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/dbm/__pycache__/__init__.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/dbm/__pycache__/dumb.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/dbm/__pycache__/dumb.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5ea5268eb9586434cba0916ddfb604db1dced298 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/dbm/__pycache__/dumb.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/dbm/__pycache__/gnu.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/dbm/__pycache__/gnu.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..50092999eb87f8f2445d27aab416639186790f1c Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/dbm/__pycache__/gnu.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/dbm/__pycache__/ndbm.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/dbm/__pycache__/ndbm.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8cbe69cfddd93e71e983e62f2486a8786f66a18f Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/dbm/__pycache__/ndbm.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/dbm/__pycache__/sqlite3.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/dbm/__pycache__/sqlite3.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ba8933d11c3b59d3dca6bfa9c30b0e7154d244ea Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/dbm/__pycache__/sqlite3.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/__init__.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/__init__.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1e8ff779db4019c8a07f3a0cd79e885a477d84d7 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/__init__.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/_encoded_words.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/_encoded_words.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5babda82874e47010ee0131387083bbcf7f05d2c Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/_encoded_words.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/_parseaddr.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/_parseaddr.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9d4dcbca771ed43d5d745f88ec0492af61e26888 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/_parseaddr.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/_policybase.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/_policybase.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fa4e184993b9734e08fd5a18a29fc7bcbf63aab5 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/_policybase.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/base64mime.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/base64mime.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0079e4841156f90ccf00a30c7c313246568587af Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/base64mime.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/charset.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/charset.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b682eb33b2e22eedd92d79618025dbfe9c848e36 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/charset.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/contentmanager.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/contentmanager.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..58f2b7f9a477833ac7fce40eff664fd8ef6056b2 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/contentmanager.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/encoders.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/encoders.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5195ed5c1e3bbaf1220578a98c50b96f9c4c636b Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/encoders.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/errors.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/errors.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5c15e1c86ff0bedb8c385aac414db42682706fcd Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/errors.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/feedparser.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/feedparser.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9cbe217877cccb2be97d4301b79704c122fc14b4 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/feedparser.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/generator.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/generator.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..422bf3f25af2733f89deabbf92c70a477df441a5 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/generator.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/header.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/header.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..47b594cc1669d2f968333db00af8cc603808686d Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/header.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/headerregistry.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/headerregistry.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..80a510ae0f3bece777d4f6060cc4d8090a6d1725 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/headerregistry.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/iterators.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/iterators.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1b8aef6a1f399d111e598d1d9b25c74d8df11c62 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/iterators.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/message.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/message.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..213cb8808c119da8a58605900e630a47c0152351 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/message.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/parser.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/parser.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bbc9538cc9b82cf52df12b245c14f01d8a9e1b05 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/parser.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/policy.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/policy.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f96a2d62bd0ed7fd73b38c4a418b13c6b4a89fb1 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/policy.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/quoprimime.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/quoprimime.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6e0258ef67eee1499bc79e26a37fa801ba7bbc91 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/quoprimime.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/utils.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/utils.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d3c1ddf1f4a5cf79dd954c18a756c2534607265d Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/__pycache__/utils.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__init__.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/__init__.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/__init__.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3ee14d4f53c94ce3f247646b651e449af5eb5aa0 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/__init__.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/application.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/application.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6887bbcf075d608161a202ed65c4a87b3657af76 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/application.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/audio.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/audio.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9334c4bed4af0fa77be655b56eb0fc89d0a968cd Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/audio.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/base.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/base.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..80631b57523f673b6e7bd7261d3e023e3063d72a Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/base.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/image.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/image.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..da472d70b9e63116198b299f2b8be7208b71cfac Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/image.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/message.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/message.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b9bebbf3c4ffc4a26bf640142bf631cacba80cba Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/message.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/multipart.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/multipart.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a77e8ad5af1a934fb664be2950b94f7347b9c2d9 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/multipart.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/nonmultipart.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/nonmultipart.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bd8e78ef9b9aa1cb7dc6963d270b21cf181f6a13 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/nonmultipart.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/text.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/text.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ff79bc14f580bb052f84d9d88d524653bb00a7b7 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/__pycache__/text.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/application.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/application.py new file mode 100644 index 0000000000000000000000000000000000000000..9a9d213d2a940d1cdb094dbe9c3f2d2cdde214eb --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/application.py @@ -0,0 +1,37 @@ +# Copyright (C) 2001 Python Software Foundation +# Author: Keith Dart +# Contact: email-sig@python.org + +"""Class representing application/* type MIME documents.""" + +__all__ = ["MIMEApplication"] + +from email import encoders +from email.mime.nonmultipart import MIMENonMultipart + + +class MIMEApplication(MIMENonMultipart): + """Class for generating application/* MIME documents.""" + + def __init__(self, _data, _subtype='octet-stream', + _encoder=encoders.encode_base64, *, policy=None, **_params): + """Create an application/* type MIME document. + + _data contains the bytes for the raw application data. + + _subtype is the MIME content type subtype, defaulting to + 'octet-stream'. + + _encoder is a function which will perform the actual encoding for + transport of the application data, defaulting to base64 encoding. + + Any additional keyword arguments are passed to the base class + constructor, which turns them into parameters on the Content-Type + header. + """ + if _subtype is None: + raise TypeError('Invalid application MIME subtype') + MIMENonMultipart.__init__(self, 'application', _subtype, policy=policy, + **_params) + self.set_payload(_data) + _encoder(self) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/audio.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/audio.py new file mode 100644 index 0000000000000000000000000000000000000000..85f4a955238c52060e01a688301e276d50fdb3f6 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/audio.py @@ -0,0 +1,97 @@ +# Copyright (C) 2001 Python Software Foundation +# Author: Anthony Baxter +# Contact: email-sig@python.org + +"""Class representing audio/* type MIME documents.""" + +__all__ = ['MIMEAudio'] + +from email import encoders +from email.mime.nonmultipart import MIMENonMultipart + + +class MIMEAudio(MIMENonMultipart): + """Class for generating audio/* MIME documents.""" + + def __init__(self, _audiodata, _subtype=None, + _encoder=encoders.encode_base64, *, policy=None, **_params): + """Create an audio/* type MIME document. + + _audiodata contains the bytes for the raw audio data. If this data + can be decoded as au, wav, aiff, or aifc, then the + subtype will be automatically included in the Content-Type header. + Otherwise, you can specify the specific audio subtype via the + _subtype parameter. If _subtype is not given, and no subtype can be + guessed, a TypeError is raised. + + _encoder is a function which will perform the actual encoding for + transport of the image data. It takes one argument, which is this + Image instance. It should use get_payload() and set_payload() to + change the payload to the encoded form. It should also add any + Content-Transfer-Encoding or other headers to the message as + necessary. The default encoding is Base64. + + Any additional keyword arguments are passed to the base class + constructor, which turns them into parameters on the Content-Type + header. + """ + if _subtype is None: + _subtype = _what(_audiodata) + if _subtype is None: + raise TypeError('Could not find audio MIME subtype') + MIMENonMultipart.__init__(self, 'audio', _subtype, policy=policy, + **_params) + self.set_payload(_audiodata) + _encoder(self) + + +_rules = [] + + +# Originally from the sndhdr module. +# +# There are others in sndhdr that don't have MIME types. :( +# Additional ones to be added to sndhdr? midi, mp3, realaudio, wma?? +def _what(data): + # Try to identify a sound file type. + # + # sndhdr.what() had a pretty cruddy interface, unfortunately. This is why + # we re-do it here. It would be easier to reverse engineer the Unix 'file' + # command and use the standard 'magic' file, as shipped with a modern Unix. + for testfn in _rules: + if res := testfn(data): + return res + else: + return None + + +def rule(rulefunc): + _rules.append(rulefunc) + return rulefunc + + +@rule +def _aiff(h): + if not h.startswith(b'FORM'): + return None + if h[8:12] in {b'AIFC', b'AIFF'}: + return 'x-aiff' + else: + return None + + +@rule +def _au(h): + if h.startswith(b'.snd'): + return 'basic' + else: + return None + + +@rule +def _wav(h): + # 'RIFF' 'WAVE' 'fmt ' + if not h.startswith(b'RIFF') or h[8:12] != b'WAVE' or h[12:16] != b'fmt ': + return None + else: + return "x-wav" diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/base.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/base.py new file mode 100644 index 0000000000000000000000000000000000000000..da4c6e591a5cb8545d8eca5892215fce2e63ee6c --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/base.py @@ -0,0 +1,29 @@ +# Copyright (C) 2001 Python Software Foundation +# Author: Barry Warsaw +# Contact: email-sig@python.org + +"""Base class for MIME specializations.""" + +__all__ = ['MIMEBase'] + +import email.policy + +from email import message + + +class MIMEBase(message.Message): + """Base class for MIME specializations.""" + + def __init__(self, _maintype, _subtype, *, policy=None, **_params): + """This constructor adds a Content-Type: and a MIME-Version: header. + + The Content-Type: header is taken from the _maintype and _subtype + arguments. Additional parameters for this header are taken from the + keyword arguments. + """ + if policy is None: + policy = email.policy.compat32 + message.Message.__init__(self, policy=policy) + ctype = '%s/%s' % (_maintype, _subtype) + self.add_header('Content-Type', ctype, **_params) + self['MIME-Version'] = '1.0' diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/image.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/image.py new file mode 100644 index 0000000000000000000000000000000000000000..dab9685848172b34e255c01d947be57372dc13c0 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/image.py @@ -0,0 +1,152 @@ +# Copyright (C) 2001 Python Software Foundation +# Author: Barry Warsaw +# Contact: email-sig@python.org + +"""Class representing image/* type MIME documents.""" + +__all__ = ['MIMEImage'] + +from email import encoders +from email.mime.nonmultipart import MIMENonMultipart + + +class MIMEImage(MIMENonMultipart): + """Class for generating image/* type MIME documents.""" + + def __init__(self, _imagedata, _subtype=None, + _encoder=encoders.encode_base64, *, policy=None, **_params): + """Create an image/* type MIME document. + + _imagedata contains the bytes for the raw image data. If the data + type can be detected (jpeg, png, gif, tiff, rgb, pbm, pgm, ppm, + rast, xbm, bmp, webp, and exr attempted), then the subtype will be + automatically included in the Content-Type header. Otherwise, you can + specify the specific image subtype via the _subtype parameter. + + _encoder is a function which will perform the actual encoding for + transport of the image data. It takes one argument, which is this + Image instance. It should use get_payload() and set_payload() to + change the payload to the encoded form. It should also add any + Content-Transfer-Encoding or other headers to the message as + necessary. The default encoding is Base64. + + Any additional keyword arguments are passed to the base class + constructor, which turns them into parameters on the Content-Type + header. + """ + _subtype = _what(_imagedata) if _subtype is None else _subtype + if _subtype is None: + raise TypeError('Could not guess image MIME subtype') + MIMENonMultipart.__init__(self, 'image', _subtype, policy=policy, + **_params) + self.set_payload(_imagedata) + _encoder(self) + + +_rules = [] + + +# Originally from the imghdr module. +def _what(data): + for rule in _rules: + if res := rule(data): + return res + else: + return None + + +def rule(rulefunc): + _rules.append(rulefunc) + return rulefunc + + +@rule +def _jpeg(h): + """JPEG data with JFIF or Exif markers; and raw JPEG""" + if h[6:10] in (b'JFIF', b'Exif'): + return 'jpeg' + elif h[:4] == b'\xff\xd8\xff\xdb': + return 'jpeg' + + +@rule +def _png(h): + if h.startswith(b'\211PNG\r\n\032\n'): + return 'png' + + +@rule +def _gif(h): + """GIF ('87 and '89 variants)""" + if h[:6] in (b'GIF87a', b'GIF89a'): + return 'gif' + + +@rule +def _tiff(h): + """TIFF (can be in Motorola or Intel byte order)""" + if h[:2] in (b'MM', b'II'): + return 'tiff' + + +@rule +def _rgb(h): + """SGI image library""" + if h.startswith(b'\001\332'): + return 'rgb' + + +@rule +def _pbm(h): + """PBM (portable bitmap)""" + if len(h) >= 3 and \ + h[0] == ord(b'P') and h[1] in b'14' and h[2] in b' \t\n\r': + return 'pbm' + + +@rule +def _pgm(h): + """PGM (portable graymap)""" + if len(h) >= 3 and \ + h[0] == ord(b'P') and h[1] in b'25' and h[2] in b' \t\n\r': + return 'pgm' + + +@rule +def _ppm(h): + """PPM (portable pixmap)""" + if len(h) >= 3 and \ + h[0] == ord(b'P') and h[1] in b'36' and h[2] in b' \t\n\r': + return 'ppm' + + +@rule +def _rast(h): + """Sun raster file""" + if h.startswith(b'\x59\xA6\x6A\x95'): + return 'rast' + + +@rule +def _xbm(h): + """X bitmap (X10 or X11)""" + if h.startswith(b'#define '): + return 'xbm' + + +@rule +def _bmp(h): + if h.startswith(b'BM'): + return 'bmp' + + +@rule +def _webp(h): + if h.startswith(b'RIFF') and h[8:12] == b'WEBP': + return 'webp' + + +@rule +def _exr(h): + if h.startswith(b'\x76\x2f\x31\x01'): + return 'exr' diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/message.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/message.py new file mode 100644 index 0000000000000000000000000000000000000000..13d9ff599f86dbb9383442189f170276cd88154a --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/message.py @@ -0,0 +1,33 @@ +# Copyright (C) 2001 Python Software Foundation +# Author: Barry Warsaw +# Contact: email-sig@python.org + +"""Class representing message/* MIME documents.""" + +__all__ = ['MIMEMessage'] + +from email import message +from email.mime.nonmultipart import MIMENonMultipart + + +class MIMEMessage(MIMENonMultipart): + """Class representing message/* MIME documents.""" + + def __init__(self, _msg, _subtype='rfc822', *, policy=None): + """Create a message/* type MIME document. + + _msg is a message object and must be an instance of Message, or a + derived class of Message, otherwise a TypeError is raised. + + Optional _subtype defines the subtype of the contained message. The + default is "rfc822" (this is defined by the MIME standard, even though + the term "rfc822" is technically outdated by RFC 2822). + """ + MIMENonMultipart.__init__(self, 'message', _subtype, policy=policy) + if not isinstance(_msg, message.Message): + raise TypeError('Argument is not an instance of Message') + # It's convenient to use this base class method. We need to do it + # this way or we'll get an exception + message.Message.attach(self, _msg) + # And be sure our default type is set correctly + self.set_default_type('message/rfc822') diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/multipart.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/multipart.py new file mode 100644 index 0000000000000000000000000000000000000000..1abb84d5fed0bb2f5809b7ba8cf3e054abf97f61 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/multipart.py @@ -0,0 +1,47 @@ +# Copyright (C) 2002 Python Software Foundation +# Author: Barry Warsaw +# Contact: email-sig@python.org + +"""Base class for MIME multipart/* type messages.""" + +__all__ = ['MIMEMultipart'] + +from email.mime.base import MIMEBase + + +class MIMEMultipart(MIMEBase): + """Base class for MIME multipart/* type messages.""" + + def __init__(self, _subtype='mixed', boundary=None, _subparts=None, + *, policy=None, + **_params): + """Creates a multipart/* type message. + + By default, creates a multipart/mixed message, with proper + Content-Type and MIME-Version headers. + + _subtype is the subtype of the multipart content type, defaulting to + 'mixed'. + + boundary is the multipart boundary string. By default it is + calculated as needed. + + _subparts is a sequence of initial subparts for the payload. It + must be an iterable object, such as a list. You can always + attach new subparts to the message by using the attach() method. + + Additional parameters for the Content-Type header are taken from the + keyword arguments (or passed into the _params argument). + """ + MIMEBase.__init__(self, 'multipart', _subtype, policy=policy, **_params) + + # Initialise _payload to an empty list as the Message superclass's + # implementation of is_multipart assumes that _payload is a list for + # multipart messages. + self._payload = [] + + if _subparts: + for p in _subparts: + self.attach(p) + if boundary: + self.set_boundary(boundary) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/nonmultipart.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/nonmultipart.py new file mode 100644 index 0000000000000000000000000000000000000000..5beab3a441e2bc6f4b88337718c8daa4711188a8 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/nonmultipart.py @@ -0,0 +1,21 @@ +# Copyright (C) 2002 Python Software Foundation +# Author: Barry Warsaw +# Contact: email-sig@python.org + +"""Base class for MIME type messages that are not multipart.""" + +__all__ = ['MIMENonMultipart'] + +from email import errors +from email.mime.base import MIMEBase + + +class MIMENonMultipart(MIMEBase): + """Base class for MIME non-multipart type messages.""" + + def attach(self, payload): + # The public API prohibits attaching multiple subparts to MIMEBase + # derived subtypes since none of them are, by definition, of content + # type multipart/* + raise errors.MultipartConversionError( + 'Cannot attach additional subparts to non-multipart/*') diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/text.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/text.py new file mode 100644 index 0000000000000000000000000000000000000000..aa4da7f8217e433186c518604e4ae531d2d78c48 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/email/mime/text.py @@ -0,0 +1,40 @@ +# Copyright (C) 2001 Python Software Foundation +# Author: Barry Warsaw +# Contact: email-sig@python.org + +"""Class representing text/* type MIME documents.""" + +__all__ = ['MIMEText'] + +from email.mime.nonmultipart import MIMENonMultipart + + +class MIMEText(MIMENonMultipart): + """Class for generating text/* type MIME documents.""" + + def __init__(self, _text, _subtype='plain', _charset=None, *, policy=None): + """Create a text/* type MIME document. + + _text is the string for this message object. + + _subtype is the MIME sub content type, defaulting to "plain". + + _charset is the character set parameter added to the Content-Type + header. This defaults to "us-ascii". Note that as a side-effect, the + Content-Transfer-Encoding header will also be set. + """ + + # If no _charset was specified, check to see if there are non-ascii + # characters present. If not, use 'us-ascii', otherwise use utf-8. + # XXX: This can be removed once #7304 is fixed. + if _charset is None: + try: + _text.encode('us-ascii') + _charset = 'us-ascii' + except UnicodeEncodeError: + _charset = 'utf-8' + + MIMENonMultipart.__init__(self, 'text', _subtype, policy=policy, + charset=str(_charset)) + + self.set_payload(_text, _charset) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/__init__.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/__init__.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..de6a2da91651577ee732375c6d2fe5661362c740 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/__init__.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/_win_cp_codecs.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/_win_cp_codecs.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8a17fbe05d4c0e0ea25ceb77fa552babd70126c9 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/_win_cp_codecs.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/hz.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/hz.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..19e2fd2cb57bb354ee20fc69bf8c5fca0c078a52 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/hz.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/idna.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/idna.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a17fb3b24c676e13f89a95fffab32f888b599819 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/idna.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso2022_jp.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso2022_jp.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e6c398bf7f62928b2468426a2fe3c0e81fa6a6cb Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso2022_jp.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso2022_jp_1.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso2022_jp_1.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a8807c46a759cd27fe5b1a3948fe087c4c8ffdf0 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso2022_jp_1.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso2022_jp_2.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso2022_jp_2.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e036a45f1134e1a757f2e56cf8aff563349b6ab8 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso2022_jp_2.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso2022_jp_2004.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso2022_jp_2004.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..76b8bf95af727d0f441d9ab21911c4e1698351ba Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso2022_jp_2004.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso2022_jp_3.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso2022_jp_3.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..500b87aeff4209d4287c057b1cf044e1470c901b Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso2022_jp_3.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso2022_jp_ext.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso2022_jp_ext.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6cb6e71a29decfd8db7d59c024f890cd72ee203e Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso2022_jp_ext.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso2022_kr.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso2022_kr.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..750ba28fca1d778fcb6158a6134827b8d078473c Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso2022_kr.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_1.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_1.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7b9a2fd53cda913f53d6c00988645a5cb0a1a683 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_1.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_10.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_10.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5f0f6bc5ea59fbe8316a0d3bd8be396f998d6aa5 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_10.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_11.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_11.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..604cbe196354a35747c4a2ac7acde61a0213c551 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_11.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_13.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_13.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..be728591ccef8f529b5059135987cfa0873ed41a Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_13.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_14.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_14.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6d1c1583f17d4878b860ad0fffb1817933635b5e Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_14.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_15.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_15.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1b06fb3cfd3145991de82590dc1cc34c22162520 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_15.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_16.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_16.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e1a39c7c015784d5101ef44ab5f91d008b59fb97 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_16.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_2.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_2.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a0c78b6f755dce677fba72e53f70e275cd7ca597 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_2.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_3.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_3.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c860179bca2c9cdf536b3658ffd59dd72c2d75b5 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_3.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_4.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_4.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f1edfbb4d66bfd9bfff255acb92d776b9b0e9c2a Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_4.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_5.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_5.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..79c66693a1d2922f83393330ec2ed12079466b50 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_5.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_6.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_6.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bfbe5e72d713ad9ac016601e288cd90d22e316ea Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_6.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_7.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_7.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..17fad2a680682fbcc84c4bc025561cb013ae023e Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_7.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_8.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_8.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..72283d0f875927f7fa857a6f4015ee0423c1ae4e Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_8.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_9.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_9.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8be4e9ff7d296ecbdea09a238c46e06a4988ec76 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/iso8859_9.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/johab.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/johab.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f4c9db0f07ad511d7fdcd8403fcb988f555df196 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/johab.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/koi8_r.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/koi8_r.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9ae24f19c0740cd661ad5276538036896a9b910b Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/koi8_r.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/koi8_t.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/koi8_t.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..efcfb7ca19bd11a341fd1e6ff0b16ea8a49791b0 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/koi8_t.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/koi8_u.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/koi8_u.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..848d989c1ea0af493e0692030ce94f597f057532 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/koi8_u.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/kz1048.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/kz1048.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9d530a83b657e429711831dc5f7e381a9ba42a39 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/kz1048.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/latin_1.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/latin_1.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..500e159dee5a1acc014cebebfbf2f53d80b57446 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/latin_1.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_arabic.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_arabic.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..66cbacb61af5c07906e2fa61f77dde56850b3f72 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_arabic.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_croatian.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_croatian.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..77bad3e233705ed02795ecbf5783fd9cbbbbfcf3 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_croatian.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_cyrillic.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_cyrillic.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e02ed9a58d1f71fba6e4dd11c50b25e1f0b65f1d Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_cyrillic.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_farsi.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_farsi.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..16b20aa88046171aa4369b1332afd47820206ad2 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_farsi.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_greek.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_greek.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6ce8f35b4340cbb4dc0e0402d6884439192cca06 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_greek.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_iceland.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_iceland.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1a25aa60c79729b8022844096acd8a47736b8c01 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_iceland.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_latin2.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_latin2.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..429620ee8685d68baaa6b5d306ff8ac8d8635c82 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_latin2.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_roman.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_roman.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..32c9f22b03334bbda0fa3357fce51ebc3f6f80db Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_roman.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_romanian.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_romanian.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1918bb5726e57cc5a61b93d96ce79e9d9a66a02e Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_romanian.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_turkish.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_turkish.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..52a29165c86c81139652cea705c97c33a16a7848 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mac_turkish.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mbcs.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mbcs.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2bace6e62e0adea7cc6ab718d920ee5b590471e4 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/mbcs.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/oem.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/oem.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6614989deaabc6b5f958535919bce29f34a66abc Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/oem.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/palmos.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/palmos.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5db3e48d800682246e0b9de0d1bf6f7f3686442c Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/palmos.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/ptcp154.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/ptcp154.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b01df6e7d16f45abefff9370c6d92983e09482b6 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/ptcp154.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/punycode.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/punycode.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d6c49fbb6357c1987e7b2bc221a9f3b7d6ac38e8 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/punycode.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/quopri_codec.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/quopri_codec.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1a0824c406516dc7b6178d40c8a99125b502c8f0 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/quopri_codec.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/raw_unicode_escape.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/raw_unicode_escape.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2f47a799763d61d8ac314ed8db2e6b064264b9b9 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/raw_unicode_escape.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/rot_13.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/rot_13.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1a1240a069aea6b2044454a7896836a4a6fa59ac Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/rot_13.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/shift_jis.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/shift_jis.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..774a322823bbe4b969b3040789c7020167d6893f Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/shift_jis.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/shift_jis_2004.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/shift_jis_2004.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..60159ccb8b94bdb9a91c7531122762fb886f3592 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/shift_jis_2004.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/shift_jisx0213.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/shift_jisx0213.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..40995d9fa60c76b889aa4307e32cf3b6823a9df3 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/shift_jisx0213.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/tis_620.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/tis_620.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a0cf21df16385fa203609ef586456286b36e4fe4 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/tis_620.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/undefined.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/undefined.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7ce06328070a7a6d613ef0a38f1b56b20c4f0296 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/undefined.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/unicode_escape.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/unicode_escape.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..21c61f6af1c368e49d0d21c12b8a6a345c5be8c7 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/unicode_escape.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_16.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_16.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bb248b8379e0f1d1a4165c2c53e5c2b09195533e Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_16.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_16_be.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_16_be.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cea3822419049de57a556f8a6b47de8e838cc002 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_16_be.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_16_le.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_16_le.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..37cacabbfac4c4637abf83c96ebb648bb1ce3308 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_16_le.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_32.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_32.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2027a41dc0e1c4ee33cc453cfa5a2c783279499d Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_32.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_32_be.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_32_be.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ae64e529eff351861846f9135dad226bfbcdcc4f Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_32_be.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_32_le.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_32_le.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2cb2b2d096415a54d13bd9ba2d5669b6eb094a53 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_32_le.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_7.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_7.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e12c31f4a1a20fa859867bf91d76df178a3ff957 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_7.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_8.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_8.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3a4623bbcea9dc4bf41826a6b666fe681a9478bc Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_8.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_8_sig.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_8_sig.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9aab0cb37d90b4dc5d83125f2c5667556b1f206b Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/utf_8_sig.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/uu_codec.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/uu_codec.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..17900bc06ce89bc9473a3377bb5ca12447f91e32 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/uu_codec.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/zlib_codec.cpython-314.pyc b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/zlib_codec.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8468fac54df5aef7006af9127cc648b546cb4636 Binary files /dev/null and b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/Lib/encodings/__pycache__/zlib_codec.cpython-314.pyc differ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/abstract.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/abstract.h new file mode 100644 index 0000000000000000000000000000000000000000..ffd19ccd3500fac847eb379eaed953aa67d12bec --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/abstract.h @@ -0,0 +1,104 @@ +#ifndef Py_CPYTHON_ABSTRACTOBJECT_H +# error "this header file must not be included directly" +#endif + +/* === Object Protocol ================================================== */ + +/* Like PyObject_CallMethod(), but expect a _Py_Identifier* + as the method name. */ +PyAPI_FUNC(PyObject*) _PyObject_CallMethodId( + PyObject *obj, + _Py_Identifier *name, + const char *format, ...); + +/* Convert keyword arguments from the FASTCALL (stack: C array, kwnames: tuple) + format to a Python dictionary ("kwargs" dict). + + The type of kwnames keys is not checked. The final function getting + arguments is responsible to check if all keys are strings, for example using + PyArg_ParseTupleAndKeywords() or PyArg_ValidateKeywordArguments(). + + Duplicate keys are merged using the last value. If duplicate keys must raise + an exception, the caller is responsible to implement an explicit keys on + kwnames. */ +PyAPI_FUNC(PyObject*) _PyStack_AsDict(PyObject *const *values, PyObject *kwnames); + + +/* === Vectorcall protocol (PEP 590) ============================= */ + +// PyVectorcall_NARGS() is exported as a function for the stable ABI. +// Here (when we are not using the stable ABI), the name is overridden to +// call a static inline function for best performance. +static inline Py_ssize_t +_PyVectorcall_NARGS(size_t n) +{ + return n & ~PY_VECTORCALL_ARGUMENTS_OFFSET; +} +#define PyVectorcall_NARGS(n) _PyVectorcall_NARGS(n) + +PyAPI_FUNC(vectorcallfunc) PyVectorcall_Function(PyObject *callable); + +// Backwards compatibility aliases (PEP 590) for API that was provisional +// in Python 3.8 +#define _PyObject_Vectorcall PyObject_Vectorcall +#define _PyObject_VectorcallMethod PyObject_VectorcallMethod +#define _PyObject_FastCallDict PyObject_VectorcallDict +#define _PyVectorcall_Function PyVectorcall_Function +#define _PyObject_CallOneArg PyObject_CallOneArg +#define _PyObject_CallMethodNoArgs PyObject_CallMethodNoArgs +#define _PyObject_CallMethodOneArg PyObject_CallMethodOneArg + +/* Same as PyObject_Vectorcall except that keyword arguments are passed as + dict, which may be NULL if there are no keyword arguments. */ +PyAPI_FUNC(PyObject *) PyObject_VectorcallDict( + PyObject *callable, + PyObject *const *args, + size_t nargsf, + PyObject *kwargs); + +PyAPI_FUNC(PyObject *) PyObject_CallOneArg(PyObject *func, PyObject *arg); + +static inline PyObject * +PyObject_CallMethodNoArgs(PyObject *self, PyObject *name) +{ + size_t nargsf = 1 | PY_VECTORCALL_ARGUMENTS_OFFSET; + return PyObject_VectorcallMethod(name, &self, nargsf, _Py_NULL); +} + +static inline PyObject * +PyObject_CallMethodOneArg(PyObject *self, PyObject *name, PyObject *arg) +{ + PyObject *args[2] = {self, arg}; + size_t nargsf = 2 | PY_VECTORCALL_ARGUMENTS_OFFSET; + assert(arg != NULL); + return PyObject_VectorcallMethod(name, args, nargsf, _Py_NULL); +} + +/* Guess the size of object 'o' using len(o) or o.__length_hint__(). + If neither of those return a non-negative value, then return the default + value. If one of the calls fails, this function returns -1. */ +PyAPI_FUNC(Py_ssize_t) PyObject_LengthHint(PyObject *o, Py_ssize_t); + +/* === Sequence protocol ================================================ */ + +/* Assume tp_as_sequence and sq_item exist and that 'i' does not + need to be corrected for a negative index. */ +#define PySequence_ITEM(o, i)\ + ( Py_TYPE(o)->tp_as_sequence->sq_item((o), (i)) ) + +/* Return the size of the sequence 'o', assuming that 'o' was returned by + PySequence_Fast and is not NULL. */ +#define PySequence_Fast_GET_SIZE(o) \ + (PyList_Check(o) ? PyList_GET_SIZE(o) : PyTuple_GET_SIZE(o)) + +/* Return the 'i'-th element of the sequence 'o', assuming that o was returned + by PySequence_Fast, and that i is within bounds. */ +#define PySequence_Fast_GET_ITEM(o, i)\ + (PyList_Check(o) ? PyList_GET_ITEM((o), (i)) : PyTuple_GET_ITEM((o), (i))) + +/* Return a pointer to the underlying item array for + an object returned by PySequence_Fast */ +#define PySequence_Fast_ITEMS(sf) \ + (PyList_Check(sf) ? ((PyListObject *)(sf))->ob_item \ + : ((PyTupleObject *)(sf))->ob_item) + diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/audit.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/audit.h new file mode 100644 index 0000000000000000000000000000000000000000..536f92486320974bea1a70786a36bbdbec68d902 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/audit.h @@ -0,0 +1,8 @@ +#ifndef _Py_CPYTHON_AUDIT_H +# error "this header file must not be included directly" +#endif + + +typedef int(*Py_AuditHookFunction)(const char *, PyObject *, void *); + +PyAPI_FUNC(int) PySys_AddAuditHook(Py_AuditHookFunction, void*); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/bytearrayobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/bytearrayobject.h new file mode 100644 index 0000000000000000000000000000000000000000..4dddef713ce0970abc2acb2302c63469538edbe0 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/bytearrayobject.h @@ -0,0 +1,38 @@ +#ifndef Py_CPYTHON_BYTEARRAYOBJECT_H +# error "this header file must not be included directly" +#endif + +/* Object layout */ +typedef struct { + PyObject_VAR_HEAD + Py_ssize_t ob_alloc; /* How many bytes allocated in ob_bytes */ + char *ob_bytes; /* Physical backing buffer */ + char *ob_start; /* Logical start inside ob_bytes */ + Py_ssize_t ob_exports; /* How many buffer exports */ +} PyByteArrayObject; + +PyAPI_DATA(char) _PyByteArray_empty_string[]; + +/* Macros and static inline functions, trading safety for speed */ +#define _PyByteArray_CAST(op) \ + (assert(PyByteArray_Check(op)), _Py_CAST(PyByteArrayObject*, op)) + +static inline char* PyByteArray_AS_STRING(PyObject *op) +{ + PyByteArrayObject *self = _PyByteArray_CAST(op); + if (Py_SIZE(self)) { + return self->ob_start; + } + return _PyByteArray_empty_string; +} +#define PyByteArray_AS_STRING(self) PyByteArray_AS_STRING(_PyObject_CAST(self)) + +static inline Py_ssize_t PyByteArray_GET_SIZE(PyObject *op) { + PyByteArrayObject *self = _PyByteArray_CAST(op); +#ifdef Py_GIL_DISABLED + return _Py_atomic_load_ssize_relaxed(&(_PyVarObject_CAST(self)->ob_size)); +#else + return Py_SIZE(self); +#endif +} +#define PyByteArray_GET_SIZE(self) PyByteArray_GET_SIZE(_PyObject_CAST(self)) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/bytesobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/bytesobject.h new file mode 100644 index 0000000000000000000000000000000000000000..71c133f173f157ffe85fa2fe09dfaf526a093216 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/bytesobject.h @@ -0,0 +1,42 @@ +#ifndef Py_CPYTHON_BYTESOBJECT_H +# error "this header file must not be included directly" +#endif + +typedef struct { + PyObject_VAR_HEAD + Py_DEPRECATED(3.11) Py_hash_t ob_shash; + char ob_sval[1]; + + /* Invariants: + * ob_sval contains space for 'ob_size+1' elements. + * ob_sval[ob_size] == 0. + * ob_shash is the hash of the byte string or -1 if not computed yet. + */ +} PyBytesObject; + +PyAPI_FUNC(int) _PyBytes_Resize(PyObject **, Py_ssize_t); + +/* Macros and static inline functions, trading safety for speed */ +#define _PyBytes_CAST(op) \ + (assert(PyBytes_Check(op)), _Py_CAST(PyBytesObject*, op)) + +static inline char* PyBytes_AS_STRING(PyObject *op) +{ + return _PyBytes_CAST(op)->ob_sval; +} +#define PyBytes_AS_STRING(op) PyBytes_AS_STRING(_PyObject_CAST(op)) + +static inline Py_ssize_t PyBytes_GET_SIZE(PyObject *op) { + PyBytesObject *self = _PyBytes_CAST(op); + return Py_SIZE(self); +} +#define PyBytes_GET_SIZE(self) PyBytes_GET_SIZE(_PyObject_CAST(self)) + +PyAPI_FUNC(PyObject*) PyBytes_Join(PyObject *sep, PyObject *iterable); + +// Deprecated alias kept for backward compatibility +Py_DEPRECATED(3.14) static inline PyObject* +_PyBytes_Join(PyObject *sep, PyObject *iterable) +{ + return PyBytes_Join(sep, iterable); +} diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/cellobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/cellobject.h new file mode 100644 index 0000000000000000000000000000000000000000..85a63a13747d872a24df507bc5ef926843632d53 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/cellobject.h @@ -0,0 +1,50 @@ +/* Cell object interface */ + +#ifndef Py_LIMITED_API +#ifndef Py_CELLOBJECT_H +#define Py_CELLOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + PyObject_HEAD + /* Content of the cell or NULL when empty */ + PyObject *ob_ref; +} PyCellObject; + +PyAPI_DATA(PyTypeObject) PyCell_Type; + +#define PyCell_Check(op) Py_IS_TYPE((op), &PyCell_Type) + +PyAPI_FUNC(PyObject *) PyCell_New(PyObject *); +PyAPI_FUNC(PyObject *) PyCell_Get(PyObject *); +PyAPI_FUNC(int) PyCell_Set(PyObject *, PyObject *); + +static inline PyObject* PyCell_GET(PyObject *op) { + PyObject *res; + PyCellObject *cell; + assert(PyCell_Check(op)); + cell = _Py_CAST(PyCellObject*, op); + Py_BEGIN_CRITICAL_SECTION(cell); + res = cell->ob_ref; + Py_END_CRITICAL_SECTION(); + return res; +} +#define PyCell_GET(op) PyCell_GET(_PyObject_CAST(op)) + +static inline void PyCell_SET(PyObject *op, PyObject *value) { + PyCellObject *cell; + assert(PyCell_Check(op)); + cell = _Py_CAST(PyCellObject*, op); + Py_BEGIN_CRITICAL_SECTION(cell); + cell->ob_ref = value; + Py_END_CRITICAL_SECTION(); +} +#define PyCell_SET(op, value) PyCell_SET(_PyObject_CAST(op), (value)) + +#ifdef __cplusplus +} +#endif +#endif /* !Py_TUPLEOBJECT_H */ +#endif /* Py_LIMITED_API */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/ceval.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/ceval.h new file mode 100644 index 0000000000000000000000000000000000000000..ca8109e3248a8d894a4407ac091a26599e30d44b --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/ceval.h @@ -0,0 +1,43 @@ +#ifndef Py_CPYTHON_CEVAL_H +# error "this header file must not be included directly" +#endif + +PyAPI_FUNC(void) PyEval_SetProfile(Py_tracefunc, PyObject *); +PyAPI_FUNC(void) PyEval_SetProfileAllThreads(Py_tracefunc, PyObject *); +PyAPI_FUNC(void) PyEval_SetTrace(Py_tracefunc, PyObject *); +PyAPI_FUNC(void) PyEval_SetTraceAllThreads(Py_tracefunc, PyObject *); + +/* Look at the current frame's (if any) code's co_flags, and turn on + the corresponding compiler flags in cf->cf_flags. Return 1 if any + flag was set, else return 0. */ +PyAPI_FUNC(int) PyEval_MergeCompilerFlags(PyCompilerFlags *cf); + +PyAPI_FUNC(PyObject *) _PyEval_EvalFrameDefault(PyThreadState *tstate, struct _PyInterpreterFrame *f, int exc); + +PyAPI_FUNC(Py_ssize_t) PyUnstable_Eval_RequestCodeExtraIndex(freefunc); +// Old name -- remove when this API changes: +_Py_DEPRECATED_EXTERNALLY(3.12) static inline Py_ssize_t +_PyEval_RequestCodeExtraIndex(freefunc f) { + return PyUnstable_Eval_RequestCodeExtraIndex(f); +} + +PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, Py_ssize_t *); +PyAPI_FUNC(int) _PyEval_SliceIndexNotNone(PyObject *, Py_ssize_t *); + + +// Trampoline API + +typedef struct { + FILE* perf_map; + PyThread_type_lock map_lock; +} PerfMapState; + +PyAPI_FUNC(int) PyUnstable_PerfMapState_Init(void); +PyAPI_FUNC(int) PyUnstable_WritePerfMapEntry( + const void *code_addr, + unsigned int code_size, + const char *entry_name); +PyAPI_FUNC(void) PyUnstable_PerfMapState_Fini(void); +PyAPI_FUNC(int) PyUnstable_CopyPerfMapFile(const char* parent_filename); +PyAPI_FUNC(int) PyUnstable_PerfTrampoline_CompileCode(PyCodeObject *); +PyAPI_FUNC(int) PyUnstable_PerfTrampoline_SetPersistAfterFork(int enable); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/classobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/classobject.h new file mode 100644 index 0000000000000000000000000000000000000000..d7c9ddd1336c46d8a57898cdcfcb0731c0cfb6a9 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/classobject.h @@ -0,0 +1,71 @@ +/* Former class object interface -- now only bound methods are here */ + +/* Revealing some structures (not for general use) */ + +#ifndef Py_LIMITED_API +#ifndef Py_CLASSOBJECT_H +#define Py_CLASSOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + PyObject_HEAD + PyObject *im_func; /* The callable object implementing the method */ + PyObject *im_self; /* The instance it is bound to */ + PyObject *im_weakreflist; /* List of weak references */ + vectorcallfunc vectorcall; +} PyMethodObject; + +PyAPI_DATA(PyTypeObject) PyMethod_Type; + +#define PyMethod_Check(op) Py_IS_TYPE((op), &PyMethod_Type) + +PyAPI_FUNC(PyObject *) PyMethod_New(PyObject *, PyObject *); + +PyAPI_FUNC(PyObject *) PyMethod_Function(PyObject *); +PyAPI_FUNC(PyObject *) PyMethod_Self(PyObject *); + +#define _PyMethod_CAST(meth) \ + (assert(PyMethod_Check(meth)), _Py_CAST(PyMethodObject*, meth)) + +/* Static inline functions for direct access to these values. + Type checks are *not* done, so use with care. */ +static inline PyObject* PyMethod_GET_FUNCTION(PyObject *meth) { + return _PyMethod_CAST(meth)->im_func; +} +#define PyMethod_GET_FUNCTION(meth) PyMethod_GET_FUNCTION(_PyObject_CAST(meth)) + +static inline PyObject* PyMethod_GET_SELF(PyObject *meth) { + return _PyMethod_CAST(meth)->im_self; +} +#define PyMethod_GET_SELF(meth) PyMethod_GET_SELF(_PyObject_CAST(meth)) + +typedef struct { + PyObject_HEAD + PyObject *func; +} PyInstanceMethodObject; + +PyAPI_DATA(PyTypeObject) PyInstanceMethod_Type; + +#define PyInstanceMethod_Check(op) Py_IS_TYPE((op), &PyInstanceMethod_Type) + +PyAPI_FUNC(PyObject *) PyInstanceMethod_New(PyObject *); +PyAPI_FUNC(PyObject *) PyInstanceMethod_Function(PyObject *); + +#define _PyInstanceMethod_CAST(meth) \ + (assert(PyInstanceMethod_Check(meth)), \ + _Py_CAST(PyInstanceMethodObject*, meth)) + +/* Static inline function for direct access to these values. + Type checks are *not* done, so use with care. */ +static inline PyObject* PyInstanceMethod_GET_FUNCTION(PyObject *meth) { + return _PyInstanceMethod_CAST(meth)->func; +} +#define PyInstanceMethod_GET_FUNCTION(meth) PyInstanceMethod_GET_FUNCTION(_PyObject_CAST(meth)) + +#ifdef __cplusplus +} +#endif +#endif // !Py_CLASSOBJECT_H +#endif // !Py_LIMITED_API diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/code.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/code.h new file mode 100644 index 0000000000000000000000000000000000000000..3f0dce0345552605b4b38f8d4248ccd973ed75a0 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/code.h @@ -0,0 +1,340 @@ +/* Definitions for bytecode */ + +#ifndef Py_LIMITED_API +#ifndef Py_CODE_H +#define Py_CODE_H + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + PyObject *_co_code; + PyObject *_co_varnames; + PyObject *_co_cellvars; + PyObject *_co_freevars; +} _PyCoCached; + +typedef struct { + int size; + int capacity; + struct _PyExecutorObject *executors[1]; +} _PyExecutorArray; + + +#ifdef Py_GIL_DISABLED + +/* Each thread specializes a thread-local copy of the bytecode in free-threaded + * builds. These copies are stored on the code object in a `_PyCodeArray`. The + * first entry in the array always points to the "main" copy of the bytecode + * that is stored at the end of the code object. + */ +typedef struct { + Py_ssize_t size; + char *entries[1]; +} _PyCodeArray; + +#define _PyCode_DEF_THREAD_LOCAL_BYTECODE() \ + _PyCodeArray *co_tlbc; +#else +#define _PyCode_DEF_THREAD_LOCAL_BYTECODE() +#endif + +// To avoid repeating ourselves in deepfreeze.py, all PyCodeObject members are +// defined in this macro: +#define _PyCode_DEF(SIZE) { \ + PyObject_VAR_HEAD \ + \ + /* Note only the following fields are used in hash and/or comparisons \ + * \ + * - co_name \ + * - co_argcount \ + * - co_posonlyargcount \ + * - co_kwonlyargcount \ + * - co_nlocals \ + * - co_stacksize \ + * - co_flags \ + * - co_firstlineno \ + * - co_consts \ + * - co_names \ + * - co_localsplusnames \ + * This is done to preserve the name and line number for tracebacks \ + * and debuggers; otherwise, constant de-duplication would collapse \ + * identical functions/lambdas defined on different lines. \ + */ \ + \ + /* These fields are set with provided values on new code objects. */ \ + \ + /* The hottest fields (in the eval loop) are grouped here at the top. */ \ + PyObject *co_consts; /* list (constants used) */ \ + PyObject *co_names; /* list of strings (names used) */ \ + PyObject *co_exceptiontable; /* Byte string encoding exception handling \ + table */ \ + int co_flags; /* CO_..., see below */ \ + \ + /* The rest are not so impactful on performance. */ \ + int co_argcount; /* #arguments, except *args */ \ + int co_posonlyargcount; /* #positional only arguments */ \ + int co_kwonlyargcount; /* #keyword only arguments */ \ + int co_stacksize; /* #entries needed for evaluation stack */ \ + int co_firstlineno; /* first source line number */ \ + \ + /* redundant values (derived from co_localsplusnames and \ + co_localspluskinds) */ \ + int co_nlocalsplus; /* number of spaces for holding local, cell, \ + and free variables */ \ + int co_framesize; /* Size of frame in words */ \ + int co_nlocals; /* number of local variables */ \ + int co_ncellvars; /* total number of cell variables */ \ + int co_nfreevars; /* number of free variables */ \ + uint32_t co_version; /* version number */ \ + \ + PyObject *co_localsplusnames; /* tuple mapping offsets to names */ \ + PyObject *co_localspluskinds; /* Bytes mapping to local kinds (one byte \ + per variable) */ \ + PyObject *co_filename; /* unicode (where it was loaded from) */ \ + PyObject *co_name; /* unicode (name, for reference) */ \ + PyObject *co_qualname; /* unicode (qualname, for reference) */ \ + PyObject *co_linetable; /* bytes object that holds location info */ \ + PyObject *co_weakreflist; /* to support weakrefs to code objects */ \ + _PyExecutorArray *co_executors; /* executors from optimizer */ \ + _PyCoCached *_co_cached; /* cached co_* attributes */ \ + uintptr_t _co_instrumentation_version; /* current instrumentation version */ \ + struct _PyCoMonitoringData *_co_monitoring; /* Monitoring data */ \ + Py_ssize_t _co_unique_id; /* ID used for per-thread refcounting */ \ + int _co_firsttraceable; /* index of first traceable instruction */ \ + /* Scratch space for extra data relating to the code object. \ + Type is a void* to keep the format private in codeobject.c to force \ + people to go through the proper APIs. */ \ + void *co_extra; \ + _PyCode_DEF_THREAD_LOCAL_BYTECODE() \ + char co_code_adaptive[(SIZE)]; \ +} + +/* Bytecode object */ +struct PyCodeObject _PyCode_DEF(1); + +/* Masks for co_flags above */ +#define CO_OPTIMIZED 0x0001 +#define CO_NEWLOCALS 0x0002 +#define CO_VARARGS 0x0004 +#define CO_VARKEYWORDS 0x0008 +#define CO_NESTED 0x0010 +#define CO_GENERATOR 0x0020 + +/* The CO_COROUTINE flag is set for coroutine functions (defined with + ``async def`` keywords) */ +#define CO_COROUTINE 0x0080 +#define CO_ITERABLE_COROUTINE 0x0100 +#define CO_ASYNC_GENERATOR 0x0200 + +/* bpo-39562: These constant values are changed in Python 3.9 + to prevent collision with compiler flags. CO_FUTURE_ and PyCF_ + constants must be kept unique. PyCF_ constants can use bits from + 0x0100 to 0x10000. CO_FUTURE_ constants use bits starting at 0x20000. */ +#define CO_FUTURE_DIVISION 0x20000 +#define CO_FUTURE_ABSOLUTE_IMPORT 0x40000 /* do absolute imports by default */ +#define CO_FUTURE_WITH_STATEMENT 0x80000 +#define CO_FUTURE_PRINT_FUNCTION 0x100000 +#define CO_FUTURE_UNICODE_LITERALS 0x200000 + +#define CO_FUTURE_BARRY_AS_BDFL 0x400000 +#define CO_FUTURE_GENERATOR_STOP 0x800000 +#define CO_FUTURE_ANNOTATIONS 0x1000000 + +#define CO_NO_MONITORING_EVENTS 0x2000000 + +/* Whether the code object has a docstring, + If so, it will be the first item in co_consts +*/ +#define CO_HAS_DOCSTRING 0x4000000 + +/* A function defined in class scope */ +#define CO_METHOD 0x8000000 + +/* This should be defined if a future statement modifies the syntax. + For example, when a keyword is added. +*/ +#define PY_PARSER_REQUIRES_FUTURE_KEYWORD + +#define CO_MAXBLOCKS 21 /* Max static block nesting within a function */ + +PyAPI_DATA(PyTypeObject) PyCode_Type; + +#define PyCode_Check(op) Py_IS_TYPE((op), &PyCode_Type) + +static inline Py_ssize_t PyCode_GetNumFree(PyCodeObject *op) { + assert(PyCode_Check(op)); + return op->co_nfreevars; +} + +static inline int PyUnstable_Code_GetFirstFree(PyCodeObject *op) { + assert(PyCode_Check(op)); + return op->co_nlocalsplus - op->co_nfreevars; +} + +Py_DEPRECATED(3.13) static inline int PyCode_GetFirstFree(PyCodeObject *op) { + return PyUnstable_Code_GetFirstFree(op); +} + +/* Unstable public interface */ +PyAPI_FUNC(PyCodeObject *) PyUnstable_Code_New( + int, int, int, int, int, PyObject *, PyObject *, + PyObject *, PyObject *, PyObject *, PyObject *, + PyObject *, PyObject *, PyObject *, int, PyObject *, + PyObject *); + +PyAPI_FUNC(PyCodeObject *) PyUnstable_Code_NewWithPosOnlyArgs( + int, int, int, int, int, int, PyObject *, PyObject *, + PyObject *, PyObject *, PyObject *, PyObject *, + PyObject *, PyObject *, PyObject *, int, PyObject *, + PyObject *); + /* same as struct above */ +// Old names -- remove when this API changes: +_Py_DEPRECATED_EXTERNALLY(3.12) static inline PyCodeObject * +PyCode_New( + int a, int b, int c, int d, int e, PyObject *f, PyObject *g, + PyObject *h, PyObject *i, PyObject *j, PyObject *k, + PyObject *l, PyObject *m, PyObject *n, int o, PyObject *p, + PyObject *q) +{ + return PyUnstable_Code_New( + a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q); +} +_Py_DEPRECATED_EXTERNALLY(3.12) static inline PyCodeObject * +PyCode_NewWithPosOnlyArgs( + int a, int poac, int b, int c, int d, int e, PyObject *f, PyObject *g, + PyObject *h, PyObject *i, PyObject *j, PyObject *k, + PyObject *l, PyObject *m, PyObject *n, int o, PyObject *p, + PyObject *q) +{ + return PyUnstable_Code_NewWithPosOnlyArgs( + a, poac, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q); +} + +/* Creates a new empty code object with the specified source location. */ +PyAPI_FUNC(PyCodeObject *) +PyCode_NewEmpty(const char *filename, const char *funcname, int firstlineno); + +/* Return the line number associated with the specified bytecode index + in this code object. If you just need the line number of a frame, + use PyFrame_GetLineNumber() instead. */ +PyAPI_FUNC(int) PyCode_Addr2Line(PyCodeObject *, int); + +PyAPI_FUNC(int) PyCode_Addr2Location(PyCodeObject *, int, int *, int *, int *, int *); + +#define PY_FOREACH_CODE_EVENT(V) \ + V(CREATE) \ + V(DESTROY) + +typedef enum { + #define PY_DEF_EVENT(op) PY_CODE_EVENT_##op, + PY_FOREACH_CODE_EVENT(PY_DEF_EVENT) + #undef PY_DEF_EVENT +} PyCodeEvent; + + +/* + * A callback that is invoked for different events in a code object's lifecycle. + * + * The callback is invoked with a borrowed reference to co, after it is + * created and before it is destroyed. + * + * If the callback sets an exception, it must return -1. Otherwise + * it should return 0. + */ +typedef int (*PyCode_WatchCallback)( + PyCodeEvent event, + PyCodeObject* co); + +/* + * Register a per-interpreter callback that will be invoked for code object + * lifecycle events. + * + * Returns a handle that may be passed to PyCode_ClearWatcher on success, + * or -1 and sets an error if no more handles are available. + */ +PyAPI_FUNC(int) PyCode_AddWatcher(PyCode_WatchCallback callback); + +/* + * Clear the watcher associated with the watcher_id handle. + * + * Returns 0 on success or -1 if no watcher exists for the provided id. + */ +PyAPI_FUNC(int) PyCode_ClearWatcher(int watcher_id); + +/* for internal use only */ +struct _opaque { + int computed_line; + const uint8_t *lo_next; + const uint8_t *limit; +}; + +typedef struct _line_offsets { + int ar_start; + int ar_end; + int ar_line; + struct _opaque opaque; +} PyCodeAddressRange; + +/* Update *bounds to describe the first and one-past-the-last instructions in the + same line as lasti. Return the number of that line. +*/ +PyAPI_FUNC(int) _PyCode_CheckLineNumber(int lasti, PyCodeAddressRange *bounds); + +/* Create a comparable key used to compare constants taking in account the + * object type. It is used to make sure types are not coerced (e.g., float and + * complex) _and_ to distinguish 0.0 from -0.0 e.g. on IEEE platforms + * + * Return (type(obj), obj, ...): a tuple with variable size (at least 2 items) + * depending on the type and the value. The type is the first item to not + * compare bytes and str which can raise a BytesWarning exception. */ +PyAPI_FUNC(PyObject*) _PyCode_ConstantKey(PyObject *obj); + +PyAPI_FUNC(PyObject*) PyCode_Optimize(PyObject *code, PyObject* consts, + PyObject *names, PyObject *lnotab); + +PyAPI_FUNC(int) PyUnstable_Code_GetExtra( + PyObject *code, Py_ssize_t index, void **extra); +PyAPI_FUNC(int) PyUnstable_Code_SetExtra( + PyObject *code, Py_ssize_t index, void *extra); +// Old names -- remove when this API changes: +_Py_DEPRECATED_EXTERNALLY(3.12) static inline int +_PyCode_GetExtra(PyObject *code, Py_ssize_t index, void **extra) +{ + return PyUnstable_Code_GetExtra(code, index, extra); +} +_Py_DEPRECATED_EXTERNALLY(3.12) static inline int +_PyCode_SetExtra(PyObject *code, Py_ssize_t index, void *extra) +{ + return PyUnstable_Code_SetExtra(code, index, extra); +} + +/* Equivalent to getattr(code, 'co_code') in Python. + Returns a strong reference to a bytes object. */ +PyAPI_FUNC(PyObject *) PyCode_GetCode(PyCodeObject *code); +/* Equivalent to getattr(code, 'co_varnames') in Python. */ +PyAPI_FUNC(PyObject *) PyCode_GetVarnames(PyCodeObject *code); +/* Equivalent to getattr(code, 'co_cellvars') in Python. */ +PyAPI_FUNC(PyObject *) PyCode_GetCellvars(PyCodeObject *code); +/* Equivalent to getattr(code, 'co_freevars') in Python. */ +PyAPI_FUNC(PyObject *) PyCode_GetFreevars(PyCodeObject *code); + +typedef enum _PyCodeLocationInfoKind { + /* short forms are 0 to 9 */ + PY_CODE_LOCATION_INFO_SHORT0 = 0, + /* one lineforms are 10 to 12 */ + PY_CODE_LOCATION_INFO_ONE_LINE0 = 10, + PY_CODE_LOCATION_INFO_ONE_LINE1 = 11, + PY_CODE_LOCATION_INFO_ONE_LINE2 = 12, + + PY_CODE_LOCATION_INFO_NO_COLUMNS = 13, + PY_CODE_LOCATION_INFO_LONG = 14, + PY_CODE_LOCATION_INFO_NONE = 15 +} _PyCodeLocationInfoKind; + +#ifdef __cplusplus +} +#endif +#endif // !Py_CODE_H +#endif // !Py_LIMITED_API diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/compile.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/compile.h new file mode 100644 index 0000000000000000000000000000000000000000..cfdb7080d45f2b166082df0be2f1508a3eef9946 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/compile.h @@ -0,0 +1,50 @@ +#ifndef Py_CPYTHON_COMPILE_H +# error "this header file must not be included directly" +#endif + +/* Public interface */ +#define PyCF_MASK (CO_FUTURE_DIVISION | CO_FUTURE_ABSOLUTE_IMPORT | \ + CO_FUTURE_WITH_STATEMENT | CO_FUTURE_PRINT_FUNCTION | \ + CO_FUTURE_UNICODE_LITERALS | CO_FUTURE_BARRY_AS_BDFL | \ + CO_FUTURE_GENERATOR_STOP | CO_FUTURE_ANNOTATIONS) +#define PyCF_MASK_OBSOLETE (CO_NESTED) + +/* bpo-39562: CO_FUTURE_ and PyCF_ constants must be kept unique. + PyCF_ constants can use bits from 0x0100 to 0x10000. + CO_FUTURE_ constants use bits starting at 0x20000. */ +#define PyCF_SOURCE_IS_UTF8 0x0100 +#define PyCF_DONT_IMPLY_DEDENT 0x0200 +#define PyCF_ONLY_AST 0x0400 +#define PyCF_IGNORE_COOKIE 0x0800 +#define PyCF_TYPE_COMMENTS 0x1000 +#define PyCF_ALLOW_TOP_LEVEL_AWAIT 0x2000 +#define PyCF_ALLOW_INCOMPLETE_INPUT 0x4000 +#define PyCF_OPTIMIZED_AST (0x8000 | PyCF_ONLY_AST) +#define PyCF_COMPILE_MASK (PyCF_ONLY_AST | PyCF_ALLOW_TOP_LEVEL_AWAIT | \ + PyCF_TYPE_COMMENTS | PyCF_DONT_IMPLY_DEDENT | \ + PyCF_ALLOW_INCOMPLETE_INPUT | PyCF_OPTIMIZED_AST) + +typedef struct { + int cf_flags; /* bitmask of CO_xxx flags relevant to future */ + int cf_feature_version; /* minor Python version (PyCF_ONLY_AST) */ +} PyCompilerFlags; + +#define _PyCompilerFlags_INIT \ + (PyCompilerFlags){.cf_flags = 0, .cf_feature_version = PY_MINOR_VERSION} + +/* Future feature support */ + +#define FUTURE_NESTED_SCOPES "nested_scopes" +#define FUTURE_GENERATORS "generators" +#define FUTURE_DIVISION "division" +#define FUTURE_ABSOLUTE_IMPORT "absolute_import" +#define FUTURE_WITH_STATEMENT "with_statement" +#define FUTURE_PRINT_FUNCTION "print_function" +#define FUTURE_UNICODE_LITERALS "unicode_literals" +#define FUTURE_BARRY_AS_BDFL "barry_as_FLUFL" +#define FUTURE_GENERATOR_STOP "generator_stop" +#define FUTURE_ANNOTATIONS "annotations" + +#define PY_INVALID_STACK_EFFECT INT_MAX +PyAPI_FUNC(int) PyCompile_OpcodeStackEffect(int opcode, int oparg); +PyAPI_FUNC(int) PyCompile_OpcodeStackEffectWithJump(int opcode, int oparg, int jump); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/complexobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/complexobject.h new file mode 100644 index 0000000000000000000000000000000000000000..fbdc6a91fe895c0f7af0bff6a3836a1991709c20 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/complexobject.h @@ -0,0 +1,33 @@ +#ifndef Py_CPYTHON_COMPLEXOBJECT_H +# error "this header file must not be included directly" +#endif + +typedef struct { + double real; + double imag; +} Py_complex; + +// Operations on complex numbers. +PyAPI_FUNC(Py_complex) _Py_c_sum(Py_complex, Py_complex); +PyAPI_FUNC(Py_complex) _Py_c_diff(Py_complex, Py_complex); +PyAPI_FUNC(Py_complex) _Py_c_neg(Py_complex); +PyAPI_FUNC(Py_complex) _Py_c_prod(Py_complex, Py_complex); +PyAPI_FUNC(Py_complex) _Py_c_quot(Py_complex, Py_complex); +PyAPI_FUNC(Py_complex) _Py_c_pow(Py_complex, Py_complex); +PyAPI_FUNC(double) _Py_c_abs(Py_complex); + + +/* Complex object interface */ + +/* +PyComplexObject represents a complex number with double-precision +real and imaginary parts. +*/ +typedef struct { + PyObject_HEAD + Py_complex cval; +} PyComplexObject; + +PyAPI_FUNC(PyObject *) PyComplex_FromCComplex(Py_complex); + +PyAPI_FUNC(Py_complex) PyComplex_AsCComplex(PyObject *op); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/context.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/context.h new file mode 100644 index 0000000000000000000000000000000000000000..3a7a4b459c09ad04d0dcd469b3cc556c36bf390f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/context.h @@ -0,0 +1,107 @@ +#ifndef Py_LIMITED_API +#ifndef Py_CONTEXT_H +#define Py_CONTEXT_H +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_DATA(PyTypeObject) PyContext_Type; +typedef struct _pycontextobject PyContext; + +PyAPI_DATA(PyTypeObject) PyContextVar_Type; +typedef struct _pycontextvarobject PyContextVar; + +PyAPI_DATA(PyTypeObject) PyContextToken_Type; +typedef struct _pycontexttokenobject PyContextToken; + + +#define PyContext_CheckExact(o) Py_IS_TYPE((o), &PyContext_Type) +#define PyContextVar_CheckExact(o) Py_IS_TYPE((o), &PyContextVar_Type) +#define PyContextToken_CheckExact(o) Py_IS_TYPE((o), &PyContextToken_Type) + + +PyAPI_FUNC(PyObject *) PyContext_New(void); +PyAPI_FUNC(PyObject *) PyContext_Copy(PyObject *); +PyAPI_FUNC(PyObject *) PyContext_CopyCurrent(void); + +PyAPI_FUNC(int) PyContext_Enter(PyObject *); +PyAPI_FUNC(int) PyContext_Exit(PyObject *); + +typedef enum { + /* + * The current context has switched to a different context. The object + * passed to the watch callback is the now-current contextvars.Context + * object, or None if no context is current. + */ + Py_CONTEXT_SWITCHED = 1, +} PyContextEvent; + +/* + * Context object watcher callback function. The object passed to the callback + * is event-specific; see PyContextEvent for details. + * + * if the callback returns with an exception set, it must return -1. Otherwise + * it should return 0 + */ +typedef int (*PyContext_WatchCallback)(PyContextEvent, PyObject *); + +/* + * Register a per-interpreter callback that will be invoked for context object + * enter/exit events. + * + * Returns a handle that may be passed to PyContext_ClearWatcher on success, + * or -1 and sets and error if no more handles are available. + */ +PyAPI_FUNC(int) PyContext_AddWatcher(PyContext_WatchCallback callback); + +/* + * Clear the watcher associated with the watcher_id handle. + * + * Returns 0 on success or -1 if no watcher exists for the provided id. + */ +PyAPI_FUNC(int) PyContext_ClearWatcher(int watcher_id); + +/* Create a new context variable. + + default_value can be NULL. +*/ +PyAPI_FUNC(PyObject *) PyContextVar_New( + const char *name, PyObject *default_value); + + +/* Get a value for the variable. + + Returns -1 if an error occurred during lookup. + + Returns 0 if value either was or was not found. + + If value was found, *value will point to it. + If not, it will point to: + + - default_value, if not NULL; + - the default value of "var", if not NULL; + - NULL. + + '*value' will be a new ref, if not NULL. +*/ +PyAPI_FUNC(int) PyContextVar_Get( + PyObject *var, PyObject *default_value, PyObject **value); + + +/* Set a new value for the variable. + Returns NULL if an error occurs. +*/ +PyAPI_FUNC(PyObject *) PyContextVar_Set(PyObject *var, PyObject *value); + + +/* Reset a variable to its previous value. + Returns 0 on success, -1 on error. +*/ +PyAPI_FUNC(int) PyContextVar_Reset(PyObject *var, PyObject *token); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_CONTEXT_H */ +#endif /* !Py_LIMITED_API */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/critical_section.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/critical_section.h new file mode 100644 index 0000000000000000000000000000000000000000..4fc46fefb93a24a5f385a38f4cfe9b108263e209 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/critical_section.h @@ -0,0 +1,154 @@ +#ifndef Py_CPYTHON_CRITICAL_SECTION_H +# error "this header file must not be included directly" +#endif + +// Python critical sections +// +// Conceptually, critical sections are a deadlock avoidance layer on top of +// per-object locks. These helpers, in combination with those locks, replace +// our usage of the global interpreter lock to provide thread-safety for +// otherwise thread-unsafe objects, such as dict. +// +// NOTE: These APIs are no-ops in non-free-threaded builds. +// +// Straightforward per-object locking could introduce deadlocks that were not +// present when running with the GIL. Threads may hold locks for multiple +// objects simultaneously because Python operations can nest. If threads were +// to acquire the same locks in different orders, they would deadlock. +// +// One way to avoid deadlocks is to allow threads to hold only the lock (or +// locks) for a single operation at a time (typically a single lock, but some +// operations involve two locks). When a thread begins a nested operation it +// could suspend the locks for any outer operation: before beginning the nested +// operation, the locks for the outer operation are released and when the +// nested operation completes, the locks for the outer operation are +// reacquired. +// +// To improve performance, this API uses a variation of the above scheme. +// Instead of immediately suspending locks any time a nested operation begins, +// locks are only suspended if the thread would block. This reduces the number +// of lock acquisitions and releases for nested operations, while still +// avoiding deadlocks. +// +// Additionally, the locks for any active operation are suspended around +// other potentially blocking operations, such as I/O. This is because the +// interaction between locks and blocking operations can lead to deadlocks in +// the same way as the interaction between multiple locks. +// +// Each thread's critical sections and their corresponding locks are tracked in +// a stack in `PyThreadState.critical_section`. When a thread calls +// `_PyThreadState_Detach()`, such as before a blocking I/O operation or when +// waiting to acquire a lock, the thread suspends all of its active critical +// sections, temporarily releasing the associated locks. When the thread calls +// `_PyThreadState_Attach()`, it resumes the top-most (i.e., most recent) +// critical section by reacquiring the associated lock or locks. See +// `_PyCriticalSection_Resume()`. +// +// NOTE: Only the top-most critical section is guaranteed to be active. +// Operations that need to lock two objects at once must use +// `Py_BEGIN_CRITICAL_SECTION2()`. You *CANNOT* use nested critical sections +// to lock more than one object at once, because the inner critical section +// may suspend the outer critical sections. This API does not provide a way +// to lock more than two objects at once (though it could be added later +// if actually needed). +// +// NOTE: Critical sections implicitly behave like reentrant locks because +// attempting to acquire the same lock will suspend any outer (earlier) +// critical sections. However, they are less efficient for this use case than +// purposefully designed reentrant locks. +// +// Example usage: +// Py_BEGIN_CRITICAL_SECTION(op); +// ... +// Py_END_CRITICAL_SECTION(); +// +// To lock two objects at once: +// Py_BEGIN_CRITICAL_SECTION2(op1, op2); +// ... +// Py_END_CRITICAL_SECTION2(); + +typedef struct PyCriticalSection PyCriticalSection; +typedef struct PyCriticalSection2 PyCriticalSection2; + +PyAPI_FUNC(void) +PyCriticalSection_Begin(PyCriticalSection *c, PyObject *op); + +PyAPI_FUNC(void) +PyCriticalSection_BeginMutex(PyCriticalSection *c, PyMutex *m); + +PyAPI_FUNC(void) +PyCriticalSection_End(PyCriticalSection *c); + +PyAPI_FUNC(void) +PyCriticalSection2_Begin(PyCriticalSection2 *c, PyObject *a, PyObject *b); + +PyAPI_FUNC(void) +PyCriticalSection2_BeginMutex(PyCriticalSection2 *c, PyMutex *m1, PyMutex *m2); + +PyAPI_FUNC(void) +PyCriticalSection2_End(PyCriticalSection2 *c); + +#ifndef Py_GIL_DISABLED +# define Py_BEGIN_CRITICAL_SECTION(op) \ + { +# define Py_BEGIN_CRITICAL_SECTION_MUTEX(mutex) \ + { +# define Py_END_CRITICAL_SECTION() \ + } +# define Py_BEGIN_CRITICAL_SECTION2(a, b) \ + { +# define Py_BEGIN_CRITICAL_SECTION2_MUTEX(m1, m2) \ + { +# define Py_END_CRITICAL_SECTION2() \ + } +#else /* !Py_GIL_DISABLED */ + +// NOTE: the contents of this struct are private and may change betweeen +// Python releases without a deprecation period. +struct PyCriticalSection { + // Tagged pointer to an outer active critical section (or 0). + uintptr_t _cs_prev; + + // Mutex used to protect critical section + PyMutex *_cs_mutex; +}; + +// A critical section protected by two mutexes. Use +// Py_BEGIN_CRITICAL_SECTION2 and Py_END_CRITICAL_SECTION2. +// NOTE: the contents of this struct are private and may change betweeen +// Python releases without a deprecation period. +struct PyCriticalSection2 { + PyCriticalSection _cs_base; + + PyMutex *_cs_mutex2; +}; + +# define Py_BEGIN_CRITICAL_SECTION(op) \ + { \ + PyCriticalSection _py_cs; \ + PyCriticalSection_Begin(&_py_cs, _PyObject_CAST(op)) + +# define Py_BEGIN_CRITICAL_SECTION_MUTEX(mutex) \ + { \ + PyCriticalSection _py_cs; \ + PyCriticalSection_BeginMutex(&_py_cs, mutex) + +# define Py_END_CRITICAL_SECTION() \ + PyCriticalSection_End(&_py_cs); \ + } + +# define Py_BEGIN_CRITICAL_SECTION2(a, b) \ + { \ + PyCriticalSection2 _py_cs2; \ + PyCriticalSection2_Begin(&_py_cs2, _PyObject_CAST(a), _PyObject_CAST(b)) + +# define Py_BEGIN_CRITICAL_SECTION2_MUTEX(m1, m2) \ + { \ + PyCriticalSection2 _py_cs2; \ + PyCriticalSection2_BeginMutex(&_py_cs2, m1, m2) + +# define Py_END_CRITICAL_SECTION2() \ + PyCriticalSection2_End(&_py_cs2); \ + } + +#endif diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/descrobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/descrobject.h new file mode 100644 index 0000000000000000000000000000000000000000..bbad8b59c225ab5a8e52493dcebd08ab7499e67e --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/descrobject.h @@ -0,0 +1,62 @@ +#ifndef Py_CPYTHON_DESCROBJECT_H +# error "this header file must not be included directly" +#endif + +typedef PyObject *(*wrapperfunc)(PyObject *self, PyObject *args, + void *wrapped); + +typedef PyObject *(*wrapperfunc_kwds)(PyObject *self, PyObject *args, + void *wrapped, PyObject *kwds); + +struct wrapperbase { + const char *name; + int offset; + void *function; + wrapperfunc wrapper; + const char *doc; + int flags; + PyObject *name_strobj; +}; + +/* Flags for above struct */ +#define PyWrapperFlag_KEYWORDS 1 /* wrapper function takes keyword args */ + +/* Various kinds of descriptor objects */ + +typedef struct { + PyObject_HEAD + PyTypeObject *d_type; + PyObject *d_name; + PyObject *d_qualname; +} PyDescrObject; + +#define PyDescr_COMMON PyDescrObject d_common + +#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type) +#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name) + +typedef struct { + PyDescr_COMMON; + PyMethodDef *d_method; + vectorcallfunc vectorcall; +} PyMethodDescrObject; + +typedef struct { + PyDescr_COMMON; + PyMemberDef *d_member; +} PyMemberDescrObject; + +typedef struct { + PyDescr_COMMON; + PyGetSetDef *d_getset; +} PyGetSetDescrObject; + +typedef struct { + PyDescr_COMMON; + struct wrapperbase *d_base; + void *d_wrapped; /* This can be any function pointer */ +} PyWrapperDescrObject; + +PyAPI_FUNC(PyObject *) PyDescr_NewWrapper(PyTypeObject *, + struct wrapperbase *, void *); +PyAPI_FUNC(int) PyDescr_IsData(PyObject *); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/dictobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/dictobject.h new file mode 100644 index 0000000000000000000000000000000000000000..df9ec7050fca1a99f66a4f5c70e60f15ded89ca7 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/dictobject.h @@ -0,0 +1,105 @@ +#ifndef Py_CPYTHON_DICTOBJECT_H +# error "this header file must not be included directly" +#endif + +typedef struct _dictkeysobject PyDictKeysObject; +typedef struct _dictvalues PyDictValues; + +/* The ma_values pointer is NULL for a combined table + * or points to an array of PyObject* for a split table + */ +typedef struct { + PyObject_HEAD + + /* Number of items in the dictionary */ + Py_ssize_t ma_used; + + /* This is a private field for CPython's internal use. + * Bits 0-7 are for dict watchers. + * Bits 8-11 are for the watched mutation counter (used by tier2 optimization) + * Bits 12-31 are currently unused + * Bits 32-63 are a unique id in the free threading build (used for per-thread refcounting) + */ + uint64_t _ma_watcher_tag; + + PyDictKeysObject *ma_keys; + + /* If ma_values is NULL, the table is "combined": keys and values + are stored in ma_keys. + + If ma_values is not NULL, the table is split: + keys are stored in ma_keys and values are stored in ma_values */ + PyDictValues *ma_values; +} PyDictObject; + +PyAPI_FUNC(PyObject *) _PyDict_GetItem_KnownHash(PyObject *mp, PyObject *key, + Py_hash_t hash); +// PyDict_GetItemStringRef() can be used instead +Py_DEPRECATED(3.14) PyAPI_FUNC(PyObject *) _PyDict_GetItemStringWithError(PyObject *, const char *); +PyAPI_FUNC(PyObject *) PyDict_SetDefault( + PyObject *mp, PyObject *key, PyObject *defaultobj); + +// Inserts `key` with a value `default_value`, if `key` is not already present +// in the dictionary. If `result` is not NULL, then the value associated +// with `key` is returned in `*result` (either the existing value, or the now +// inserted `default_value`). +// Returns: +// -1 on error +// 0 if `key` was not present and `default_value` was inserted +// 1 if `key` was present and `default_value` was not inserted +PyAPI_FUNC(int) PyDict_SetDefaultRef(PyObject *mp, PyObject *key, PyObject *default_value, PyObject **result); + +/* Get the number of items of a dictionary. */ +static inline Py_ssize_t PyDict_GET_SIZE(PyObject *op) { + PyDictObject *mp; + assert(PyDict_Check(op)); + mp = _Py_CAST(PyDictObject*, op); +#ifdef Py_GIL_DISABLED + return _Py_atomic_load_ssize_relaxed(&mp->ma_used); +#else + return mp->ma_used; +#endif +} +#define PyDict_GET_SIZE(op) PyDict_GET_SIZE(_PyObject_CAST(op)) + +PyAPI_FUNC(int) PyDict_ContainsString(PyObject *mp, const char *key); + +PyAPI_FUNC(PyObject *) _PyDict_NewPresized(Py_ssize_t minused); + +PyAPI_FUNC(int) PyDict_Pop(PyObject *dict, PyObject *key, PyObject **result); +PyAPI_FUNC(int) PyDict_PopString(PyObject *dict, const char *key, PyObject **result); + +// Use PyDict_Pop() instead +Py_DEPRECATED(3.14) PyAPI_FUNC(PyObject *) _PyDict_Pop( + PyObject *dict, + PyObject *key, + PyObject *default_value); + +/* Dictionary watchers */ + +#define PY_FOREACH_DICT_EVENT(V) \ + V(ADDED) \ + V(MODIFIED) \ + V(DELETED) \ + V(CLONED) \ + V(CLEARED) \ + V(DEALLOCATED) + +typedef enum { + #define PY_DEF_EVENT(EVENT) PyDict_EVENT_##EVENT, + PY_FOREACH_DICT_EVENT(PY_DEF_EVENT) + #undef PY_DEF_EVENT +} PyDict_WatchEvent; + +// Callback to be invoked when a watched dict is cleared, dealloced, or modified. +// In clear/dealloc case, key and new_value will be NULL. Otherwise, new_value will be the +// new value for key, NULL if key is being deleted. +typedef int(*PyDict_WatchCallback)(PyDict_WatchEvent event, PyObject* dict, PyObject* key, PyObject* new_value); + +// Register/unregister a dict-watcher callback +PyAPI_FUNC(int) PyDict_AddWatcher(PyDict_WatchCallback callback); +PyAPI_FUNC(int) PyDict_ClearWatcher(int watcher_id); + +// Mark given dictionary as "watched" (callback will be called if it is modified) +PyAPI_FUNC(int) PyDict_Watch(int watcher_id, PyObject* dict); +PyAPI_FUNC(int) PyDict_Unwatch(int watcher_id, PyObject* dict); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/fileobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/fileobject.h new file mode 100644 index 0000000000000000000000000000000000000000..e2d89c522bdd1326b440421c76f4cc0f77d6ba87 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/fileobject.h @@ -0,0 +1,16 @@ +#ifndef Py_CPYTHON_FILEOBJECT_H +# error "this header file must not be included directly" +#endif + +PyAPI_FUNC(char *) Py_UniversalNewlineFgets(char *, int, FILE*, PyObject *); + +/* The std printer acts as a preliminary sys.stderr until the new io + infrastructure is in place. */ +PyAPI_FUNC(PyObject *) PyFile_NewStdPrinter(int); +PyAPI_DATA(PyTypeObject) PyStdPrinter_Type; + +typedef PyObject * (*Py_OpenCodeHookFunction)(PyObject *, void *); + +PyAPI_FUNC(PyObject *) PyFile_OpenCode(const char *utf8path); +PyAPI_FUNC(PyObject *) PyFile_OpenCodeObject(PyObject *path); +PyAPI_FUNC(int) PyFile_SetOpenCodeHook(Py_OpenCodeHookFunction hook, void *userData); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/fileutils.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/fileutils.h new file mode 100644 index 0000000000000000000000000000000000000000..626b1ad57b384688609f0add0a2b52a3bbf8c97a --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/fileutils.h @@ -0,0 +1,16 @@ +#ifndef Py_CPYTHON_FILEUTILS_H +# error "this header file must not be included directly" +#endif + +PyAPI_FUNC(FILE*) Py_fopen( + PyObject *path, + const char *mode); + +// Deprecated alias kept for backward compatibility +Py_DEPRECATED(3.14) static inline FILE* +_Py_fopen_obj(PyObject *path, const char *mode) +{ + return Py_fopen(path, mode); +} + +PyAPI_FUNC(int) Py_fclose(FILE *file); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/floatobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/floatobject.h new file mode 100644 index 0000000000000000000000000000000000000000..127093098bfe642355383c0be1ba6e560b1f93cd --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/floatobject.h @@ -0,0 +1,27 @@ +#ifndef Py_CPYTHON_FLOATOBJECT_H +# error "this header file must not be included directly" +#endif + +typedef struct { + PyObject_HEAD + double ob_fval; +} PyFloatObject; + +#define _PyFloat_CAST(op) \ + (assert(PyFloat_Check(op)), _Py_CAST(PyFloatObject*, op)) + +// Static inline version of PyFloat_AsDouble() trading safety for speed. +// It doesn't check if op is a double object. +static inline double PyFloat_AS_DOUBLE(PyObject *op) { + return _PyFloat_CAST(op)->ob_fval; +} +#define PyFloat_AS_DOUBLE(op) PyFloat_AS_DOUBLE(_PyObject_CAST(op)) + + +PyAPI_FUNC(int) PyFloat_Pack2(double x, char *p, int le); +PyAPI_FUNC(int) PyFloat_Pack4(double x, char *p, int le); +PyAPI_FUNC(int) PyFloat_Pack8(double x, char *p, int le); + +PyAPI_FUNC(double) PyFloat_Unpack2(const char *p, int le); +PyAPI_FUNC(double) PyFloat_Unpack4(const char *p, int le); +PyAPI_FUNC(double) PyFloat_Unpack8(const char *p, int le); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/frameobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/frameobject.h new file mode 100644 index 0000000000000000000000000000000000000000..dbbfbb5105ba7aa51840beff4a90b4e103d497da --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/frameobject.h @@ -0,0 +1,35 @@ +/* Frame object interface */ + +#ifndef Py_CPYTHON_FRAMEOBJECT_H +# error "this header file must not be included directly" +#endif + +/* Standard object interface */ + +PyAPI_FUNC(PyFrameObject *) PyFrame_New(PyThreadState *, PyCodeObject *, + PyObject *, PyObject *); + +/* The rest of the interface is specific for frame objects */ + +/* Conversions between "fast locals" and locals in dictionary */ + +PyAPI_FUNC(void) PyFrame_LocalsToFast(PyFrameObject *, int); + +/* -- Caveat emptor -- + * The concept of entry frames is an implementation detail of the CPython + * interpreter. This API is considered unstable and is provided for the + * convenience of debuggers, profilers and state-inspecting tools. Notice that + * this API can be changed in future minor versions if the underlying frame + * mechanism change or the concept of an 'entry frame' or its semantics becomes + * obsolete or outdated. */ + +PyAPI_FUNC(int) _PyFrame_IsEntryFrame(PyFrameObject *frame); + +PyAPI_FUNC(int) PyFrame_FastToLocalsWithError(PyFrameObject *f); +PyAPI_FUNC(void) PyFrame_FastToLocals(PyFrameObject *); + + +typedef struct { + PyObject_HEAD + PyFrameObject* frame; +} PyFrameLocalsProxyObject; diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/funcobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/funcobject.h new file mode 100644 index 0000000000000000000000000000000000000000..598cd330bc9ca958a50a4ebc6ea09892d4a693d6 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/funcobject.h @@ -0,0 +1,185 @@ +/* Function object interface */ + +#ifndef Py_LIMITED_API +#ifndef Py_FUNCOBJECT_H +#define Py_FUNCOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + + +#define _Py_COMMON_FIELDS(PREFIX) \ + PyObject *PREFIX ## globals; \ + PyObject *PREFIX ## builtins; \ + PyObject *PREFIX ## name; \ + PyObject *PREFIX ## qualname; \ + PyObject *PREFIX ## code; /* A code object, the __code__ attribute */ \ + PyObject *PREFIX ## defaults; /* NULL or a tuple */ \ + PyObject *PREFIX ## kwdefaults; /* NULL or a dict */ \ + PyObject *PREFIX ## closure; /* NULL or a tuple of cell objects */ + +typedef struct { + _Py_COMMON_FIELDS(fc_) +} PyFrameConstructor; + +/* Function objects and code objects should not be confused with each other: + * + * Function objects are created by the execution of the 'def' statement. + * They reference a code object in their __code__ attribute, which is a + * purely syntactic object, i.e. nothing more than a compiled version of some + * source code lines. There is one code object per source code "fragment", + * but each code object can be referenced by zero or many function objects + * depending only on how many times the 'def' statement in the source was + * executed so far. + */ + +typedef struct { + PyObject_HEAD + _Py_COMMON_FIELDS(func_) + PyObject *func_doc; /* The __doc__ attribute, can be anything */ + PyObject *func_dict; /* The __dict__ attribute, a dict or NULL */ + PyObject *func_weakreflist; /* List of weak references */ + PyObject *func_module; /* The __module__ attribute, can be anything */ + PyObject *func_annotations; /* Annotations, a dict or NULL */ + PyObject *func_annotate; /* Callable to fill the annotations dictionary */ + PyObject *func_typeparams; /* Tuple of active type variables or NULL */ + vectorcallfunc vectorcall; + /* Version number for use by specializer. + * Can set to non-zero when we want to specialize. + * Will be set to zero if any of these change: + * defaults + * kwdefaults (only if the object changes, not the contents of the dict) + * code + * annotations + * vectorcall function pointer */ + uint32_t func_version; + + /* Invariant: + * func_closure contains the bindings for func_code->co_freevars, so + * PyTuple_Size(func_closure) == PyCode_GetNumFree(func_code) + * (func_closure may be NULL if PyCode_GetNumFree(func_code) == 0). + */ +} PyFunctionObject; + +#undef _Py_COMMON_FIELDS + +PyAPI_DATA(PyTypeObject) PyFunction_Type; + +#define PyFunction_Check(op) Py_IS_TYPE((op), &PyFunction_Type) + +PyAPI_FUNC(PyObject *) PyFunction_New(PyObject *, PyObject *); +PyAPI_FUNC(PyObject *) PyFunction_NewWithQualName(PyObject *, PyObject *, PyObject *); +PyAPI_FUNC(PyObject *) PyFunction_GetCode(PyObject *); +PyAPI_FUNC(PyObject *) PyFunction_GetGlobals(PyObject *); +PyAPI_FUNC(PyObject *) PyFunction_GetModule(PyObject *); +PyAPI_FUNC(PyObject *) PyFunction_GetDefaults(PyObject *); +PyAPI_FUNC(int) PyFunction_SetDefaults(PyObject *, PyObject *); +PyAPI_FUNC(void) PyFunction_SetVectorcall(PyFunctionObject *, vectorcallfunc); +PyAPI_FUNC(PyObject *) PyFunction_GetKwDefaults(PyObject *); +PyAPI_FUNC(int) PyFunction_SetKwDefaults(PyObject *, PyObject *); +PyAPI_FUNC(PyObject *) PyFunction_GetClosure(PyObject *); +PyAPI_FUNC(int) PyFunction_SetClosure(PyObject *, PyObject *); +PyAPI_FUNC(PyObject *) PyFunction_GetAnnotations(PyObject *); +PyAPI_FUNC(int) PyFunction_SetAnnotations(PyObject *, PyObject *); + +#define _PyFunction_CAST(func) \ + (assert(PyFunction_Check(func)), _Py_CAST(PyFunctionObject*, func)) + +/* Static inline functions for direct access to these values. + Type checks are *not* done, so use with care. */ +static inline PyObject* PyFunction_GET_CODE(PyObject *func) { + return _PyFunction_CAST(func)->func_code; +} +#define PyFunction_GET_CODE(func) PyFunction_GET_CODE(_PyObject_CAST(func)) + +static inline PyObject* PyFunction_GET_GLOBALS(PyObject *func) { + return _PyFunction_CAST(func)->func_globals; +} +#define PyFunction_GET_GLOBALS(func) PyFunction_GET_GLOBALS(_PyObject_CAST(func)) + +static inline PyObject* PyFunction_GET_MODULE(PyObject *func) { + return _PyFunction_CAST(func)->func_module; +} +#define PyFunction_GET_MODULE(func) PyFunction_GET_MODULE(_PyObject_CAST(func)) + +static inline PyObject* PyFunction_GET_DEFAULTS(PyObject *func) { + return _PyFunction_CAST(func)->func_defaults; +} +#define PyFunction_GET_DEFAULTS(func) PyFunction_GET_DEFAULTS(_PyObject_CAST(func)) + +static inline PyObject* PyFunction_GET_KW_DEFAULTS(PyObject *func) { + return _PyFunction_CAST(func)->func_kwdefaults; +} +#define PyFunction_GET_KW_DEFAULTS(func) PyFunction_GET_KW_DEFAULTS(_PyObject_CAST(func)) + +static inline PyObject* PyFunction_GET_CLOSURE(PyObject *func) { + return _PyFunction_CAST(func)->func_closure; +} +#define PyFunction_GET_CLOSURE(func) PyFunction_GET_CLOSURE(_PyObject_CAST(func)) + +static inline PyObject* PyFunction_GET_ANNOTATIONS(PyObject *func) { + return _PyFunction_CAST(func)->func_annotations; +} +#define PyFunction_GET_ANNOTATIONS(func) PyFunction_GET_ANNOTATIONS(_PyObject_CAST(func)) + +/* The classmethod and staticmethod types lives here, too */ +PyAPI_DATA(PyTypeObject) PyClassMethod_Type; +PyAPI_DATA(PyTypeObject) PyStaticMethod_Type; + +PyAPI_FUNC(PyObject *) PyClassMethod_New(PyObject *); +PyAPI_FUNC(PyObject *) PyStaticMethod_New(PyObject *); + +#define PY_FOREACH_FUNC_EVENT(V) \ + V(CREATE) \ + V(DESTROY) \ + V(MODIFY_CODE) \ + V(MODIFY_DEFAULTS) \ + V(MODIFY_KWDEFAULTS) + +typedef enum { + #define PY_DEF_EVENT(EVENT) PyFunction_EVENT_##EVENT, + PY_FOREACH_FUNC_EVENT(PY_DEF_EVENT) + #undef PY_DEF_EVENT +} PyFunction_WatchEvent; + +/* + * A callback that is invoked for different events in a function's lifecycle. + * + * The callback is invoked with a borrowed reference to func, after it is + * created and before it is modified or destroyed. The callback should not + * modify func. + * + * When a function's code object, defaults, or kwdefaults are modified the + * callback will be invoked with the respective event and new_value will + * contain a borrowed reference to the new value that is about to be stored in + * the function. Otherwise the third argument is NULL. + * + * If the callback returns with an exception set, it must return -1. Otherwise + * it should return 0. + */ +typedef int (*PyFunction_WatchCallback)( + PyFunction_WatchEvent event, + PyFunctionObject *func, + PyObject *new_value); + +/* + * Register a per-interpreter callback that will be invoked for function lifecycle + * events. + * + * Returns a handle that may be passed to PyFunction_ClearWatcher on success, + * or -1 and sets an error if no more handles are available. + */ +PyAPI_FUNC(int) PyFunction_AddWatcher(PyFunction_WatchCallback callback); + +/* + * Clear the watcher associated with the watcher_id handle. + * + * Returns 0 on success or -1 if no watcher exists for the supplied id. + */ +PyAPI_FUNC(int) PyFunction_ClearWatcher(int watcher_id); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_FUNCOBJECT_H */ +#endif /* Py_LIMITED_API */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/genobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/genobject.h new file mode 100644 index 0000000000000000000000000000000000000000..f75884e597e2c247f211d0159f72b051070531d0 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/genobject.h @@ -0,0 +1,56 @@ +/* Generator object interface */ + +#ifndef Py_LIMITED_API +#ifndef Py_GENOBJECT_H +#define Py_GENOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +/* --- Generators --------------------------------------------------------- */ + +typedef struct _PyGenObject PyGenObject; + +PyAPI_DATA(PyTypeObject) PyGen_Type; + +#define PyGen_Check(op) PyObject_TypeCheck((op), &PyGen_Type) +#define PyGen_CheckExact(op) Py_IS_TYPE((op), &PyGen_Type) + +PyAPI_FUNC(PyObject *) PyGen_New(PyFrameObject *); +PyAPI_FUNC(PyObject *) PyGen_NewWithQualName(PyFrameObject *, + PyObject *name, PyObject *qualname); +PyAPI_FUNC(PyCodeObject *) PyGen_GetCode(PyGenObject *gen); + + +/* --- PyCoroObject ------------------------------------------------------- */ + +typedef struct _PyCoroObject PyCoroObject; + +PyAPI_DATA(PyTypeObject) PyCoro_Type; + +#define PyCoro_CheckExact(op) Py_IS_TYPE((op), &PyCoro_Type) +PyAPI_FUNC(PyObject *) PyCoro_New(PyFrameObject *, + PyObject *name, PyObject *qualname); + + +/* --- Asynchronous Generators -------------------------------------------- */ + +typedef struct _PyAsyncGenObject PyAsyncGenObject; + +PyAPI_DATA(PyTypeObject) PyAsyncGen_Type; +PyAPI_DATA(PyTypeObject) _PyAsyncGenASend_Type; + +PyAPI_FUNC(PyObject *) PyAsyncGen_New(PyFrameObject *, + PyObject *name, PyObject *qualname); + +#define PyAsyncGen_CheckExact(op) Py_IS_TYPE((op), &PyAsyncGen_Type) + +#define PyAsyncGenASend_CheckExact(op) Py_IS_TYPE((op), &_PyAsyncGenASend_Type) + +#undef _PyGenObject_HEAD + +#ifdef __cplusplus +} +#endif +#endif /* !Py_GENOBJECT_H */ +#endif /* Py_LIMITED_API */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/import.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/import.h new file mode 100644 index 0000000000000000000000000000000000000000..0ce0b1ee6cce2a2c373e3cffb4f4ffcf1d0893fb --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/import.h @@ -0,0 +1,30 @@ +#ifndef Py_CPYTHON_IMPORT_H +# error "this header file must not be included directly" +#endif + +struct _inittab { + const char *name; /* ASCII encoded string */ + PyObject* (*initfunc)(void); +}; +// This is not used after Py_Initialize() is called. +PyAPI_DATA(struct _inittab *) PyImport_Inittab; +PyAPI_FUNC(int) PyImport_ExtendInittab(struct _inittab *newtab); + +struct _frozen { + const char *name; /* ASCII encoded string */ + const unsigned char *code; + int size; + int is_package; +}; + +/* Embedding apps may change this pointer to point to their favorite + collection of frozen modules: */ + +PyAPI_DATA(const struct _frozen *) PyImport_FrozenModules; + +PyAPI_FUNC(PyObject*) PyImport_ImportModuleAttr( + PyObject *mod_name, + PyObject *attr_name); +PyAPI_FUNC(PyObject*) PyImport_ImportModuleAttrString( + const char *mod_name, + const char *attr_name); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/initconfig.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/initconfig.h new file mode 100644 index 0000000000000000000000000000000000000000..7ce4acfeb7177d9ea99222b79caabb27815717cf --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/initconfig.h @@ -0,0 +1,334 @@ +#ifndef Py_PYCORECONFIG_H +#define Py_PYCORECONFIG_H +#ifndef Py_LIMITED_API +#ifdef __cplusplus +extern "C" { +#endif + +/* --- PyStatus ----------------------------------------------- */ + +typedef struct { + enum { + _PyStatus_TYPE_OK=0, + _PyStatus_TYPE_ERROR=1, + _PyStatus_TYPE_EXIT=2 + } _type; + const char *func; + const char *err_msg; + int exitcode; +} PyStatus; + +PyAPI_FUNC(PyStatus) PyStatus_Ok(void); +PyAPI_FUNC(PyStatus) PyStatus_Error(const char *err_msg); +PyAPI_FUNC(PyStatus) PyStatus_NoMemory(void); +PyAPI_FUNC(PyStatus) PyStatus_Exit(int exitcode); +PyAPI_FUNC(int) PyStatus_IsError(PyStatus err); +PyAPI_FUNC(int) PyStatus_IsExit(PyStatus err); +PyAPI_FUNC(int) PyStatus_Exception(PyStatus err); + +/* --- PyWideStringList ------------------------------------------------ */ + +typedef struct { + /* If length is greater than zero, items must be non-NULL + and all items strings must be non-NULL */ + Py_ssize_t length; + wchar_t **items; +} PyWideStringList; + +PyAPI_FUNC(PyStatus) PyWideStringList_Append(PyWideStringList *list, + const wchar_t *item); +PyAPI_FUNC(PyStatus) PyWideStringList_Insert(PyWideStringList *list, + Py_ssize_t index, + const wchar_t *item); + + +/* --- PyPreConfig ----------------------------------------------- */ + +typedef struct PyPreConfig { + int _config_init; /* _PyConfigInitEnum value */ + + /* Parse Py_PreInitializeFromBytesArgs() arguments? + See PyConfig.parse_argv */ + int parse_argv; + + /* If greater than 0, enable isolated mode: sys.path contains + neither the script's directory nor the user's site-packages directory. + + Set to 1 by the -I command line option. If set to -1 (default), inherit + Py_IsolatedFlag value. */ + int isolated; + + /* If greater than 0: use environment variables. + Set to 0 by -E command line option. If set to -1 (default), it is + set to !Py_IgnoreEnvironmentFlag. */ + int use_environment; + + /* Set the LC_CTYPE locale to the user preferred locale? If equals to 0, + set coerce_c_locale and coerce_c_locale_warn to 0. */ + int configure_locale; + + /* Coerce the LC_CTYPE locale if it's equal to "C"? (PEP 538) + + Set to 0 by PYTHONCOERCECLOCALE=0. Set to 1 by PYTHONCOERCECLOCALE=1. + Set to 2 if the user preferred LC_CTYPE locale is "C". + + If it is equal to 1, LC_CTYPE locale is read to decide if it should be + coerced or not (ex: PYTHONCOERCECLOCALE=1). Internally, it is set to 2 + if the LC_CTYPE locale must be coerced. + + Disable by default (set to 0). Set it to -1 to let Python decide if it + should be enabled or not. */ + int coerce_c_locale; + + /* Emit a warning if the LC_CTYPE locale is coerced? + + Set to 1 by PYTHONCOERCECLOCALE=warn. + + Disable by default (set to 0). Set it to -1 to let Python decide if it + should be enabled or not. */ + int coerce_c_locale_warn; + +#ifdef MS_WINDOWS + /* If greater than 1, use the "mbcs" encoding instead of the UTF-8 + encoding for the filesystem encoding. + + Set to 1 if the PYTHONLEGACYWINDOWSFSENCODING environment variable is + set to a non-empty string. If set to -1 (default), inherit + Py_LegacyWindowsFSEncodingFlag value. + + See PEP 529 for more details. */ + int legacy_windows_fs_encoding; +#endif + + /* Enable UTF-8 mode? (PEP 540) + + Disabled by default (equals to 0). + + Set to 1 by "-X utf8" and "-X utf8=1" command line options. + Set to 1 by PYTHONUTF8=1 environment variable. + + Set to 0 by "-X utf8=0" and PYTHONUTF8=0. + + If equals to -1, it is set to 1 if the LC_CTYPE locale is "C" or + "POSIX", otherwise it is set to 0. Inherit Py_UTF8Mode value value. */ + int utf8_mode; + + /* If non-zero, enable the Python Development Mode. + + Set to 1 by the -X dev command line option. Set by the PYTHONDEVMODE + environment variable. */ + int dev_mode; + + /* Memory allocator: PYTHONMALLOC env var. + See PyMemAllocatorName for valid values. */ + int allocator; +} PyPreConfig; + +PyAPI_FUNC(void) PyPreConfig_InitPythonConfig(PyPreConfig *config); +PyAPI_FUNC(void) PyPreConfig_InitIsolatedConfig(PyPreConfig *config); + + +/* --- PyConfig ---------------------------------------------- */ + +/* This structure is best documented in the Doc/c-api/init_config.rst file. */ +typedef struct PyConfig { + int _config_init; /* _PyConfigInitEnum value */ + + int isolated; + int use_environment; + int dev_mode; + int install_signal_handlers; + int use_hash_seed; + unsigned long hash_seed; + int faulthandler; + int tracemalloc; + int perf_profiling; + int remote_debug; + int import_time; + int code_debug_ranges; + int show_ref_count; + int dump_refs; + wchar_t *dump_refs_file; + int malloc_stats; + wchar_t *filesystem_encoding; + wchar_t *filesystem_errors; + wchar_t *pycache_prefix; + int parse_argv; + PyWideStringList orig_argv; + PyWideStringList argv; + PyWideStringList xoptions; + PyWideStringList warnoptions; + int site_import; + int bytes_warning; + int warn_default_encoding; + int inspect; + int interactive; + int optimization_level; + int parser_debug; + int write_bytecode; + int verbose; + int quiet; + int user_site_directory; + int configure_c_stdio; + int buffered_stdio; + wchar_t *stdio_encoding; + wchar_t *stdio_errors; +#ifdef MS_WINDOWS + int legacy_windows_stdio; +#endif + wchar_t *check_hash_pycs_mode; + int use_frozen_modules; + int safe_path; + int int_max_str_digits; + int thread_inherit_context; + int context_aware_warnings; +#ifdef __APPLE__ + int use_system_logger; +#endif + + int cpu_count; +#ifdef Py_GIL_DISABLED + int enable_gil; + int tlbc_enabled; +#endif + + /* --- Path configuration inputs ------------ */ + int pathconfig_warnings; + wchar_t *program_name; + wchar_t *pythonpath_env; + wchar_t *home; + wchar_t *platlibdir; + + /* --- Path configuration outputs ----------- */ + int module_search_paths_set; + PyWideStringList module_search_paths; + wchar_t *stdlib_dir; + wchar_t *executable; + wchar_t *base_executable; + wchar_t *prefix; + wchar_t *base_prefix; + wchar_t *exec_prefix; + wchar_t *base_exec_prefix; + + /* --- Parameter only used by Py_Main() ---------- */ + int skip_source_first_line; + wchar_t *run_command; + wchar_t *run_module; + wchar_t *run_filename; + + /* --- Set by Py_Main() -------------------------- */ + wchar_t *sys_path_0; + + /* --- Private fields ---------------------------- */ + + // Install importlib? If equals to 0, importlib is not initialized at all. + // Needed by freeze_importlib. + int _install_importlib; + + // If equal to 0, stop Python initialization before the "main" phase. + int _init_main; + + // If non-zero, we believe we're running from a source tree. + int _is_python_build; + +#ifdef Py_STATS + // If non-zero, turns on statistics gathering. + int _pystats; +#endif + +#ifdef Py_DEBUG + // If not empty, import a non-__main__ module before site.py is executed. + // PYTHON_PRESITE=package.module or -X presite=package.module + wchar_t *run_presite; +#endif +} PyConfig; + +PyAPI_FUNC(void) PyConfig_InitPythonConfig(PyConfig *config); +PyAPI_FUNC(void) PyConfig_InitIsolatedConfig(PyConfig *config); +PyAPI_FUNC(void) PyConfig_Clear(PyConfig *); +PyAPI_FUNC(PyStatus) PyConfig_SetString( + PyConfig *config, + wchar_t **config_str, + const wchar_t *str); +PyAPI_FUNC(PyStatus) PyConfig_SetBytesString( + PyConfig *config, + wchar_t **config_str, + const char *str); +PyAPI_FUNC(PyStatus) PyConfig_Read(PyConfig *config); +PyAPI_FUNC(PyStatus) PyConfig_SetBytesArgv( + PyConfig *config, + Py_ssize_t argc, + char * const *argv); +PyAPI_FUNC(PyStatus) PyConfig_SetArgv(PyConfig *config, + Py_ssize_t argc, + wchar_t * const *argv); +PyAPI_FUNC(PyStatus) PyConfig_SetWideStringList(PyConfig *config, + PyWideStringList *list, + Py_ssize_t length, wchar_t **items); + + +/* --- PyConfig_Get() ----------------------------------------- */ + +PyAPI_FUNC(PyObject*) PyConfig_Get(const char *name); +PyAPI_FUNC(int) PyConfig_GetInt(const char *name, int *value); +PyAPI_FUNC(PyObject*) PyConfig_Names(void); +PyAPI_FUNC(int) PyConfig_Set(const char *name, PyObject *value); + + +/* --- Helper functions --------------------------------------- */ + +/* Get the original command line arguments, before Python modified them. + + See also PyConfig.orig_argv. */ +PyAPI_FUNC(void) Py_GetArgcArgv(int *argc, wchar_t ***argv); + + +// --- PyInitConfig --------------------------------------------------------- + +typedef struct PyInitConfig PyInitConfig; + +PyAPI_FUNC(PyInitConfig*) PyInitConfig_Create(void); +PyAPI_FUNC(void) PyInitConfig_Free(PyInitConfig *config); + +PyAPI_FUNC(int) PyInitConfig_GetError(PyInitConfig* config, + const char **err_msg); +PyAPI_FUNC(int) PyInitConfig_GetExitCode(PyInitConfig* config, + int *exitcode); + +PyAPI_FUNC(int) PyInitConfig_HasOption(PyInitConfig *config, + const char *name); +PyAPI_FUNC(int) PyInitConfig_GetInt(PyInitConfig *config, + const char *name, + int64_t *value); +PyAPI_FUNC(int) PyInitConfig_GetStr(PyInitConfig *config, + const char *name, + char **value); +PyAPI_FUNC(int) PyInitConfig_GetStrList(PyInitConfig *config, + const char *name, + size_t *length, + char ***items); +PyAPI_FUNC(void) PyInitConfig_FreeStrList(size_t length, char **items); + +PyAPI_FUNC(int) PyInitConfig_SetInt(PyInitConfig *config, + const char *name, + int64_t value); +PyAPI_FUNC(int) PyInitConfig_SetStr(PyInitConfig *config, + const char *name, + const char *value); +PyAPI_FUNC(int) PyInitConfig_SetStrList(PyInitConfig *config, + const char *name, + size_t length, + char * const *items); + +PyAPI_FUNC(int) PyInitConfig_AddModule(PyInitConfig *config, + const char *name, + PyObject* (*initfunc)(void)); + +PyAPI_FUNC(int) Py_InitializeFromInitConfig(PyInitConfig *config); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_LIMITED_API */ +#endif /* !Py_PYCORECONFIG_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/listobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/listobject.h new file mode 100644 index 0000000000000000000000000000000000000000..49f5e8d6d1a0d6c2863925daaac16c07b6066948 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/listobject.h @@ -0,0 +1,53 @@ +#ifndef Py_CPYTHON_LISTOBJECT_H +# error "this header file must not be included directly" +#endif + +typedef struct { + PyObject_VAR_HEAD + /* Vector of pointers to list elements. list[0] is ob_item[0], etc. */ + PyObject **ob_item; + + /* ob_item contains space for 'allocated' elements. The number + * currently in use is ob_size. + * Invariants: + * 0 <= ob_size <= allocated + * len(list) == ob_size + * ob_item == NULL implies ob_size == allocated == 0 + * list.sort() temporarily sets allocated to -1 to detect mutations. + * + * Items must normally not be NULL, except during construction when + * the list is not yet visible outside the function that builds it. + */ + Py_ssize_t allocated; +} PyListObject; + +/* Cast argument to PyListObject* type. */ +#define _PyList_CAST(op) \ + (assert(PyList_Check(op)), _Py_CAST(PyListObject*, (op))) + +// Macros and static inline functions, trading safety for speed + +static inline Py_ssize_t PyList_GET_SIZE(PyObject *op) { + PyListObject *list = _PyList_CAST(op); +#ifdef Py_GIL_DISABLED + return _Py_atomic_load_ssize_relaxed(&(_PyVarObject_CAST(list)->ob_size)); +#else + return Py_SIZE(list); +#endif +} +#define PyList_GET_SIZE(op) PyList_GET_SIZE(_PyObject_CAST(op)) + +#define PyList_GET_ITEM(op, index) (_PyList_CAST(op)->ob_item[(index)]) + +static inline void +PyList_SET_ITEM(PyObject *op, Py_ssize_t index, PyObject *value) { + PyListObject *list = _PyList_CAST(op); + assert(0 <= index); + assert(index < list->allocated); + list->ob_item[index] = value; +} +#define PyList_SET_ITEM(op, index, value) \ + PyList_SET_ITEM(_PyObject_CAST(op), (index), _PyObject_CAST(value)) + +PyAPI_FUNC(int) PyList_Extend(PyObject *self, PyObject *iterable); +PyAPI_FUNC(int) PyList_Clear(PyObject *self); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/lock.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/lock.h new file mode 100644 index 0000000000000000000000000000000000000000..63886fca28eae24ac903a5267ffd03c8d2e469b7 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/lock.h @@ -0,0 +1,74 @@ +#ifndef Py_CPYTHON_LOCK_H +# error "this header file must not be included directly" +#endif + +#define _Py_UNLOCKED 0 +#define _Py_LOCKED 1 + +// A mutex that occupies one byte. The lock can be zero initialized to +// represent the unlocked state. +// +// Typical initialization: +// PyMutex m = (PyMutex){0}; +// +// Or initialize as global variables: +// static PyMutex m; +// +// Typical usage: +// PyMutex_Lock(&m); +// ... +// PyMutex_Unlock(&m); +// +// The contents of the PyMutex are not part of the public API, but are +// described to aid in understanding the implementation and debugging. Only +// the two least significant bits are used. The remaining bits are always zero: +// 0b00: unlocked +// 0b01: locked +// 0b10: unlocked and has parked threads +// 0b11: locked and has parked threads +typedef struct PyMutex { + uint8_t _bits; // (private) +} PyMutex; + +// exported function for locking the mutex +PyAPI_FUNC(void) PyMutex_Lock(PyMutex *m); + +// exported function for unlocking the mutex +PyAPI_FUNC(void) PyMutex_Unlock(PyMutex *m); + +// exported function for checking if the mutex is locked +PyAPI_FUNC(int) PyMutex_IsLocked(PyMutex *m); + +// Locks the mutex. +// +// If the mutex is currently locked, the calling thread will be parked until +// the mutex is unlocked. If the current thread holds the GIL, then the GIL +// will be released while the thread is parked. +static inline void +_PyMutex_Lock(PyMutex *m) +{ + uint8_t expected = _Py_UNLOCKED; + if (!_Py_atomic_compare_exchange_uint8(&m->_bits, &expected, _Py_LOCKED)) { + PyMutex_Lock(m); + } +} +#define PyMutex_Lock _PyMutex_Lock + +// Unlocks the mutex. +static inline void +_PyMutex_Unlock(PyMutex *m) +{ + uint8_t expected = _Py_LOCKED; + if (!_Py_atomic_compare_exchange_uint8(&m->_bits, &expected, _Py_UNLOCKED)) { + PyMutex_Unlock(m); + } +} +#define PyMutex_Unlock _PyMutex_Unlock + +// Checks if the mutex is currently locked. +static inline int +_PyMutex_IsLocked(PyMutex *m) +{ + return (_Py_atomic_load_uint8(&m->_bits) & _Py_LOCKED) != 0; +} +#define PyMutex_IsLocked _PyMutex_IsLocked diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/longintrepr.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/longintrepr.h new file mode 100644 index 0000000000000000000000000000000000000000..4b6f97a5e475d65497a0bc0b1d51425b612ae5c2 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/longintrepr.h @@ -0,0 +1,184 @@ +#ifndef Py_LIMITED_API +#ifndef Py_LONGINTREPR_H +#define Py_LONGINTREPR_H +#ifdef __cplusplus +extern "C" { +#endif + + +/* This is published for the benefit of "friends" marshal.c and _decimal.c. */ + +/* Parameters of the integer representation. There are two different + sets of parameters: one set for 30-bit digits, stored in an unsigned 32-bit + integer type, and one set for 15-bit digits with each digit stored in an + unsigned short. The value of PYLONG_BITS_IN_DIGIT, defined either at + configure time or in pyport.h, is used to decide which digit size to use. + + Type 'digit' should be able to hold 2*PyLong_BASE-1, and type 'twodigits' + should be an unsigned integer type able to hold all integers up to + PyLong_BASE*PyLong_BASE-1. x_sub assumes that 'digit' is an unsigned type, + and that overflow is handled by taking the result modulo 2**N for some N > + PyLong_SHIFT. The majority of the code doesn't care about the precise + value of PyLong_SHIFT, but there are some notable exceptions: + + - PyLong_{As,From}ByteArray require that PyLong_SHIFT be at least 8 + + - long_hash() requires that PyLong_SHIFT is *strictly* less than the number + of bits in an unsigned long, as do the PyLong <-> long (or unsigned long) + conversion functions + + - the Python int <-> size_t/Py_ssize_t conversion functions expect that + PyLong_SHIFT is strictly less than the number of bits in a size_t + + - the marshal code currently expects that PyLong_SHIFT is a multiple of 15 + + - NSMALLNEGINTS and NSMALLPOSINTS should be small enough to fit in a single + digit; with the current values this forces PyLong_SHIFT >= 9 + + The values 15 and 30 should fit all of the above requirements, on any + platform. +*/ + +#if PYLONG_BITS_IN_DIGIT == 30 +typedef uint32_t digit; +typedef int32_t sdigit; /* signed variant of digit */ +typedef uint64_t twodigits; +typedef int64_t stwodigits; /* signed variant of twodigits */ +#define PyLong_SHIFT 30 +#define _PyLong_DECIMAL_SHIFT 9 /* max(e such that 10**e fits in a digit) */ +#define _PyLong_DECIMAL_BASE ((digit)1000000000) /* 10 ** DECIMAL_SHIFT */ +#elif PYLONG_BITS_IN_DIGIT == 15 +typedef unsigned short digit; +typedef short sdigit; /* signed variant of digit */ +typedef unsigned long twodigits; +typedef long stwodigits; /* signed variant of twodigits */ +#define PyLong_SHIFT 15 +#define _PyLong_DECIMAL_SHIFT 4 /* max(e such that 10**e fits in a digit) */ +#define _PyLong_DECIMAL_BASE ((digit)10000) /* 10 ** DECIMAL_SHIFT */ +#else +#error "PYLONG_BITS_IN_DIGIT should be 15 or 30" +#endif +#define PyLong_BASE ((digit)1 << PyLong_SHIFT) +#define PyLong_MASK ((digit)(PyLong_BASE - 1)) + +/* Long integer representation. + + Long integers are made up of a number of 30- or 15-bit digits, depending on + the platform. The number of digits (ndigits) is stored in the high bits of + the lv_tag field (lvtag >> _PyLong_NON_SIZE_BITS). + + The absolute value of a number is equal to + SUM(for i=0 through ndigits-1) ob_digit[i] * 2**(PyLong_SHIFT*i) + + The sign of the value is stored in the lower 2 bits of lv_tag. + + - 0: Positive + - 1: Zero + - 2: Negative + + The third lowest bit of lv_tag is + set to 1 for the small ints. + + In a normalized number, ob_digit[ndigits-1] (the most significant + digit) is never zero. Also, in all cases, for all valid i, + 0 <= ob_digit[i] <= PyLong_MASK. + + The allocation function takes care of allocating extra memory + so that ob_digit[0] ... ob_digit[ndigits-1] are actually available. + We always allocate memory for at least one digit, so accessing ob_digit[0] + is always safe. However, in the case ndigits == 0, the contents of + ob_digit[0] may be undefined. +*/ + +typedef struct _PyLongValue { + uintptr_t lv_tag; /* Number of digits, sign and flags */ + digit ob_digit[1]; +} _PyLongValue; + +struct _longobject { + PyObject_HEAD + _PyLongValue long_value; +}; + +Py_DEPRECATED(3.14) PyAPI_FUNC(PyLongObject*) _PyLong_New(Py_ssize_t); + +// Return a copy of src. +PyAPI_FUNC(PyObject*) _PyLong_Copy(PyLongObject *src); + +Py_DEPRECATED(3.14) PyAPI_FUNC(PyLongObject*) _PyLong_FromDigits( + int negative, + Py_ssize_t digit_count, + digit *digits); + + +/* Inline some internals for speed. These should be in pycore_long.h + * if user code didn't need them inlined. */ + +#define _PyLong_SIGN_MASK 3 +#define _PyLong_NON_SIZE_BITS 3 + + +static inline int +_PyLong_IsCompact(const PyLongObject* op) { + assert(PyType_HasFeature(op->ob_base.ob_type, Py_TPFLAGS_LONG_SUBCLASS)); + return op->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS); +} + +#define PyUnstable_Long_IsCompact _PyLong_IsCompact + +static inline Py_ssize_t +_PyLong_CompactValue(const PyLongObject *op) +{ + Py_ssize_t sign; + assert(PyType_HasFeature(op->ob_base.ob_type, Py_TPFLAGS_LONG_SUBCLASS)); + assert(PyUnstable_Long_IsCompact(op)); + sign = 1 - (op->long_value.lv_tag & _PyLong_SIGN_MASK); + return sign * (Py_ssize_t)op->long_value.ob_digit[0]; +} + +#define PyUnstable_Long_CompactValue _PyLong_CompactValue + + +/* --- Import/Export API -------------------------------------------------- */ + +typedef struct PyLongLayout { + uint8_t bits_per_digit; + uint8_t digit_size; + int8_t digits_order; + int8_t digit_endianness; +} PyLongLayout; + +PyAPI_FUNC(const PyLongLayout*) PyLong_GetNativeLayout(void); + +typedef struct PyLongExport { + int64_t value; + uint8_t negative; + Py_ssize_t ndigits; + const void *digits; + // Member used internally, must not be used for other purpose. + Py_uintptr_t _reserved; +} PyLongExport; + +PyAPI_FUNC(int) PyLong_Export( + PyObject *obj, + PyLongExport *export_long); +PyAPI_FUNC(void) PyLong_FreeExport( + PyLongExport *export_long); + + +/* --- PyLongWriter API --------------------------------------------------- */ + +typedef struct PyLongWriter PyLongWriter; + +PyAPI_FUNC(PyLongWriter*) PyLongWriter_Create( + int negative, + Py_ssize_t ndigits, + void **digits); +PyAPI_FUNC(PyObject*) PyLongWriter_Finish(PyLongWriter *writer); +PyAPI_FUNC(void) PyLongWriter_Discard(PyLongWriter *writer); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_LONGINTREPR_H */ +#endif /* Py_LIMITED_API */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/longobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/longobject.h new file mode 100644 index 0000000000000000000000000000000000000000..32e6fd73fb5c604c066a933da19b59bddf6db698 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/longobject.h @@ -0,0 +1,89 @@ +#ifndef Py_CPYTHON_LONGOBJECT_H +# error "this header file must not be included directly" +#endif + +#define _PyLong_CAST(op) \ + (assert(PyLong_Check(op)), _Py_CAST(PyLongObject*, (op))) + +PyAPI_FUNC(PyObject*) PyLong_FromUnicodeObject(PyObject *u, int base); + +PyAPI_FUNC(int) PyUnstable_Long_IsCompact(const PyLongObject* op); +PyAPI_FUNC(Py_ssize_t) PyUnstable_Long_CompactValue(const PyLongObject* op); + +/* PyLong_IsPositive. Check if the integer object is positive. + + - On success, return 1 if *obj is positive, and 0 otherwise. + - On failure, set an exception, and return -1. */ +PyAPI_FUNC(int) PyLong_IsPositive(PyObject *obj); + +/* PyLong_IsNegative. Check if the integer object is negative. + + - On success, return 1 if *obj is negative, and 0 otherwise. + - On failure, set an exception, and return -1. */ +PyAPI_FUNC(int) PyLong_IsNegative(PyObject *obj); + +/* PyLong_IsZero. Check if the integer object is zero. + + - On success, return 1 if *obj is zero, and 0 if it is non-zero. + - On failure, set an exception, and return -1. */ +PyAPI_FUNC(int) PyLong_IsZero(PyObject *obj); + +/* PyLong_GetSign. Get the sign of an integer object: + 0, -1 or +1 for zero, negative or positive integer, respectively. + + - On success, set '*sign' to the integer sign, and return 0. + - On failure, set an exception, and return -1. */ +PyAPI_FUNC(int) PyLong_GetSign(PyObject *v, int *sign); + +Py_DEPRECATED(3.14) PyAPI_FUNC(int) _PyLong_Sign(PyObject *v); + +/* _PyLong_NumBits. Return the number of bits needed to represent the + absolute value of a long. For example, this returns 1 for 1 and -1, 2 + for 2 and -2, and 2 for 3 and -3. It returns 0 for 0. + v must not be NULL, and must be a normalized long. + Always successful. +*/ +PyAPI_FUNC(int64_t) _PyLong_NumBits(PyObject *v); + +/* _PyLong_FromByteArray: View the n unsigned bytes as a binary integer in + base 256, and return a Python int with the same numeric value. + If n is 0, the integer is 0. Else: + If little_endian is 1/true, bytes[n-1] is the MSB and bytes[0] the LSB; + else (little_endian is 0/false) bytes[0] is the MSB and bytes[n-1] the + LSB. + If is_signed is 0/false, view the bytes as a non-negative integer. + If is_signed is 1/true, view the bytes as a 2's-complement integer, + non-negative if bit 0x80 of the MSB is clear, negative if set. + Error returns: + + Return NULL with the appropriate exception set if there's not + enough memory to create the Python int. +*/ +PyAPI_FUNC(PyObject *) _PyLong_FromByteArray( + const unsigned char* bytes, size_t n, + int little_endian, int is_signed); + +/* _PyLong_AsByteArray: Convert the least-significant 8*n bits of long + v to a base-256 integer, stored in array bytes. Normally return 0, + return -1 on error. + If little_endian is 1/true, store the MSB at bytes[n-1] and the LSB at + bytes[0]; else (little_endian is 0/false) store the MSB at bytes[0] and + the LSB at bytes[n-1]. + If is_signed is 0/false, it's an error if v < 0; else (v >= 0) n bytes + are filled and there's nothing special about bit 0x80 of the MSB. + If is_signed is 1/true, bytes is filled with the 2's-complement + representation of v's value. Bit 0x80 of the MSB is the sign bit. + Error returns (-1): + + is_signed is 0 and v < 0. TypeError is set in this case, and bytes + isn't altered. + + n isn't big enough to hold the full mathematical value of v. For + example, if is_signed is 0 and there are more digits in the v than + fit in n; or if is_signed is 1, v < 0, and n is just 1 bit shy of + being large enough to hold a sign bit. OverflowError is set in this + case, but bytes holds the least-significant n bytes of the true value. +*/ +PyAPI_FUNC(int) _PyLong_AsByteArray(PyLongObject* v, + unsigned char* bytes, size_t n, + int little_endian, int is_signed, int with_exceptions); + +/* For use by the gcd function in mathmodule.c */ +PyAPI_FUNC(PyObject *) _PyLong_GCD(PyObject *, PyObject *); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/memoryobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/memoryobject.h new file mode 100644 index 0000000000000000000000000000000000000000..961161b70f20580b9d1c1408b3b58aebf01214ec --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/memoryobject.h @@ -0,0 +1,50 @@ +#ifndef Py_CPYTHON_MEMORYOBJECT_H +# error "this header file must not be included directly" +#endif + +/* The structs are declared here so that macros can work, but they shouldn't + be considered public. Don't access their fields directly, use the macros + and functions instead! */ +#define _Py_MANAGED_BUFFER_RELEASED 0x001 /* access to exporter blocked */ +#define _Py_MANAGED_BUFFER_FREE_FORMAT 0x002 /* free format */ + +typedef struct { + PyObject_HEAD + int flags; /* state flags */ + Py_ssize_t exports; /* number of direct memoryview exports */ + Py_buffer master; /* snapshot buffer obtained from the original exporter */ +} _PyManagedBufferObject; + + +/* memoryview state flags */ +#define _Py_MEMORYVIEW_RELEASED 0x001 /* access to master buffer blocked */ +#define _Py_MEMORYVIEW_C 0x002 /* C-contiguous layout */ +#define _Py_MEMORYVIEW_FORTRAN 0x004 /* Fortran contiguous layout */ +#define _Py_MEMORYVIEW_SCALAR 0x008 /* scalar: ndim = 0 */ +#define _Py_MEMORYVIEW_PIL 0x010 /* PIL-style layout */ +#define _Py_MEMORYVIEW_RESTRICTED 0x020 /* Disallow new references to the memoryview's buffer */ + +typedef struct { + PyObject_VAR_HEAD + _PyManagedBufferObject *mbuf; /* managed buffer */ + Py_hash_t hash; /* hash value for read-only views */ + int flags; /* state flags */ + Py_ssize_t exports; /* number of buffer re-exports */ + Py_buffer view; /* private copy of the exporter's view */ + PyObject *weakreflist; + Py_ssize_t ob_array[1]; /* shape, strides, suboffsets */ +} PyMemoryViewObject; + +#define _PyMemoryView_CAST(op) _Py_CAST(PyMemoryViewObject*, op) + +/* Get a pointer to the memoryview's private copy of the exporter's buffer. */ +static inline Py_buffer* PyMemoryView_GET_BUFFER(PyObject *op) { + return (&_PyMemoryView_CAST(op)->view); +} +#define PyMemoryView_GET_BUFFER(op) PyMemoryView_GET_BUFFER(_PyObject_CAST(op)) + +/* Get a pointer to the exporting object (this may be NULL!). */ +static inline PyObject* PyMemoryView_GET_BASE(PyObject *op) { + return _PyMemoryView_CAST(op)->view.obj; +} +#define PyMemoryView_GET_BASE(op) PyMemoryView_GET_BASE(_PyObject_CAST(op)) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/methodobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/methodobject.h new file mode 100644 index 0000000000000000000000000000000000000000..d541e1549480417fbce8933e222821ef8aab6247 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/methodobject.h @@ -0,0 +1,66 @@ +#ifndef Py_CPYTHON_METHODOBJECT_H +# error "this header file must not be included directly" +#endif + +// PyCFunctionObject structure + +typedef struct { + PyObject_HEAD + PyMethodDef *m_ml; /* Description of the C function to call */ + PyObject *m_self; /* Passed as 'self' arg to the C func, can be NULL */ + PyObject *m_module; /* The __module__ attribute, can be anything */ + PyObject *m_weakreflist; /* List of weak references */ + vectorcallfunc vectorcall; +} PyCFunctionObject; + +#define _PyCFunctionObject_CAST(func) \ + (assert(PyCFunction_Check(func)), \ + _Py_CAST(PyCFunctionObject*, (func))) + + +// PyCMethodObject structure + +typedef struct { + PyCFunctionObject func; + PyTypeObject *mm_class; /* Class that defines this method */ +} PyCMethodObject; + +#define _PyCMethodObject_CAST(func) \ + (assert(PyCMethod_Check(func)), \ + _Py_CAST(PyCMethodObject*, (func))) + +PyAPI_DATA(PyTypeObject) PyCMethod_Type; + +#define PyCMethod_CheckExact(op) Py_IS_TYPE((op), &PyCMethod_Type) +#define PyCMethod_Check(op) PyObject_TypeCheck((op), &PyCMethod_Type) + + +/* Static inline functions for direct access to these values. + Type checks are *not* done, so use with care. */ +static inline PyCFunction PyCFunction_GET_FUNCTION(PyObject *func) { + return _PyCFunctionObject_CAST(func)->m_ml->ml_meth; +} +#define PyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(_PyObject_CAST(func)) + +static inline PyObject* PyCFunction_GET_SELF(PyObject *func_obj) { + PyCFunctionObject *func = _PyCFunctionObject_CAST(func_obj); + if (func->m_ml->ml_flags & METH_STATIC) { + return _Py_NULL; + } + return func->m_self; +} +#define PyCFunction_GET_SELF(func) PyCFunction_GET_SELF(_PyObject_CAST(func)) + +static inline int PyCFunction_GET_FLAGS(PyObject *func) { + return _PyCFunctionObject_CAST(func)->m_ml->ml_flags; +} +#define PyCFunction_GET_FLAGS(func) PyCFunction_GET_FLAGS(_PyObject_CAST(func)) + +static inline PyTypeObject* PyCFunction_GET_CLASS(PyObject *func_obj) { + PyCFunctionObject *func = _PyCFunctionObject_CAST(func_obj); + if (func->m_ml->ml_flags & METH_METHOD) { + return _PyCMethodObject_CAST(func)->mm_class; + } + return _Py_NULL; +} +#define PyCFunction_GET_CLASS(func) PyCFunction_GET_CLASS(_PyObject_CAST(func)) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/modsupport.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/modsupport.h new file mode 100644 index 0000000000000000000000000000000000000000..d3b88f58c82ca3e923cb7756871113f1dfcafec7 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/modsupport.h @@ -0,0 +1,26 @@ +#ifndef Py_CPYTHON_MODSUPPORT_H +# error "this header file must not be included directly" +#endif + +// A data structure that can be used to run initialization code once in a +// thread-safe manner. The C++11 equivalent is std::call_once. +typedef struct { + uint8_t v; +} _PyOnceFlag; + +typedef struct _PyArg_Parser { + const char *format; + const char * const *keywords; + const char *fname; + const char *custom_msg; + _PyOnceFlag once; /* atomic one-time initialization flag */ + int is_kwtuple_owned; /* does this parser own the kwtuple object? */ + int pos; /* number of positional-only arguments */ + int min; /* minimal number of arguments */ + int max; /* maximal number of positional arguments */ + PyObject *kwtuple; /* tuple of keyword parameter names */ + struct _PyArg_Parser *next; +} _PyArg_Parser; + +PyAPI_FUNC(int) _PyArg_ParseTupleAndKeywordsFast(PyObject *, PyObject *, + struct _PyArg_Parser *, ...); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/monitoring.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/monitoring.h new file mode 100644 index 0000000000000000000000000000000000000000..ce92942404c9f7db3f9bf0378c1fa6d500ccf7bc --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/monitoring.h @@ -0,0 +1,269 @@ +#ifndef Py_CPYTHON_MONITORING_H +# error "this header file must not be included directly" +#endif + +/* Local events. + * These require bytecode instrumentation */ + +#define PY_MONITORING_EVENT_PY_START 0 +#define PY_MONITORING_EVENT_PY_RESUME 1 +#define PY_MONITORING_EVENT_PY_RETURN 2 +#define PY_MONITORING_EVENT_PY_YIELD 3 +#define PY_MONITORING_EVENT_CALL 4 +#define PY_MONITORING_EVENT_LINE 5 +#define PY_MONITORING_EVENT_INSTRUCTION 6 +#define PY_MONITORING_EVENT_JUMP 7 +#define PY_MONITORING_EVENT_BRANCH_LEFT 8 +#define PY_MONITORING_EVENT_BRANCH_RIGHT 9 +#define PY_MONITORING_EVENT_STOP_ITERATION 10 + +#define PY_MONITORING_IS_INSTRUMENTED_EVENT(ev) \ + ((ev) < _PY_MONITORING_LOCAL_EVENTS) + +/* Other events, mainly exceptions */ + +#define PY_MONITORING_EVENT_RAISE 11 +#define PY_MONITORING_EVENT_EXCEPTION_HANDLED 12 +#define PY_MONITORING_EVENT_PY_UNWIND 13 +#define PY_MONITORING_EVENT_PY_THROW 14 +#define PY_MONITORING_EVENT_RERAISE 15 + + +/* Ancillary events */ + +#define PY_MONITORING_EVENT_C_RETURN 16 +#define PY_MONITORING_EVENT_C_RAISE 17 +#define PY_MONITORING_EVENT_BRANCH 18 + + +typedef struct _PyMonitoringState { + uint8_t active; + uint8_t opaque; +} PyMonitoringState; + + +PyAPI_FUNC(int) +PyMonitoring_EnterScope(PyMonitoringState *state_array, uint64_t *version, + const uint8_t *event_types, Py_ssize_t length); + +PyAPI_FUNC(int) +PyMonitoring_ExitScope(void); + + +PyAPI_FUNC(int) +_PyMonitoring_FirePyStartEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset); + +PyAPI_FUNC(int) +_PyMonitoring_FirePyResumeEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset); + +PyAPI_FUNC(int) +_PyMonitoring_FirePyReturnEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset, + PyObject *retval); + +PyAPI_FUNC(int) +_PyMonitoring_FirePyYieldEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset, + PyObject *retval); + +PyAPI_FUNC(int) +_PyMonitoring_FireCallEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset, + PyObject* callable, PyObject *arg0); + +PyAPI_FUNC(int) +_PyMonitoring_FireLineEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset, + int lineno); + +PyAPI_FUNC(int) +_PyMonitoring_FireJumpEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset, + PyObject *target_offset); + +Py_DEPRECATED(3.14) PyAPI_FUNC(int) +_PyMonitoring_FireBranchEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset, + PyObject *target_offset); + +PyAPI_FUNC(int) +_PyMonitoring_FireBranchRightEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset, + PyObject *target_offset); + +PyAPI_FUNC(int) +_PyMonitoring_FireBranchLeftEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset, + PyObject *target_offset); + +PyAPI_FUNC(int) +_PyMonitoring_FireCReturnEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset, + PyObject *retval); + +PyAPI_FUNC(int) +_PyMonitoring_FirePyThrowEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset); + +PyAPI_FUNC(int) +_PyMonitoring_FireRaiseEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset); + +PyAPI_FUNC(int) +_PyMonitoring_FireReraiseEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset); + +PyAPI_FUNC(int) +_PyMonitoring_FireExceptionHandledEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset); + +PyAPI_FUNC(int) +_PyMonitoring_FireCRaiseEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset); + +PyAPI_FUNC(int) +_PyMonitoring_FirePyUnwindEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset); + +PyAPI_FUNC(int) +_PyMonitoring_FireStopIterationEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset, PyObject *value); + + +#define _PYMONITORING_IF_ACTIVE(STATE, X) \ + if ((STATE)->active) { \ + return (X); \ + } \ + else { \ + return 0; \ + } + +static inline int +PyMonitoring_FirePyStartEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset) +{ + _PYMONITORING_IF_ACTIVE( + state, + _PyMonitoring_FirePyStartEvent(state, codelike, offset)); +} + +static inline int +PyMonitoring_FirePyResumeEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset) +{ + _PYMONITORING_IF_ACTIVE( + state, + _PyMonitoring_FirePyResumeEvent(state, codelike, offset)); +} + +static inline int +PyMonitoring_FirePyReturnEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset, + PyObject *retval) +{ + _PYMONITORING_IF_ACTIVE( + state, + _PyMonitoring_FirePyReturnEvent(state, codelike, offset, retval)); +} + +static inline int +PyMonitoring_FirePyYieldEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset, + PyObject *retval) +{ + _PYMONITORING_IF_ACTIVE( + state, + _PyMonitoring_FirePyYieldEvent(state, codelike, offset, retval)); +} + +static inline int +PyMonitoring_FireCallEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset, + PyObject* callable, PyObject *arg0) +{ + _PYMONITORING_IF_ACTIVE( + state, + _PyMonitoring_FireCallEvent(state, codelike, offset, callable, arg0)); +} + +static inline int +PyMonitoring_FireLineEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset, + int lineno) +{ + _PYMONITORING_IF_ACTIVE( + state, + _PyMonitoring_FireLineEvent(state, codelike, offset, lineno)); +} + +static inline int +PyMonitoring_FireJumpEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset, + PyObject *target_offset) +{ + _PYMONITORING_IF_ACTIVE( + state, + _PyMonitoring_FireJumpEvent(state, codelike, offset, target_offset)); +} + +static inline int +PyMonitoring_FireBranchRightEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset, + PyObject *target_offset) +{ + _PYMONITORING_IF_ACTIVE( + state, + _PyMonitoring_FireBranchRightEvent(state, codelike, offset, target_offset)); +} + +static inline int +PyMonitoring_FireBranchLeftEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset, + PyObject *target_offset) +{ + _PYMONITORING_IF_ACTIVE( + state, + _PyMonitoring_FireBranchLeftEvent(state, codelike, offset, target_offset)); +} + +static inline int +PyMonitoring_FireCReturnEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset, + PyObject *retval) +{ + _PYMONITORING_IF_ACTIVE( + state, + _PyMonitoring_FireCReturnEvent(state, codelike, offset, retval)); +} + +static inline int +PyMonitoring_FirePyThrowEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset) +{ + _PYMONITORING_IF_ACTIVE( + state, + _PyMonitoring_FirePyThrowEvent(state, codelike, offset)); +} + +static inline int +PyMonitoring_FireRaiseEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset) +{ + _PYMONITORING_IF_ACTIVE( + state, + _PyMonitoring_FireRaiseEvent(state, codelike, offset)); +} + +static inline int +PyMonitoring_FireReraiseEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset) +{ + _PYMONITORING_IF_ACTIVE( + state, + _PyMonitoring_FireReraiseEvent(state, codelike, offset)); +} + +static inline int +PyMonitoring_FireExceptionHandledEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset) +{ + _PYMONITORING_IF_ACTIVE( + state, + _PyMonitoring_FireExceptionHandledEvent(state, codelike, offset)); +} + +static inline int +PyMonitoring_FireCRaiseEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset) +{ + _PYMONITORING_IF_ACTIVE( + state, + _PyMonitoring_FireCRaiseEvent(state, codelike, offset)); +} + +static inline int +PyMonitoring_FirePyUnwindEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset) +{ + _PYMONITORING_IF_ACTIVE( + state, + _PyMonitoring_FirePyUnwindEvent(state, codelike, offset)); +} + +static inline int +PyMonitoring_FireStopIterationEvent(PyMonitoringState *state, PyObject *codelike, int32_t offset, PyObject *value) +{ + _PYMONITORING_IF_ACTIVE( + state, + _PyMonitoring_FireStopIterationEvent(state, codelike, offset, value)); +} + +#undef _PYMONITORING_IF_ACTIVE diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/object.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/object.h new file mode 100644 index 0000000000000000000000000000000000000000..973d358ed8e4ec7c66c578d06869a00b73883a6f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/object.h @@ -0,0 +1,493 @@ +#ifndef Py_CPYTHON_OBJECT_H +# error "this header file must not be included directly" +#endif + +PyAPI_FUNC(void) _Py_NewReference(PyObject *op); +PyAPI_FUNC(void) _Py_NewReferenceNoTotal(PyObject *op); +PyAPI_FUNC(void) _Py_ResurrectReference(PyObject *op); +PyAPI_FUNC(void) _Py_ForgetReference(PyObject *op); + +#ifdef Py_REF_DEBUG +/* These are useful as debugging aids when chasing down refleaks. */ +PyAPI_FUNC(Py_ssize_t) _Py_GetGlobalRefTotal(void); +# define _Py_GetRefTotal() _Py_GetGlobalRefTotal() +PyAPI_FUNC(Py_ssize_t) _Py_GetLegacyRefTotal(void); +PyAPI_FUNC(Py_ssize_t) _PyInterpreterState_GetRefTotal(PyInterpreterState *); +#endif + + +/********************* String Literals ****************************************/ +/* This structure helps managing static strings. The basic usage goes like this: + Instead of doing + + r = PyObject_CallMethod(o, "foo", "args", ...); + + do + + _Py_IDENTIFIER(foo); + ... + r = _PyObject_CallMethodId(o, &PyId_foo, "args", ...); + + PyId_foo is a static variable, either on block level or file level. On first + usage, the string "foo" is interned, and the structures are linked. On interpreter + shutdown, all strings are released. + + Alternatively, _Py_static_string allows choosing the variable name. + _PyUnicode_FromId returns a borrowed reference to the interned string. + _PyObject_{Get,Set,Has}AttrId are __getattr__ versions using _Py_Identifier*. +*/ +typedef struct _Py_Identifier { + const char* string; + // Index in PyInterpreterState.unicode.ids.array. It is process-wide + // unique and must be initialized to -1. + Py_ssize_t index; + // Hidden PyMutex struct for non free-threaded build. + struct { + uint8_t v; + } mutex; +} _Py_Identifier; + +#ifndef Py_BUILD_CORE +// For now we are keeping _Py_IDENTIFIER for continued use +// in non-builtin extensions (and naughty PyPI modules). + +#define _Py_static_string_init(value) { .string = (value), .index = -1 } +#define _Py_static_string(varname, value) static _Py_Identifier varname = _Py_static_string_init(value) +#define _Py_IDENTIFIER(varname) _Py_static_string(PyId_##varname, #varname) + +#endif /* !Py_BUILD_CORE */ + + +typedef struct { + /* Number implementations must check *both* + arguments for proper type and implement the necessary conversions + in the slot functions themselves. */ + + binaryfunc nb_add; + binaryfunc nb_subtract; + binaryfunc nb_multiply; + binaryfunc nb_remainder; + binaryfunc nb_divmod; + ternaryfunc nb_power; + unaryfunc nb_negative; + unaryfunc nb_positive; + unaryfunc nb_absolute; + inquiry nb_bool; + unaryfunc nb_invert; + binaryfunc nb_lshift; + binaryfunc nb_rshift; + binaryfunc nb_and; + binaryfunc nb_xor; + binaryfunc nb_or; + unaryfunc nb_int; + void *nb_reserved; /* the slot formerly known as nb_long */ + unaryfunc nb_float; + + binaryfunc nb_inplace_add; + binaryfunc nb_inplace_subtract; + binaryfunc nb_inplace_multiply; + binaryfunc nb_inplace_remainder; + ternaryfunc nb_inplace_power; + binaryfunc nb_inplace_lshift; + binaryfunc nb_inplace_rshift; + binaryfunc nb_inplace_and; + binaryfunc nb_inplace_xor; + binaryfunc nb_inplace_or; + + binaryfunc nb_floor_divide; + binaryfunc nb_true_divide; + binaryfunc nb_inplace_floor_divide; + binaryfunc nb_inplace_true_divide; + + unaryfunc nb_index; + + binaryfunc nb_matrix_multiply; + binaryfunc nb_inplace_matrix_multiply; +} PyNumberMethods; + +typedef struct { + lenfunc sq_length; + binaryfunc sq_concat; + ssizeargfunc sq_repeat; + ssizeargfunc sq_item; + void *was_sq_slice; + ssizeobjargproc sq_ass_item; + void *was_sq_ass_slice; + objobjproc sq_contains; + + binaryfunc sq_inplace_concat; + ssizeargfunc sq_inplace_repeat; +} PySequenceMethods; + +typedef struct { + lenfunc mp_length; + binaryfunc mp_subscript; + objobjargproc mp_ass_subscript; +} PyMappingMethods; + +typedef PySendResult (*sendfunc)(PyObject *iter, PyObject *value, PyObject **result); + +typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + sendfunc am_send; +} PyAsyncMethods; + +typedef struct { + getbufferproc bf_getbuffer; + releasebufferproc bf_releasebuffer; +} PyBufferProcs; + +/* Allow printfunc in the tp_vectorcall_offset slot for + * backwards-compatibility */ +typedef Py_ssize_t printfunc; + +// If this structure is modified, Doc/includes/typestruct.h should be updated +// as well. +struct _typeobject { + PyObject_VAR_HEAD + const char *tp_name; /* For printing, in format "." */ + Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */ + + /* Methods to implement standard operations */ + + destructor tp_dealloc; + Py_ssize_t tp_vectorcall_offset; + getattrfunc tp_getattr; + setattrfunc tp_setattr; + PyAsyncMethods *tp_as_async; /* formerly known as tp_compare (Python 2) + or tp_reserved (Python 3) */ + reprfunc tp_repr; + + /* Method suites for standard classes */ + + PyNumberMethods *tp_as_number; + PySequenceMethods *tp_as_sequence; + PyMappingMethods *tp_as_mapping; + + /* More standard operations (here for binary compatibility) */ + + hashfunc tp_hash; + ternaryfunc tp_call; + reprfunc tp_str; + getattrofunc tp_getattro; + setattrofunc tp_setattro; + + /* Functions to access object as input/output buffer */ + PyBufferProcs *tp_as_buffer; + + /* Flags to define presence of optional/expanded features */ + unsigned long tp_flags; + + const char *tp_doc; /* Documentation string */ + + /* Assigned meaning in release 2.0 */ + /* call function for all accessible objects */ + traverseproc tp_traverse; + + /* delete references to contained objects */ + inquiry tp_clear; + + /* Assigned meaning in release 2.1 */ + /* rich comparisons */ + richcmpfunc tp_richcompare; + + /* weak reference enabler */ + Py_ssize_t tp_weaklistoffset; + + /* Iterators */ + getiterfunc tp_iter; + iternextfunc tp_iternext; + + /* Attribute descriptor and subclassing stuff */ + PyMethodDef *tp_methods; + PyMemberDef *tp_members; + PyGetSetDef *tp_getset; + // Strong reference on a heap type, borrowed reference on a static type + PyTypeObject *tp_base; + PyObject *tp_dict; + descrgetfunc tp_descr_get; + descrsetfunc tp_descr_set; + Py_ssize_t tp_dictoffset; + initproc tp_init; + allocfunc tp_alloc; + newfunc tp_new; + freefunc tp_free; /* Low-level free-memory routine */ + inquiry tp_is_gc; /* For PyObject_IS_GC */ + PyObject *tp_bases; + PyObject *tp_mro; /* method resolution order */ + PyObject *tp_cache; /* no longer used */ + void *tp_subclasses; /* for static builtin types this is an index */ + PyObject *tp_weaklist; /* not used for static builtin types */ + destructor tp_del; + + /* Type attribute cache version tag. Added in version 2.6. + * If zero, the cache is invalid and must be initialized. + */ + unsigned int tp_version_tag; + + destructor tp_finalize; + vectorcallfunc tp_vectorcall; + + /* bitset of which type-watchers care about this type */ + unsigned char tp_watched; + + /* Number of tp_version_tag values used. + * Set to _Py_ATTR_CACHE_UNUSED if the attribute cache is + * disabled for this type (e.g. due to custom MRO entries). + * Otherwise, limited to MAX_VERSIONS_PER_CLASS (defined elsewhere). + */ + uint16_t tp_versions_used; +}; + +#define _Py_ATTR_CACHE_UNUSED (30000) // (see tp_versions_used) + +/* This struct is used by the specializer + * It should be treated as an opaque blob + * by code other than the specializer and interpreter. */ +struct _specialization_cache { + // In order to avoid bloating the bytecode with lots of inline caches, the + // members of this structure have a somewhat unique contract. They are set + // by the specialization machinery, and are invalidated by PyType_Modified. + // The rules for using them are as follows: + // - If getitem is non-NULL, then it is the same Python function that + // PyType_Lookup(cls, "__getitem__") would return. + // - If getitem is NULL, then getitem_version is meaningless. + // - If getitem->func_version == getitem_version, then getitem can be called + // with two positional arguments and no keyword arguments, and has neither + // *args nor **kwargs (as required by BINARY_OP_SUBSCR_GETITEM): + PyObject *getitem; + uint32_t getitem_version; + PyObject *init; +}; + +/* The *real* layout of a type object when allocated on the heap */ +typedef struct _heaptypeobject { + /* Note: there's a dependency on the order of these members + in slotptr() in typeobject.c . */ + PyTypeObject ht_type; + PyAsyncMethods as_async; + PyNumberMethods as_number; + PyMappingMethods as_mapping; + PySequenceMethods as_sequence; /* as_sequence comes after as_mapping, + so that the mapping wins when both + the mapping and the sequence define + a given operator (e.g. __getitem__). + see add_operators() in typeobject.c . */ + PyBufferProcs as_buffer; + PyObject *ht_name, *ht_slots, *ht_qualname; + struct _dictkeysobject *ht_cached_keys; + PyObject *ht_module; + char *_ht_tpname; // Storage for "tp_name"; see PyType_FromModuleAndSpec + void *ht_token; // Storage for the "Py_tp_token" slot + struct _specialization_cache _spec_cache; // For use by the specializer. +#ifdef Py_GIL_DISABLED + Py_ssize_t unique_id; // ID used for per-thread refcounting +#endif + /* here are optional user slots, followed by the members. */ +} PyHeapTypeObject; + +PyAPI_FUNC(const char *) _PyType_Name(PyTypeObject *); +PyAPI_FUNC(PyObject *) _PyType_Lookup(PyTypeObject *, PyObject *); +PyAPI_FUNC(PyObject *) _PyType_LookupRef(PyTypeObject *, PyObject *); +PyAPI_FUNC(PyObject *) PyType_GetDict(PyTypeObject *); + +PyAPI_FUNC(int) PyObject_Print(PyObject *, FILE *, int); +PyAPI_FUNC(void) _Py_BreakPoint(void); +PyAPI_FUNC(void) _PyObject_Dump(PyObject *); + +PyAPI_FUNC(PyObject*) _PyObject_GetAttrId(PyObject *, _Py_Identifier *); + +PyAPI_FUNC(PyObject **) _PyObject_GetDictPtr(PyObject *); +PyAPI_FUNC(void) PyObject_CallFinalizer(PyObject *); +PyAPI_FUNC(int) PyObject_CallFinalizerFromDealloc(PyObject *); + +PyAPI_FUNC(void) PyUnstable_Object_ClearWeakRefsNoCallbacks(PyObject *); + +/* Same as PyObject_Generic{Get,Set}Attr, but passing the attributes + dict as the last parameter. */ +PyAPI_FUNC(PyObject *) +_PyObject_GenericGetAttrWithDict(PyObject *, PyObject *, PyObject *, int); +PyAPI_FUNC(int) +_PyObject_GenericSetAttrWithDict(PyObject *, PyObject *, + PyObject *, PyObject *); + +PyAPI_FUNC(PyObject *) _PyObject_FunctionStr(PyObject *); + +/* Safely decref `dst` and set `dst` to `src`. + * + * As in case of Py_CLEAR "the obvious" code can be deadly: + * + * Py_DECREF(dst); + * dst = src; + * + * The safe way is: + * + * Py_SETREF(dst, src); + * + * That arranges to set `dst` to `src` _before_ decref'ing, so that any code + * triggered as a side-effect of `dst` getting torn down no longer believes + * `dst` points to a valid object. + * + * Temporary variables are used to only evaluate macro arguments once and so + * avoid the duplication of side effects. _Py_TYPEOF() or memcpy() is used to + * avoid a miscompilation caused by type punning. See Py_CLEAR() comment for + * implementation details about type punning. + * + * The memcpy() implementation does not emit a compiler warning if 'src' has + * not the same type than 'src': any pointer type is accepted for 'src'. + */ +#ifdef _Py_TYPEOF +#define Py_SETREF(dst, src) \ + do { \ + _Py_TYPEOF(dst)* _tmp_dst_ptr = &(dst); \ + _Py_TYPEOF(dst) _tmp_old_dst = (*_tmp_dst_ptr); \ + *_tmp_dst_ptr = (src); \ + Py_DECREF(_tmp_old_dst); \ + } while (0) +#else +#define Py_SETREF(dst, src) \ + do { \ + PyObject **_tmp_dst_ptr = _Py_CAST(PyObject**, &(dst)); \ + PyObject *_tmp_old_dst = (*_tmp_dst_ptr); \ + PyObject *_tmp_src = _PyObject_CAST(src); \ + memcpy(_tmp_dst_ptr, &_tmp_src, sizeof(PyObject*)); \ + Py_DECREF(_tmp_old_dst); \ + } while (0) +#endif + +/* Py_XSETREF() is a variant of Py_SETREF() that uses Py_XDECREF() instead of + * Py_DECREF(). + */ +#ifdef _Py_TYPEOF +#define Py_XSETREF(dst, src) \ + do { \ + _Py_TYPEOF(dst)* _tmp_dst_ptr = &(dst); \ + _Py_TYPEOF(dst) _tmp_old_dst = (*_tmp_dst_ptr); \ + *_tmp_dst_ptr = (src); \ + Py_XDECREF(_tmp_old_dst); \ + } while (0) +#else +#define Py_XSETREF(dst, src) \ + do { \ + PyObject **_tmp_dst_ptr = _Py_CAST(PyObject**, &(dst)); \ + PyObject *_tmp_old_dst = (*_tmp_dst_ptr); \ + PyObject *_tmp_src = _PyObject_CAST(src); \ + memcpy(_tmp_dst_ptr, &_tmp_src, sizeof(PyObject*)); \ + Py_XDECREF(_tmp_old_dst); \ + } while (0) +#endif + + +/* Define a pair of assertion macros: + _PyObject_ASSERT_FROM(), _PyObject_ASSERT_WITH_MSG() and _PyObject_ASSERT(). + + These work like the regular C assert(), in that they will abort the + process with a message on stderr if the given condition fails to hold, + but compile away to nothing if NDEBUG is defined. + + However, before aborting, Python will also try to call _PyObject_Dump() on + the given object. This may be of use when investigating bugs in which a + particular object is corrupt (e.g. buggy a tp_visit method in an extension + module breaking the garbage collector), to help locate the broken objects. + + The WITH_MSG variant allows you to supply an additional message that Python + will attempt to print to stderr, after the object dump. */ +#ifdef NDEBUG + /* No debugging: compile away the assertions: */ +# define _PyObject_ASSERT_FROM(obj, expr, msg, filename, lineno, func) \ + ((void)0) +#else + /* With debugging: generate checks: */ +# define _PyObject_ASSERT_FROM(obj, expr, msg, filename, lineno, func) \ + ((expr) \ + ? (void)(0) \ + : _PyObject_AssertFailed((obj), Py_STRINGIFY(expr), \ + (msg), (filename), (lineno), (func))) +#endif + +#define _PyObject_ASSERT_WITH_MSG(obj, expr, msg) \ + _PyObject_ASSERT_FROM((obj), expr, (msg), __FILE__, __LINE__, __func__) +#define _PyObject_ASSERT(obj, expr) \ + _PyObject_ASSERT_WITH_MSG((obj), expr, NULL) + +#define _PyObject_ASSERT_FAILED_MSG(obj, msg) \ + _PyObject_AssertFailed((obj), NULL, (msg), __FILE__, __LINE__, __func__) + +/* Declare and define _PyObject_AssertFailed() even when NDEBUG is defined, + to avoid causing compiler/linker errors when building extensions without + NDEBUG against a Python built with NDEBUG defined. + + msg, expr and function can be NULL. */ +PyAPI_FUNC(void) _Py_NO_RETURN _PyObject_AssertFailed( + PyObject *obj, + const char *expr, + const char *msg, + const char *file, + int line, + const char *function); + + +PyAPI_FUNC(void) _PyTrash_thread_deposit_object(PyThreadState *tstate, PyObject *op); +PyAPI_FUNC(void) _PyTrash_thread_destroy_chain(PyThreadState *tstate); + +PyAPI_FUNC(int) _Py_ReachedRecursionLimitWithMargin(PyThreadState *tstate, int margin_count); + +/* For backwards compatibility with the old trashcan mechanism */ +#define Py_TRASHCAN_BEGIN(op, dealloc) +#define Py_TRASHCAN_END + + +PyAPI_FUNC(void *) PyObject_GetItemData(PyObject *obj); + +PyAPI_FUNC(int) PyObject_VisitManagedDict(PyObject *obj, visitproc visit, void *arg); +PyAPI_FUNC(int) _PyObject_SetManagedDict(PyObject *obj, PyObject *new_dict); +PyAPI_FUNC(void) PyObject_ClearManagedDict(PyObject *obj); + + +typedef int(*PyType_WatchCallback)(PyTypeObject *); +PyAPI_FUNC(int) PyType_AddWatcher(PyType_WatchCallback callback); +PyAPI_FUNC(int) PyType_ClearWatcher(int watcher_id); +PyAPI_FUNC(int) PyType_Watch(int watcher_id, PyObject *type); +PyAPI_FUNC(int) PyType_Unwatch(int watcher_id, PyObject *type); + +/* Attempt to assign a version tag to the given type. + * + * Returns 1 if the type already had a valid version tag or a new one was + * assigned, or 0 if a new tag could not be assigned. + */ +PyAPI_FUNC(int) PyUnstable_Type_AssignVersionTag(PyTypeObject *type); + + +typedef enum { + PyRefTracer_CREATE = 0, + PyRefTracer_DESTROY = 1, +} PyRefTracerEvent; + +typedef int (*PyRefTracer)(PyObject *, PyRefTracerEvent event, void *); +PyAPI_FUNC(int) PyRefTracer_SetTracer(PyRefTracer tracer, void *data); +PyAPI_FUNC(PyRefTracer) PyRefTracer_GetTracer(void**); + +/* Enable PEP-703 deferred reference counting on the object. + * + * Returns 1 if deferred reference counting was successfully enabled, and + * 0 if the runtime ignored it. This function cannot fail. + */ +PyAPI_FUNC(int) PyUnstable_Object_EnableDeferredRefcount(PyObject *); + +/* Determine if the object exists as a unique temporary variable on the + * topmost frame of the interpreter. + */ +PyAPI_FUNC(int) PyUnstable_Object_IsUniqueReferencedTemporary(PyObject *); + +/* Check whether the object is immortal. This cannot fail. */ +PyAPI_FUNC(int) PyUnstable_IsImmortal(PyObject *); + +// Increments the reference count of the object, if it's not zero. +// PyUnstable_EnableTryIncRef() should be called on the object +// before calling this function in order to avoid spurious failures. +PyAPI_FUNC(int) PyUnstable_TryIncRef(PyObject *); +PyAPI_FUNC(void) PyUnstable_EnableTryIncRef(PyObject *); + +PyAPI_FUNC(int) PyUnstable_Object_IsUniquelyReferenced(PyObject *); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/objimpl.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/objimpl.h new file mode 100644 index 0000000000000000000000000000000000000000..e0c2ce286f13ce38c3308c17e1cdc2308bf76edf --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/objimpl.h @@ -0,0 +1,104 @@ +#ifndef Py_CPYTHON_OBJIMPL_H +# error "this header file must not be included directly" +#endif + +static inline size_t _PyObject_SIZE(PyTypeObject *type) { + return _Py_STATIC_CAST(size_t, type->tp_basicsize); +} + +/* _PyObject_VAR_SIZE returns the number of bytes (as size_t) allocated for a + vrbl-size object with nitems items, exclusive of gc overhead (if any). The + value is rounded up to the closest multiple of sizeof(void *), in order to + ensure that pointer fields at the end of the object are correctly aligned + for the platform (this is of special importance for subclasses of, e.g., + str or int, so that pointers can be stored after the embedded data). + + Note that there's no memory wastage in doing this, as malloc has to + return (at worst) pointer-aligned memory anyway. +*/ +#if ((SIZEOF_VOID_P - 1) & SIZEOF_VOID_P) != 0 +# error "_PyObject_VAR_SIZE requires SIZEOF_VOID_P be a power of 2" +#endif + +static inline size_t _PyObject_VAR_SIZE(PyTypeObject *type, Py_ssize_t nitems) { + size_t size = _Py_STATIC_CAST(size_t, type->tp_basicsize); + size += _Py_STATIC_CAST(size_t, nitems) * _Py_STATIC_CAST(size_t, type->tp_itemsize); + return _Py_SIZE_ROUND_UP(size, SIZEOF_VOID_P); +} + + +/* This example code implements an object constructor with a custom + allocator, where PyObject_New is inlined, and shows the important + distinction between two steps (at least): + 1) the actual allocation of the object storage; + 2) the initialization of the Python specific fields + in this storage with PyObject_{Init, InitVar}. + + PyObject * + YourObject_New(...) + { + PyObject *op; + + op = (PyObject *) Your_Allocator(_PyObject_SIZE(YourTypeStruct)); + if (op == NULL) { + return PyErr_NoMemory(); + } + + PyObject_Init(op, &YourTypeStruct); + + op->ob_field = value; + ... + return op; + } + + Note that in C++, the use of the new operator usually implies that + the 1st step is performed automatically for you, so in a C++ class + constructor you would start directly with PyObject_Init/InitVar. */ + + +typedef struct { + /* user context passed as the first argument to the 2 functions */ + void *ctx; + + /* allocate an arena of size bytes */ + void* (*alloc) (void *ctx, size_t size); + + /* free an arena */ + void (*free) (void *ctx, void *ptr, size_t size); +} PyObjectArenaAllocator; + +/* Get the arena allocator. */ +PyAPI_FUNC(void) PyObject_GetArenaAllocator(PyObjectArenaAllocator *allocator); + +/* Set the arena allocator. */ +PyAPI_FUNC(void) PyObject_SetArenaAllocator(PyObjectArenaAllocator *allocator); + + +/* Test if an object implements the garbage collector protocol */ +PyAPI_FUNC(int) PyObject_IS_GC(PyObject *obj); + + +// Test if a type supports weak references +PyAPI_FUNC(int) PyType_SUPPORTS_WEAKREFS(PyTypeObject *type); + +PyAPI_FUNC(PyObject **) PyObject_GET_WEAKREFS_LISTPTR(PyObject *op); + +PyAPI_FUNC(PyObject *) PyUnstable_Object_GC_NewWithExtraData(PyTypeObject *, + size_t); + + +/* Visit all live GC-capable objects, similar to gc.get_objects(None). The + * supplied callback is called on every such object with the void* arg set + * to the supplied arg. Returning 0 from the callback ends iteration, returning + * 1 allows iteration to continue. Returning any other value may result in + * undefined behaviour. + * + * If new objects are (de)allocated by the callback it is undefined if they + * will be visited. + + * Garbage collection is disabled during operation. Explicitly running a + * collection in the callback may lead to undefined behaviour e.g. visiting the + * same objects multiple times or not at all. + */ +typedef int (*gcvisitobjects_t)(PyObject*, void*); +PyAPI_FUNC(void) PyUnstable_GC_VisitObjects(gcvisitobjects_t callback, void* arg); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/odictobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/odictobject.h new file mode 100644 index 0000000000000000000000000000000000000000..3822d554868c10e3910f13aad4272f2973726eed --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/odictobject.h @@ -0,0 +1,43 @@ +#ifndef Py_ODICTOBJECT_H +#define Py_ODICTOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + + +/* OrderedDict */ +/* This API is optional and mostly redundant. */ + +#ifndef Py_LIMITED_API + +typedef struct _odictobject PyODictObject; + +PyAPI_DATA(PyTypeObject) PyODict_Type; +PyAPI_DATA(PyTypeObject) PyODictIter_Type; +PyAPI_DATA(PyTypeObject) PyODictKeys_Type; +PyAPI_DATA(PyTypeObject) PyODictItems_Type; +PyAPI_DATA(PyTypeObject) PyODictValues_Type; + +#define PyODict_Check(op) PyObject_TypeCheck((op), &PyODict_Type) +#define PyODict_CheckExact(op) Py_IS_TYPE((op), &PyODict_Type) +#define PyODict_SIZE(op) PyDict_GET_SIZE((op)) + +PyAPI_FUNC(PyObject *) PyODict_New(void); +PyAPI_FUNC(int) PyODict_SetItem(PyObject *od, PyObject *key, PyObject *item); +PyAPI_FUNC(int) PyODict_DelItem(PyObject *od, PyObject *key); + +/* wrappers around PyDict* functions */ +#define PyODict_GetItem(od, key) PyDict_GetItem(_PyObject_CAST(od), (key)) +#define PyODict_GetItemWithError(od, key) \ + PyDict_GetItemWithError(_PyObject_CAST(od), (key)) +#define PyODict_Contains(od, key) PyDict_Contains(_PyObject_CAST(od), (key)) +#define PyODict_Size(od) PyDict_Size(_PyObject_CAST(od)) +#define PyODict_GetItemString(od, key) \ + PyDict_GetItemString(_PyObject_CAST(od), (key)) + +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_ODICTOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/picklebufobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/picklebufobject.h new file mode 100644 index 0000000000000000000000000000000000000000..f3cbaeef919518cd3154ce6cd4634210aebf42de --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/picklebufobject.h @@ -0,0 +1,31 @@ +/* PickleBuffer object. This is built-in for ease of use from third-party + * C extensions. + */ + +#ifndef Py_PICKLEBUFOBJECT_H +#define Py_PICKLEBUFOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_LIMITED_API + +PyAPI_DATA(PyTypeObject) PyPickleBuffer_Type; + +#define PyPickleBuffer_Check(op) Py_IS_TYPE((op), &PyPickleBuffer_Type) + +/* Create a PickleBuffer redirecting to the given buffer-enabled object */ +PyAPI_FUNC(PyObject *) PyPickleBuffer_FromObject(PyObject *); +/* Get the PickleBuffer's underlying view to the original object + * (NULL if released) + */ +PyAPI_FUNC(const Py_buffer *) PyPickleBuffer_GetBuffer(PyObject *); +/* Release the PickleBuffer. Returns 0 on success, -1 on error. */ +PyAPI_FUNC(int) PyPickleBuffer_Release(PyObject *); + +#endif /* !Py_LIMITED_API */ + +#ifdef __cplusplus +} +#endif +#endif /* !Py_PICKLEBUFOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pthread_stubs.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pthread_stubs.h new file mode 100644 index 0000000000000000000000000000000000000000..e542eaa5bff0cf0322441f18e05da6dba35ab417 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pthread_stubs.h @@ -0,0 +1,105 @@ +#ifndef Py_CPYTHON_PTRHEAD_STUBS_H +#define Py_CPYTHON_PTRHEAD_STUBS_H + +#if !defined(HAVE_PTHREAD_STUBS) +# error "this header file requires stubbed pthreads." +#endif + +#ifndef _POSIX_THREADS +# define _POSIX_THREADS 1 +#endif + +/* Minimal pthread stubs for CPython. + * + * The stubs implement the minimum pthread API for CPython. + * - pthread_create() fails. + * - pthread_exit() calls exit(0). + * - pthread_key_*() functions implement minimal TSS without destructor. + * - all other functions do nothing and return 0. + */ + +#ifdef __wasi__ +// WASI's bits/alltypes.h provides type definitions when __NEED_ is set. +// The header file can be included multiple times. +// +// may also define these macros. +# ifndef __NEED_pthread_cond_t +# define __NEED_pthread_cond_t 1 +# endif +# ifndef __NEED_pthread_condattr_t +# define __NEED_pthread_condattr_t 1 +# endif +# ifndef __NEED_pthread_mutex_t +# define __NEED_pthread_mutex_t 1 +# endif +# ifndef __NEED_pthread_mutexattr_t +# define __NEED_pthread_mutexattr_t 1 +# endif +# ifndef __NEED_pthread_key_t +# define __NEED_pthread_key_t 1 +# endif +# ifndef __NEED_pthread_t +# define __NEED_pthread_t 1 +# endif +# ifndef __NEED_pthread_attr_t +# define __NEED_pthread_attr_t 1 +# endif +# include +#else +typedef struct { void *__x; } pthread_cond_t; +typedef struct { unsigned __attr; } pthread_condattr_t; +typedef struct { void *__x; } pthread_mutex_t; +typedef struct { unsigned __attr; } pthread_mutexattr_t; +typedef unsigned pthread_key_t; +typedef unsigned pthread_t; +typedef struct { unsigned __attr; } pthread_attr_t; +#endif + +// mutex +PyAPI_FUNC(int) pthread_mutex_init(pthread_mutex_t *restrict mutex, + const pthread_mutexattr_t *restrict attr); +PyAPI_FUNC(int) pthread_mutex_destroy(pthread_mutex_t *mutex); +PyAPI_FUNC(int) pthread_mutex_trylock(pthread_mutex_t *mutex); +PyAPI_FUNC(int) pthread_mutex_lock(pthread_mutex_t *mutex); +PyAPI_FUNC(int) pthread_mutex_unlock(pthread_mutex_t *mutex); + +// condition +PyAPI_FUNC(int) pthread_cond_init(pthread_cond_t *restrict cond, + const pthread_condattr_t *restrict attr); +PyAPI_FUNC(int) pthread_cond_destroy(pthread_cond_t *cond); +PyAPI_FUNC(int) pthread_cond_wait(pthread_cond_t *restrict cond, + pthread_mutex_t *restrict mutex); +PyAPI_FUNC(int) pthread_cond_timedwait(pthread_cond_t *restrict cond, + pthread_mutex_t *restrict mutex, + const struct timespec *restrict abstime); +PyAPI_FUNC(int) pthread_cond_signal(pthread_cond_t *cond); +PyAPI_FUNC(int) pthread_condattr_init(pthread_condattr_t *attr); +PyAPI_FUNC(int) pthread_condattr_setclock( + pthread_condattr_t *attr, clockid_t clock_id); + +// pthread +PyAPI_FUNC(int) pthread_create(pthread_t *restrict thread, + const pthread_attr_t *restrict attr, + void *(*start_routine)(void *), + void *restrict arg); +PyAPI_FUNC(int) pthread_detach(pthread_t thread); +PyAPI_FUNC(int) pthread_join(pthread_t thread, void** value_ptr); +PyAPI_FUNC(pthread_t) pthread_self(void); +PyAPI_FUNC(int) pthread_exit(void *retval) __attribute__ ((__noreturn__)); +PyAPI_FUNC(int) pthread_attr_init(pthread_attr_t *attr); +PyAPI_FUNC(int) pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize); +PyAPI_FUNC(int) pthread_attr_destroy(pthread_attr_t *attr); + + +// pthread_key +#ifndef PTHREAD_KEYS_MAX +# define PTHREAD_KEYS_MAX 128 +#endif + +PyAPI_FUNC(int) pthread_key_create(pthread_key_t *key, + void (*destr_function)(void *)); +PyAPI_FUNC(int) pthread_key_delete(pthread_key_t key); +PyAPI_FUNC(void *) pthread_getspecific(pthread_key_t key); +PyAPI_FUNC(int) pthread_setspecific(pthread_key_t key, const void *value); + +#endif // Py_CPYTHON_PTRHEAD_STUBS_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyatomic.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyatomic.h new file mode 100644 index 0000000000000000000000000000000000000000..3a71ed689d88d8fbf8e907a41161596c27a458c6 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyatomic.h @@ -0,0 +1,628 @@ +// This header provides cross-platform low-level atomic operations +// similar to C11 atomics. +// +// Operations are sequentially consistent unless they have a suffix indicating +// otherwise. If in doubt, prefer the sequentially consistent operations. +// +// The "_relaxed" suffix for load and store operations indicates the "relaxed" +// memory order. They don't provide synchronization, but (roughly speaking) +// guarantee somewhat sane behavior for races instead of undefined behavior. +// In practice, they correspond to "normal" hardware load and store +// instructions, so they are almost as inexpensive as plain loads and stores +// in C. +// +// Note that atomic read-modify-write operations like _Py_atomic_add_* return +// the previous value of the atomic variable, not the new value. +// +// See https://en.cppreference.com/w/c/atomic for more information on C11 +// atomics. +// See https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2055r0.pdf +// "A Relaxed Guide to memory_order_relaxed" for discussion of and common usage +// or relaxed atomics. +// +// Functions with pseudo Python code: +// +// def _Py_atomic_load(obj): +// return obj # sequential consistency +// +// def _Py_atomic_load_relaxed(obj): +// return obj # relaxed consistency +// +// def _Py_atomic_store(obj, value): +// obj = value # sequential consistency +// +// def _Py_atomic_store_relaxed(obj, value): +// obj = value # relaxed consistency +// +// def _Py_atomic_exchange(obj, value): +// # sequential consistency +// old_obj = obj +// obj = value +// return old_obj +// +// def _Py_atomic_compare_exchange(obj, expected, desired): +// # sequential consistency +// if obj == expected: +// obj = desired +// return True +// else: +// expected = obj +// return False +// +// def _Py_atomic_add(obj, value): +// # sequential consistency +// old_obj = obj +// obj += value +// return old_obj +// +// def _Py_atomic_and(obj, value): +// # sequential consistency +// old_obj = obj +// obj &= value +// return old_obj +// +// def _Py_atomic_or(obj, value): +// # sequential consistency +// old_obj = obj +// obj |= value +// return old_obj +// +// Other functions: +// +// def _Py_atomic_load_ptr_acquire(obj): +// return obj # acquire +// +// def _Py_atomic_store_ptr_release(obj, value): +// obj = value # release +// +// def _Py_atomic_fence_seq_cst(): +// # sequential consistency +// ... +// +// def _Py_atomic_fence_release(): +// # release +// ... + +#ifndef Py_CPYTHON_ATOMIC_H +# error "this header file must not be included directly" +#endif + +// --- _Py_atomic_add -------------------------------------------------------- +// Atomically adds `value` to `obj` and returns the previous value + +static inline int +_Py_atomic_add_int(int *obj, int value); + +static inline int8_t +_Py_atomic_add_int8(int8_t *obj, int8_t value); + +static inline int16_t +_Py_atomic_add_int16(int16_t *obj, int16_t value); + +static inline int32_t +_Py_atomic_add_int32(int32_t *obj, int32_t value); + +static inline int64_t +_Py_atomic_add_int64(int64_t *obj, int64_t value); + +static inline intptr_t +_Py_atomic_add_intptr(intptr_t *obj, intptr_t value); + +static inline unsigned int +_Py_atomic_add_uint(unsigned int *obj, unsigned int value); + +static inline uint8_t +_Py_atomic_add_uint8(uint8_t *obj, uint8_t value); + +static inline uint16_t +_Py_atomic_add_uint16(uint16_t *obj, uint16_t value); + +static inline uint32_t +_Py_atomic_add_uint32(uint32_t *obj, uint32_t value); + +static inline uint64_t +_Py_atomic_add_uint64(uint64_t *obj, uint64_t value); + +static inline uintptr_t +_Py_atomic_add_uintptr(uintptr_t *obj, uintptr_t value); + +static inline Py_ssize_t +_Py_atomic_add_ssize(Py_ssize_t *obj, Py_ssize_t value); + + +// --- _Py_atomic_compare_exchange ------------------------------------------- +// Performs an atomic compare-and-exchange. +// +// - If `*obj` and `*expected` are equal, store `desired` into `*obj` +// and return 1 (success). +// - Otherwise, store the `*obj` current value into `*expected` +// and return 0 (failure). +// +// These correspond to the C11 atomic_compare_exchange_strong() function. + +static inline int +_Py_atomic_compare_exchange_int(int *obj, int *expected, int desired); + +static inline int +_Py_atomic_compare_exchange_int8(int8_t *obj, int8_t *expected, int8_t desired); + +static inline int +_Py_atomic_compare_exchange_int16(int16_t *obj, int16_t *expected, int16_t desired); + +static inline int +_Py_atomic_compare_exchange_int32(int32_t *obj, int32_t *expected, int32_t desired); + +static inline int +_Py_atomic_compare_exchange_int64(int64_t *obj, int64_t *expected, int64_t desired); + +static inline int +_Py_atomic_compare_exchange_intptr(intptr_t *obj, intptr_t *expected, intptr_t desired); + +static inline int +_Py_atomic_compare_exchange_uint(unsigned int *obj, unsigned int *expected, unsigned int desired); + +static inline int +_Py_atomic_compare_exchange_uint8(uint8_t *obj, uint8_t *expected, uint8_t desired); + +static inline int +_Py_atomic_compare_exchange_uint16(uint16_t *obj, uint16_t *expected, uint16_t desired); + +static inline int +_Py_atomic_compare_exchange_uint32(uint32_t *obj, uint32_t *expected, uint32_t desired); + +static inline int +_Py_atomic_compare_exchange_uint64(uint64_t *obj, uint64_t *expected, uint64_t desired); + +static inline int +_Py_atomic_compare_exchange_uintptr(uintptr_t *obj, uintptr_t *expected, uintptr_t desired); + +static inline int +_Py_atomic_compare_exchange_ssize(Py_ssize_t *obj, Py_ssize_t *expected, Py_ssize_t desired); + +// NOTE: `obj` and `expected` are logically `void**` types, but we use `void*` +// so that we can pass types like `PyObject**` without a cast. +static inline int +_Py_atomic_compare_exchange_ptr(void *obj, void *expected, void *value); + + +// --- _Py_atomic_exchange --------------------------------------------------- +// Atomically replaces `*obj` with `value` and returns the previous value of `*obj`. + +static inline int +_Py_atomic_exchange_int(int *obj, int value); + +static inline int8_t +_Py_atomic_exchange_int8(int8_t *obj, int8_t value); + +static inline int16_t +_Py_atomic_exchange_int16(int16_t *obj, int16_t value); + +static inline int32_t +_Py_atomic_exchange_int32(int32_t *obj, int32_t value); + +static inline int64_t +_Py_atomic_exchange_int64(int64_t *obj, int64_t value); + +static inline intptr_t +_Py_atomic_exchange_intptr(intptr_t *obj, intptr_t value); + +static inline unsigned int +_Py_atomic_exchange_uint(unsigned int *obj, unsigned int value); + +static inline uint8_t +_Py_atomic_exchange_uint8(uint8_t *obj, uint8_t value); + +static inline uint16_t +_Py_atomic_exchange_uint16(uint16_t *obj, uint16_t value); + +static inline uint32_t +_Py_atomic_exchange_uint32(uint32_t *obj, uint32_t value); + +static inline uint64_t +_Py_atomic_exchange_uint64(uint64_t *obj, uint64_t value); + +static inline uintptr_t +_Py_atomic_exchange_uintptr(uintptr_t *obj, uintptr_t value); + +static inline Py_ssize_t +_Py_atomic_exchange_ssize(Py_ssize_t *obj, Py_ssize_t value); + +static inline void * +_Py_atomic_exchange_ptr(void *obj, void *value); + + +// --- _Py_atomic_and -------------------------------------------------------- +// Performs `*obj &= value` atomically and returns the previous value of `*obj`. + +static inline uint8_t +_Py_atomic_and_uint8(uint8_t *obj, uint8_t value); + +static inline uint16_t +_Py_atomic_and_uint16(uint16_t *obj, uint16_t value); + +static inline uint32_t +_Py_atomic_and_uint32(uint32_t *obj, uint32_t value); + +static inline uint64_t +_Py_atomic_and_uint64(uint64_t *obj, uint64_t value); + +static inline uintptr_t +_Py_atomic_and_uintptr(uintptr_t *obj, uintptr_t value); + + +// --- _Py_atomic_or --------------------------------------------------------- +// Performs `*obj |= value` atomically and returns the previous value of `*obj`. + +static inline uint8_t +_Py_atomic_or_uint8(uint8_t *obj, uint8_t value); + +static inline uint16_t +_Py_atomic_or_uint16(uint16_t *obj, uint16_t value); + +static inline uint32_t +_Py_atomic_or_uint32(uint32_t *obj, uint32_t value); + +static inline uint64_t +_Py_atomic_or_uint64(uint64_t *obj, uint64_t value); + +static inline uintptr_t +_Py_atomic_or_uintptr(uintptr_t *obj, uintptr_t value); + + +// --- _Py_atomic_load ------------------------------------------------------- +// Atomically loads `*obj` (sequential consistency) + +static inline int +_Py_atomic_load_int(const int *obj); + +static inline int8_t +_Py_atomic_load_int8(const int8_t *obj); + +static inline int16_t +_Py_atomic_load_int16(const int16_t *obj); + +static inline int32_t +_Py_atomic_load_int32(const int32_t *obj); + +static inline int64_t +_Py_atomic_load_int64(const int64_t *obj); + +static inline intptr_t +_Py_atomic_load_intptr(const intptr_t *obj); + +static inline uint8_t +_Py_atomic_load_uint8(const uint8_t *obj); + +static inline uint16_t +_Py_atomic_load_uint16(const uint16_t *obj); + +static inline uint32_t +_Py_atomic_load_uint32(const uint32_t *obj); + +static inline uint64_t +_Py_atomic_load_uint64(const uint64_t *obj); + +static inline uintptr_t +_Py_atomic_load_uintptr(const uintptr_t *obj); + +static inline unsigned int +_Py_atomic_load_uint(const unsigned int *obj); + +static inline Py_ssize_t +_Py_atomic_load_ssize(const Py_ssize_t *obj); + +static inline void * +_Py_atomic_load_ptr(const void *obj); + + +// --- _Py_atomic_load_relaxed ----------------------------------------------- +// Loads `*obj` (relaxed consistency, i.e., no ordering) + +static inline int +_Py_atomic_load_int_relaxed(const int *obj); + +static inline char +_Py_atomic_load_char_relaxed(const char *obj); + +static inline unsigned char +_Py_atomic_load_uchar_relaxed(const unsigned char *obj); + +static inline short +_Py_atomic_load_short_relaxed(const short *obj); + +static inline unsigned short +_Py_atomic_load_ushort_relaxed(const unsigned short *obj); + +static inline long +_Py_atomic_load_long_relaxed(const long *obj); + +static inline double +_Py_atomic_load_double_relaxed(const double *obj); + +static inline long long +_Py_atomic_load_llong_relaxed(const long long *obj); + +static inline int8_t +_Py_atomic_load_int8_relaxed(const int8_t *obj); + +static inline int16_t +_Py_atomic_load_int16_relaxed(const int16_t *obj); + +static inline int32_t +_Py_atomic_load_int32_relaxed(const int32_t *obj); + +static inline int64_t +_Py_atomic_load_int64_relaxed(const int64_t *obj); + +static inline intptr_t +_Py_atomic_load_intptr_relaxed(const intptr_t *obj); + +static inline uint8_t +_Py_atomic_load_uint8_relaxed(const uint8_t *obj); + +static inline uint16_t +_Py_atomic_load_uint16_relaxed(const uint16_t *obj); + +static inline uint32_t +_Py_atomic_load_uint32_relaxed(const uint32_t *obj); + +static inline uint64_t +_Py_atomic_load_uint64_relaxed(const uint64_t *obj); + +static inline uintptr_t +_Py_atomic_load_uintptr_relaxed(const uintptr_t *obj); + +static inline unsigned int +_Py_atomic_load_uint_relaxed(const unsigned int *obj); + +static inline Py_ssize_t +_Py_atomic_load_ssize_relaxed(const Py_ssize_t *obj); + +static inline void * +_Py_atomic_load_ptr_relaxed(const void *obj); + +static inline unsigned long long +_Py_atomic_load_ullong_relaxed(const unsigned long long *obj); + +// --- _Py_atomic_store ------------------------------------------------------ +// Atomically performs `*obj = value` (sequential consistency) + +static inline void +_Py_atomic_store_int(int *obj, int value); + +static inline void +_Py_atomic_store_int8(int8_t *obj, int8_t value); + +static inline void +_Py_atomic_store_int16(int16_t *obj, int16_t value); + +static inline void +_Py_atomic_store_int32(int32_t *obj, int32_t value); + +static inline void +_Py_atomic_store_int64(int64_t *obj, int64_t value); + +static inline void +_Py_atomic_store_intptr(intptr_t *obj, intptr_t value); + +static inline void +_Py_atomic_store_uint8(uint8_t *obj, uint8_t value); + +static inline void +_Py_atomic_store_uint16(uint16_t *obj, uint16_t value); + +static inline void +_Py_atomic_store_uint32(uint32_t *obj, uint32_t value); + +static inline void +_Py_atomic_store_uint64(uint64_t *obj, uint64_t value); + +static inline void +_Py_atomic_store_uintptr(uintptr_t *obj, uintptr_t value); + +static inline void +_Py_atomic_store_uint(unsigned int *obj, unsigned int value); + +static inline void +_Py_atomic_store_ptr(void *obj, void *value); + +static inline void +_Py_atomic_store_ssize(Py_ssize_t* obj, Py_ssize_t value); + + +// --- _Py_atomic_store_relaxed ---------------------------------------------- +// Stores `*obj = value` (relaxed consistency, i.e., no ordering) + +static inline void +_Py_atomic_store_int_relaxed(int *obj, int value); + +static inline void +_Py_atomic_store_int8_relaxed(int8_t *obj, int8_t value); + +static inline void +_Py_atomic_store_int16_relaxed(int16_t *obj, int16_t value); + +static inline void +_Py_atomic_store_int32_relaxed(int32_t *obj, int32_t value); + +static inline void +_Py_atomic_store_int64_relaxed(int64_t *obj, int64_t value); + +static inline void +_Py_atomic_store_intptr_relaxed(intptr_t *obj, intptr_t value); + +static inline void +_Py_atomic_store_uint8_relaxed(uint8_t* obj, uint8_t value); + +static inline void +_Py_atomic_store_uint16_relaxed(uint16_t *obj, uint16_t value); + +static inline void +_Py_atomic_store_uint32_relaxed(uint32_t *obj, uint32_t value); + +static inline void +_Py_atomic_store_uint64_relaxed(uint64_t *obj, uint64_t value); + +static inline void +_Py_atomic_store_uintptr_relaxed(uintptr_t *obj, uintptr_t value); + +static inline void +_Py_atomic_store_uint_relaxed(unsigned int *obj, unsigned int value); + +static inline void +_Py_atomic_store_ptr_relaxed(void *obj, void *value); + +static inline void +_Py_atomic_store_ssize_relaxed(Py_ssize_t *obj, Py_ssize_t value); + +static inline void +_Py_atomic_store_ullong_relaxed(unsigned long long *obj, + unsigned long long value); + +static inline void +_Py_atomic_store_char_relaxed(char *obj, char value); + +static inline void +_Py_atomic_store_uchar_relaxed(unsigned char *obj, unsigned char value); + +static inline void +_Py_atomic_store_short_relaxed(short *obj, short value); + +static inline void +_Py_atomic_store_ushort_relaxed(unsigned short *obj, unsigned short value); + +static inline void +_Py_atomic_store_long_relaxed(long *obj, long value); + +static inline void +_Py_atomic_store_float_relaxed(float *obj, float value); + +static inline void +_Py_atomic_store_double_relaxed(double *obj, double value); + +static inline void +_Py_atomic_store_llong_relaxed(long long *obj, long long value); + + +// --- _Py_atomic_load_ptr_acquire / _Py_atomic_store_ptr_release ------------ + +// Loads `*obj` (acquire operation) +static inline void * +_Py_atomic_load_ptr_acquire(const void *obj); + +static inline uintptr_t +_Py_atomic_load_uintptr_acquire(const uintptr_t *obj); + +// Stores `*obj = value` (release operation) +static inline void +_Py_atomic_store_ptr_release(void *obj, void *value); + +static inline void +_Py_atomic_store_uintptr_release(uintptr_t *obj, uintptr_t value); + +static inline void +_Py_atomic_store_ssize_release(Py_ssize_t *obj, Py_ssize_t value); + +static inline void +_Py_atomic_store_int_release(int *obj, int value); + +static inline int +_Py_atomic_load_int_acquire(const int *obj); + +static inline void +_Py_atomic_store_uint_release(unsigned int *obj, unsigned int value); + +static inline void +_Py_atomic_store_uint32_release(uint32_t *obj, uint32_t value); + +static inline void +_Py_atomic_store_uint64_release(uint64_t *obj, uint64_t value); + +static inline uint64_t +_Py_atomic_load_uint64_acquire(const uint64_t *obj); + +static inline uint32_t +_Py_atomic_load_uint32_acquire(const uint32_t *obj); + +static inline Py_ssize_t +_Py_atomic_load_ssize_acquire(const Py_ssize_t *obj); + + + + +// --- _Py_atomic_fence ------------------------------------------------------ + +// Sequential consistency fence. C11 fences have complex semantics. When +// possible, use the atomic operations on variables defined above, which +// generally do not require explicit use of a fence. +// See https://en.cppreference.com/w/cpp/atomic/atomic_thread_fence +static inline void _Py_atomic_fence_seq_cst(void); + +// Acquire fence +static inline void _Py_atomic_fence_acquire(void); + +// Release fence +static inline void _Py_atomic_fence_release(void); + + +#ifndef _Py_USE_GCC_BUILTIN_ATOMICS +# if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)) +# define _Py_USE_GCC_BUILTIN_ATOMICS 1 +# elif defined(__clang__) +# if __has_builtin(__atomic_load) +# define _Py_USE_GCC_BUILTIN_ATOMICS 1 +# endif +# endif +#endif + +#if _Py_USE_GCC_BUILTIN_ATOMICS +# define Py_ATOMIC_GCC_H +# include "pyatomic_gcc.h" +# undef Py_ATOMIC_GCC_H +#elif __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_ATOMICS__) +# define Py_ATOMIC_STD_H +# include "pyatomic_std.h" +# undef Py_ATOMIC_STD_H +#elif defined(_MSC_VER) +# define Py_ATOMIC_MSC_H +# include "pyatomic_msc.h" +# undef Py_ATOMIC_MSC_H +#else +# error "no available pyatomic implementation for this platform/compiler" +#endif + + +// --- aliases --------------------------------------------------------------- + +// Compilers don't really support "consume" semantics, so we fake it. Use +// "acquire" with TSan to support false positives. Use "relaxed" otherwise, +// because CPUs on all platforms we support respect address dependencies without +// extra barriers. +// See 2.6.7 in https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2055r0.pdf +#if defined(_Py_THREAD_SANITIZER) +# define _Py_atomic_load_ptr_consume _Py_atomic_load_ptr_acquire +#else +# define _Py_atomic_load_ptr_consume _Py_atomic_load_ptr_relaxed +#endif + +#if SIZEOF_LONG == 8 +# define _Py_atomic_load_ulong(p) \ + _Py_atomic_load_uint64((uint64_t *)p) +# define _Py_atomic_load_ulong_relaxed(p) \ + _Py_atomic_load_uint64_relaxed((uint64_t *)p) +# define _Py_atomic_store_ulong(p, v) \ + _Py_atomic_store_uint64((uint64_t *)p, v) +# define _Py_atomic_store_ulong_relaxed(p, v) \ + _Py_atomic_store_uint64_relaxed((uint64_t *)p, v) +#elif SIZEOF_LONG == 4 +# define _Py_atomic_load_ulong(p) \ + _Py_atomic_load_uint32((uint32_t *)p) +# define _Py_atomic_load_ulong_relaxed(p) \ + _Py_atomic_load_uint32_relaxed((uint32_t *)p) +# define _Py_atomic_store_ulong(p, v) \ + _Py_atomic_store_uint32((uint32_t *)p, v) +# define _Py_atomic_store_ulong_relaxed(p, v) \ + _Py_atomic_store_uint32_relaxed((uint32_t *)p, v) +#else +# error "long must be 4 or 8 bytes in size" +#endif // SIZEOF_LONG diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyatomic_gcc.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyatomic_gcc.h new file mode 100644 index 0000000000000000000000000000000000000000..465226a76ab2556b7c771ddb0fee8ce92d7daddd --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyatomic_gcc.h @@ -0,0 +1,619 @@ +// This is the implementation of Python atomic operations using GCC's built-in +// functions that match the C+11 memory model. This implementation is preferred +// for GCC compatible compilers, such as Clang. These functions are available +// in GCC 4.8+ without needing to compile with --std=c11 or --std=gnu11. + +#ifndef Py_ATOMIC_GCC_H +# error "this header file must not be included directly" +#endif + + +// --- _Py_atomic_add -------------------------------------------------------- + +static inline int +_Py_atomic_add_int(int *obj, int value) +{ return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); } + +static inline int8_t +_Py_atomic_add_int8(int8_t *obj, int8_t value) +{ return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); } + +static inline int16_t +_Py_atomic_add_int16(int16_t *obj, int16_t value) +{ return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); } + +static inline int32_t +_Py_atomic_add_int32(int32_t *obj, int32_t value) +{ return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); } + +static inline int64_t +_Py_atomic_add_int64(int64_t *obj, int64_t value) +{ return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); } + +static inline intptr_t +_Py_atomic_add_intptr(intptr_t *obj, intptr_t value) +{ return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); } + +static inline unsigned int +_Py_atomic_add_uint(unsigned int *obj, unsigned int value) +{ return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); } + +static inline uint8_t +_Py_atomic_add_uint8(uint8_t *obj, uint8_t value) +{ return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); } + +static inline uint16_t +_Py_atomic_add_uint16(uint16_t *obj, uint16_t value) +{ return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); } + +static inline uint32_t +_Py_atomic_add_uint32(uint32_t *obj, uint32_t value) +{ return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); } + +static inline uint64_t +_Py_atomic_add_uint64(uint64_t *obj, uint64_t value) +{ return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); } + +static inline uintptr_t +_Py_atomic_add_uintptr(uintptr_t *obj, uintptr_t value) +{ return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); } + +static inline Py_ssize_t +_Py_atomic_add_ssize(Py_ssize_t *obj, Py_ssize_t value) +{ return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); } + + +// --- _Py_atomic_compare_exchange ------------------------------------------- + +static inline int +_Py_atomic_compare_exchange_int(int *obj, int *expected, int desired) +{ return __atomic_compare_exchange_n(obj, expected, desired, 0, + __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + +static inline int +_Py_atomic_compare_exchange_int8(int8_t *obj, int8_t *expected, int8_t desired) +{ return __atomic_compare_exchange_n(obj, expected, desired, 0, + __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + +static inline int +_Py_atomic_compare_exchange_int16(int16_t *obj, int16_t *expected, int16_t desired) +{ return __atomic_compare_exchange_n(obj, expected, desired, 0, + __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + +static inline int +_Py_atomic_compare_exchange_int32(int32_t *obj, int32_t *expected, int32_t desired) +{ return __atomic_compare_exchange_n(obj, expected, desired, 0, + __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + +static inline int +_Py_atomic_compare_exchange_int64(int64_t *obj, int64_t *expected, int64_t desired) +{ return __atomic_compare_exchange_n(obj, expected, desired, 0, + __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + +static inline int +_Py_atomic_compare_exchange_intptr(intptr_t *obj, intptr_t *expected, intptr_t desired) +{ return __atomic_compare_exchange_n(obj, expected, desired, 0, + __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + +static inline int +_Py_atomic_compare_exchange_uint(unsigned int *obj, unsigned int *expected, unsigned int desired) +{ return __atomic_compare_exchange_n(obj, expected, desired, 0, + __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + +static inline int +_Py_atomic_compare_exchange_uint8(uint8_t *obj, uint8_t *expected, uint8_t desired) +{ return __atomic_compare_exchange_n(obj, expected, desired, 0, + __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + +static inline int +_Py_atomic_compare_exchange_uint16(uint16_t *obj, uint16_t *expected, uint16_t desired) +{ return __atomic_compare_exchange_n(obj, expected, desired, 0, + __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + +static inline int +_Py_atomic_compare_exchange_uint32(uint32_t *obj, uint32_t *expected, uint32_t desired) +{ return __atomic_compare_exchange_n(obj, expected, desired, 0, + __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + +static inline int +_Py_atomic_compare_exchange_uint64(uint64_t *obj, uint64_t *expected, uint64_t desired) +{ return __atomic_compare_exchange_n(obj, expected, desired, 0, + __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + +static inline int +_Py_atomic_compare_exchange_uintptr(uintptr_t *obj, uintptr_t *expected, uintptr_t desired) +{ return __atomic_compare_exchange_n(obj, expected, desired, 0, + __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + +static inline int +_Py_atomic_compare_exchange_ssize(Py_ssize_t *obj, Py_ssize_t *expected, Py_ssize_t desired) +{ return __atomic_compare_exchange_n(obj, expected, desired, 0, + __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + +static inline int +_Py_atomic_compare_exchange_ptr(void *obj, void *expected, void *desired) +{ return __atomic_compare_exchange_n((void **)obj, (void **)expected, desired, 0, + __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + + +// --- _Py_atomic_exchange --------------------------------------------------- + +static inline int +_Py_atomic_exchange_int(int *obj, int value) +{ return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline int8_t +_Py_atomic_exchange_int8(int8_t *obj, int8_t value) +{ return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline int16_t +_Py_atomic_exchange_int16(int16_t *obj, int16_t value) +{ return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline int32_t +_Py_atomic_exchange_int32(int32_t *obj, int32_t value) +{ return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline int64_t +_Py_atomic_exchange_int64(int64_t *obj, int64_t value) +{ return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline intptr_t +_Py_atomic_exchange_intptr(intptr_t *obj, intptr_t value) +{ return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline unsigned int +_Py_atomic_exchange_uint(unsigned int *obj, unsigned int value) +{ return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline uint8_t +_Py_atomic_exchange_uint8(uint8_t *obj, uint8_t value) +{ return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline uint16_t +_Py_atomic_exchange_uint16(uint16_t *obj, uint16_t value) +{ return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline uint32_t +_Py_atomic_exchange_uint32(uint32_t *obj, uint32_t value) +{ return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline uint64_t +_Py_atomic_exchange_uint64(uint64_t *obj, uint64_t value) +{ return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline uintptr_t +_Py_atomic_exchange_uintptr(uintptr_t *obj, uintptr_t value) +{ return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline Py_ssize_t +_Py_atomic_exchange_ssize(Py_ssize_t *obj, Py_ssize_t value) +{ return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline void * +_Py_atomic_exchange_ptr(void *obj, void *value) +{ return __atomic_exchange_n((void **)obj, value, __ATOMIC_SEQ_CST); } + + +// --- _Py_atomic_and -------------------------------------------------------- + +static inline uint8_t +_Py_atomic_and_uint8(uint8_t *obj, uint8_t value) +{ return __atomic_fetch_and(obj, value, __ATOMIC_SEQ_CST); } + +static inline uint16_t +_Py_atomic_and_uint16(uint16_t *obj, uint16_t value) +{ return __atomic_fetch_and(obj, value, __ATOMIC_SEQ_CST); } + +static inline uint32_t +_Py_atomic_and_uint32(uint32_t *obj, uint32_t value) +{ return __atomic_fetch_and(obj, value, __ATOMIC_SEQ_CST); } + +static inline uint64_t +_Py_atomic_and_uint64(uint64_t *obj, uint64_t value) +{ return __atomic_fetch_and(obj, value, __ATOMIC_SEQ_CST); } + +static inline uintptr_t +_Py_atomic_and_uintptr(uintptr_t *obj, uintptr_t value) +{ return __atomic_fetch_and(obj, value, __ATOMIC_SEQ_CST); } + + +// --- _Py_atomic_or --------------------------------------------------------- + +static inline uint8_t +_Py_atomic_or_uint8(uint8_t *obj, uint8_t value) +{ return __atomic_fetch_or(obj, value, __ATOMIC_SEQ_CST); } + +static inline uint16_t +_Py_atomic_or_uint16(uint16_t *obj, uint16_t value) +{ return __atomic_fetch_or(obj, value, __ATOMIC_SEQ_CST); } + +static inline uint32_t +_Py_atomic_or_uint32(uint32_t *obj, uint32_t value) +{ return __atomic_fetch_or(obj, value, __ATOMIC_SEQ_CST); } + +static inline uint64_t +_Py_atomic_or_uint64(uint64_t *obj, uint64_t value) +{ return __atomic_fetch_or(obj, value, __ATOMIC_SEQ_CST); } + +static inline uintptr_t +_Py_atomic_or_uintptr(uintptr_t *obj, uintptr_t value) +{ return __atomic_fetch_or(obj, value, __ATOMIC_SEQ_CST); } + + +// --- _Py_atomic_load ------------------------------------------------------- + +static inline int +_Py_atomic_load_int(const int *obj) +{ return __atomic_load_n(obj, __ATOMIC_SEQ_CST); } + +static inline int8_t +_Py_atomic_load_int8(const int8_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_SEQ_CST); } + +static inline int16_t +_Py_atomic_load_int16(const int16_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_SEQ_CST); } + +static inline int32_t +_Py_atomic_load_int32(const int32_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_SEQ_CST); } + +static inline int64_t +_Py_atomic_load_int64(const int64_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_SEQ_CST); } + +static inline intptr_t +_Py_atomic_load_intptr(const intptr_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_SEQ_CST); } + +static inline uint8_t +_Py_atomic_load_uint8(const uint8_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_SEQ_CST); } + +static inline uint16_t +_Py_atomic_load_uint16(const uint16_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_SEQ_CST); } + +static inline uint32_t +_Py_atomic_load_uint32(const uint32_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_SEQ_CST); } + +static inline uint64_t +_Py_atomic_load_uint64(const uint64_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_SEQ_CST); } + +static inline uintptr_t +_Py_atomic_load_uintptr(const uintptr_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_SEQ_CST); } + +static inline unsigned int +_Py_atomic_load_uint(const unsigned int *obj) +{ return __atomic_load_n(obj, __ATOMIC_SEQ_CST); } + +static inline Py_ssize_t +_Py_atomic_load_ssize(const Py_ssize_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_SEQ_CST); } + +static inline void * +_Py_atomic_load_ptr(const void *obj) +{ return (void *)__atomic_load_n((void * const *)obj, __ATOMIC_SEQ_CST); } + + +// --- _Py_atomic_load_relaxed ----------------------------------------------- + +static inline int +_Py_atomic_load_int_relaxed(const int *obj) +{ return __atomic_load_n(obj, __ATOMIC_RELAXED); } + +static inline char +_Py_atomic_load_char_relaxed(const char *obj) +{ return __atomic_load_n(obj, __ATOMIC_RELAXED); } + +static inline unsigned char +_Py_atomic_load_uchar_relaxed(const unsigned char *obj) +{ return __atomic_load_n(obj, __ATOMIC_RELAXED); } + +static inline short +_Py_atomic_load_short_relaxed(const short *obj) +{ return __atomic_load_n(obj, __ATOMIC_RELAXED); } + +static inline unsigned short +_Py_atomic_load_ushort_relaxed(const unsigned short *obj) +{ return __atomic_load_n(obj, __ATOMIC_RELAXED); } + +static inline long +_Py_atomic_load_long_relaxed(const long *obj) +{ return __atomic_load_n(obj, __ATOMIC_RELAXED); } + +static inline float +_Py_atomic_load_float_relaxed(const float *obj) +{ float ret; __atomic_load(obj, &ret, __ATOMIC_RELAXED); return ret; } + +static inline double +_Py_atomic_load_double_relaxed(const double *obj) +{ double ret; __atomic_load(obj, &ret, __ATOMIC_RELAXED); return ret; } + +static inline int8_t +_Py_atomic_load_int8_relaxed(const int8_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_RELAXED); } + +static inline int16_t +_Py_atomic_load_int16_relaxed(const int16_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_RELAXED); } + +static inline int32_t +_Py_atomic_load_int32_relaxed(const int32_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_RELAXED); } + +static inline int64_t +_Py_atomic_load_int64_relaxed(const int64_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_RELAXED); } + +static inline intptr_t +_Py_atomic_load_intptr_relaxed(const intptr_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_RELAXED); } + +static inline uint8_t +_Py_atomic_load_uint8_relaxed(const uint8_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_RELAXED); } + +static inline uint16_t +_Py_atomic_load_uint16_relaxed(const uint16_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_RELAXED); } + +static inline uint32_t +_Py_atomic_load_uint32_relaxed(const uint32_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_RELAXED); } + +static inline uint64_t +_Py_atomic_load_uint64_relaxed(const uint64_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_RELAXED); } + +static inline uintptr_t +_Py_atomic_load_uintptr_relaxed(const uintptr_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_RELAXED); } + +static inline unsigned int +_Py_atomic_load_uint_relaxed(const unsigned int *obj) +{ return __atomic_load_n(obj, __ATOMIC_RELAXED); } + +static inline Py_ssize_t +_Py_atomic_load_ssize_relaxed(const Py_ssize_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_RELAXED); } + +static inline void * +_Py_atomic_load_ptr_relaxed(const void *obj) +{ return (void *)__atomic_load_n((void * const *)obj, __ATOMIC_RELAXED); } + +static inline unsigned long long +_Py_atomic_load_ullong_relaxed(const unsigned long long *obj) +{ return __atomic_load_n(obj, __ATOMIC_RELAXED); } + +static inline long long +_Py_atomic_load_llong_relaxed(const long long *obj) +{ return __atomic_load_n(obj, __ATOMIC_RELAXED); } + + +// --- _Py_atomic_store ------------------------------------------------------ + +static inline void +_Py_atomic_store_int(int *obj, int value) +{ __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline void +_Py_atomic_store_int8(int8_t *obj, int8_t value) +{ __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline void +_Py_atomic_store_int16(int16_t *obj, int16_t value) +{ __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline void +_Py_atomic_store_int32(int32_t *obj, int32_t value) +{ __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline void +_Py_atomic_store_int64(int64_t *obj, int64_t value) +{ __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline void +_Py_atomic_store_intptr(intptr_t *obj, intptr_t value) +{ __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline void +_Py_atomic_store_uint8(uint8_t *obj, uint8_t value) +{ __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline void +_Py_atomic_store_uint16(uint16_t *obj, uint16_t value) +{ __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline void +_Py_atomic_store_uint32(uint32_t *obj, uint32_t value) +{ __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline void +_Py_atomic_store_uint64(uint64_t *obj, uint64_t value) +{ __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline void +_Py_atomic_store_uintptr(uintptr_t *obj, uintptr_t value) +{ __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline void +_Py_atomic_store_uint(unsigned int *obj, unsigned int value) +{ __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); } + +static inline void +_Py_atomic_store_ptr(void *obj, void *value) +{ __atomic_store_n((void **)obj, value, __ATOMIC_SEQ_CST); } + +static inline void +_Py_atomic_store_ssize(Py_ssize_t *obj, Py_ssize_t value) +{ __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); } + + +// --- _Py_atomic_store_relaxed ---------------------------------------------- + +static inline void +_Py_atomic_store_int_relaxed(int *obj, int value) +{ __atomic_store_n(obj, value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_int8_relaxed(int8_t *obj, int8_t value) +{ __atomic_store_n(obj, value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_int16_relaxed(int16_t *obj, int16_t value) +{ __atomic_store_n(obj, value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_int32_relaxed(int32_t *obj, int32_t value) +{ __atomic_store_n(obj, value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_int64_relaxed(int64_t *obj, int64_t value) +{ __atomic_store_n(obj, value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_intptr_relaxed(intptr_t *obj, intptr_t value) +{ __atomic_store_n(obj, value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_uint8_relaxed(uint8_t *obj, uint8_t value) +{ __atomic_store_n(obj, value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_uint16_relaxed(uint16_t *obj, uint16_t value) +{ __atomic_store_n(obj, value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_uint32_relaxed(uint32_t *obj, uint32_t value) +{ __atomic_store_n(obj, value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_uint64_relaxed(uint64_t *obj, uint64_t value) +{ __atomic_store_n(obj, value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_uintptr_relaxed(uintptr_t *obj, uintptr_t value) +{ __atomic_store_n(obj, value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_uint_relaxed(unsigned int *obj, unsigned int value) +{ __atomic_store_n(obj, value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_ptr_relaxed(void *obj, void *value) +{ __atomic_store_n((void **)obj, value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_ssize_relaxed(Py_ssize_t *obj, Py_ssize_t value) +{ __atomic_store_n(obj, value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_ullong_relaxed(unsigned long long *obj, + unsigned long long value) +{ __atomic_store_n(obj, value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_char_relaxed(char *obj, char value) +{ __atomic_store_n(obj, value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_uchar_relaxed(unsigned char *obj, unsigned char value) +{ __atomic_store_n(obj, value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_short_relaxed(short *obj, short value) +{ __atomic_store_n(obj, value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_ushort_relaxed(unsigned short *obj, unsigned short value) +{ __atomic_store_n(obj, value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_long_relaxed(long *obj, long value) +{ __atomic_store_n(obj, value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_float_relaxed(float *obj, float value) +{ __atomic_store(obj, &value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_double_relaxed(double *obj, double value) +{ __atomic_store(obj, &value, __ATOMIC_RELAXED); } + +static inline void +_Py_atomic_store_llong_relaxed(long long *obj, long long value) +{ __atomic_store_n(obj, value, __ATOMIC_RELAXED); } + + +// --- _Py_atomic_load_ptr_acquire / _Py_atomic_store_ptr_release ------------ + +static inline void * +_Py_atomic_load_ptr_acquire(const void *obj) +{ return (void *)__atomic_load_n((void * const *)obj, __ATOMIC_ACQUIRE); } + +static inline uintptr_t +_Py_atomic_load_uintptr_acquire(const uintptr_t *obj) +{ return (uintptr_t)__atomic_load_n(obj, __ATOMIC_ACQUIRE); } + +static inline void +_Py_atomic_store_ptr_release(void *obj, void *value) +{ __atomic_store_n((void **)obj, value, __ATOMIC_RELEASE); } + +static inline void +_Py_atomic_store_uintptr_release(uintptr_t *obj, uintptr_t value) +{ __atomic_store_n(obj, value, __ATOMIC_RELEASE); } + +static inline void +_Py_atomic_store_int_release(int *obj, int value) +{ __atomic_store_n(obj, value, __ATOMIC_RELEASE); } + +static inline void +_Py_atomic_store_ssize_release(Py_ssize_t *obj, Py_ssize_t value) +{ __atomic_store_n(obj, value, __ATOMIC_RELEASE); } + +static inline void +_Py_atomic_store_uint_release(unsigned int *obj, unsigned int value) +{ __atomic_store_n(obj, value, __ATOMIC_RELEASE); } + +static inline int +_Py_atomic_load_int_acquire(const int *obj) +{ return __atomic_load_n(obj, __ATOMIC_ACQUIRE); } + +static inline void +_Py_atomic_store_uint32_release(uint32_t *obj, uint32_t value) +{ __atomic_store_n(obj, value, __ATOMIC_RELEASE); } + +static inline void +_Py_atomic_store_uint64_release(uint64_t *obj, uint64_t value) +{ __atomic_store_n(obj, value, __ATOMIC_RELEASE); } + +static inline uint64_t +_Py_atomic_load_uint64_acquire(const uint64_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_ACQUIRE); } + +static inline uint32_t +_Py_atomic_load_uint32_acquire(const uint32_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_ACQUIRE); } + +static inline Py_ssize_t +_Py_atomic_load_ssize_acquire(const Py_ssize_t *obj) +{ return __atomic_load_n(obj, __ATOMIC_ACQUIRE); } + +// --- _Py_atomic_fence ------------------------------------------------------ + +static inline void +_Py_atomic_fence_seq_cst(void) +{ __atomic_thread_fence(__ATOMIC_SEQ_CST); } + + static inline void +_Py_atomic_fence_acquire(void) +{ __atomic_thread_fence(__ATOMIC_ACQUIRE); } + + static inline void +_Py_atomic_fence_release(void) +{ __atomic_thread_fence(__ATOMIC_RELEASE); } diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyatomic_msc.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyatomic_msc.h new file mode 100644 index 0000000000000000000000000000000000000000..eb6df819fa7ee88482e51836adf9d4200477b4bc --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyatomic_msc.h @@ -0,0 +1,1204 @@ +// This is the implementation of Python atomic operations for MSVC if the +// compiler does not support C11 or C++11 atomics. +// +// MSVC intrinsics are defined on char, short, long, __int64, and pointer +// types. Note that long and int are both 32-bits even on 64-bit Windows, +// so operations on int are cast to long. +// +// The volatile keyword has additional memory ordering semantics on MSVC. On +// x86 and x86-64, volatile accesses have acquire-release semantics. On ARM64, +// volatile accesses behave like C11's memory_order_relaxed. + +#ifndef Py_ATOMIC_MSC_H +# error "this header file must not be included directly" +#endif + +#include + +#define _Py_atomic_ASSERT_ARG_TYPE(TYPE) \ + Py_BUILD_ASSERT(sizeof(*obj) == sizeof(TYPE)) + + +// --- _Py_atomic_add -------------------------------------------------------- + +static inline int8_t +_Py_atomic_add_int8(int8_t *obj, int8_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(char); + return (int8_t)_InterlockedExchangeAdd8((volatile char *)obj, (char)value); +} + +static inline int16_t +_Py_atomic_add_int16(int16_t *obj, int16_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(short); + return (int16_t)_InterlockedExchangeAdd16((volatile short *)obj, (short)value); +} + +static inline int32_t +_Py_atomic_add_int32(int32_t *obj, int32_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(long); + return (int32_t)_InterlockedExchangeAdd((volatile long *)obj, (long)value); +} + +static inline int64_t +_Py_atomic_add_int64(int64_t *obj, int64_t value) +{ +#if defined(_M_X64) || defined(_M_ARM64) + _Py_atomic_ASSERT_ARG_TYPE(__int64); + return (int64_t)_InterlockedExchangeAdd64((volatile __int64 *)obj, (__int64)value); +#else + int64_t old_value = _Py_atomic_load_int64_relaxed(obj); + for (;;) { + int64_t new_value = old_value + value; + if (_Py_atomic_compare_exchange_int64(obj, &old_value, new_value)) { + return old_value; + } + } +#endif +} + + +static inline uint8_t +_Py_atomic_add_uint8(uint8_t *obj, uint8_t value) +{ + return (uint8_t)_Py_atomic_add_int8((int8_t *)obj, (int8_t)value); +} + +static inline uint16_t +_Py_atomic_add_uint16(uint16_t *obj, uint16_t value) +{ + return (uint16_t)_Py_atomic_add_int16((int16_t *)obj, (int16_t)value); +} + +static inline uint32_t +_Py_atomic_add_uint32(uint32_t *obj, uint32_t value) +{ + return (uint32_t)_Py_atomic_add_int32((int32_t *)obj, (int32_t)value); +} + +static inline int +_Py_atomic_add_int(int *obj, int value) +{ + _Py_atomic_ASSERT_ARG_TYPE(int32_t); + return (int)_Py_atomic_add_int32((int32_t *)obj, (int32_t)value); +} + +static inline unsigned int +_Py_atomic_add_uint(unsigned int *obj, unsigned int value) +{ + _Py_atomic_ASSERT_ARG_TYPE(int32_t); + return (unsigned int)_Py_atomic_add_int32((int32_t *)obj, (int32_t)value); +} + +static inline uint64_t +_Py_atomic_add_uint64(uint64_t *obj, uint64_t value) +{ + return (uint64_t)_Py_atomic_add_int64((int64_t *)obj, (int64_t)value); +} + +static inline intptr_t +_Py_atomic_add_intptr(intptr_t *obj, intptr_t value) +{ +#if SIZEOF_VOID_P == 8 + _Py_atomic_ASSERT_ARG_TYPE(int64_t); + return (intptr_t)_Py_atomic_add_int64((int64_t *)obj, (int64_t)value); +#else + _Py_atomic_ASSERT_ARG_TYPE(int32_t); + return (intptr_t)_Py_atomic_add_int32((int32_t *)obj, (int32_t)value); +#endif +} + +static inline uintptr_t +_Py_atomic_add_uintptr(uintptr_t *obj, uintptr_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(intptr_t); + return (uintptr_t)_Py_atomic_add_intptr((intptr_t *)obj, (intptr_t)value); +} + +static inline Py_ssize_t +_Py_atomic_add_ssize(Py_ssize_t *obj, Py_ssize_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(intptr_t); + return (Py_ssize_t)_Py_atomic_add_intptr((intptr_t *)obj, (intptr_t)value); +} + + +// --- _Py_atomic_compare_exchange ------------------------------------------- + +static inline int +_Py_atomic_compare_exchange_int8(int8_t *obj, int8_t *expected, int8_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(char); + int8_t initial = (int8_t)_InterlockedCompareExchange8( + (volatile char *)obj, + (char)value, + (char)*expected); + if (initial == *expected) { + return 1; + } + *expected = initial; + return 0; +} + +static inline int +_Py_atomic_compare_exchange_int16(int16_t *obj, int16_t *expected, int16_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(short); + int16_t initial = (int16_t)_InterlockedCompareExchange16( + (volatile short *)obj, + (short)value, + (short)*expected); + if (initial == *expected) { + return 1; + } + *expected = initial; + return 0; +} + +static inline int +_Py_atomic_compare_exchange_int32(int32_t *obj, int32_t *expected, int32_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(long); + int32_t initial = (int32_t)_InterlockedCompareExchange( + (volatile long *)obj, + (long)value, + (long)*expected); + if (initial == *expected) { + return 1; + } + *expected = initial; + return 0; +} + +static inline int +_Py_atomic_compare_exchange_int64(int64_t *obj, int64_t *expected, int64_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(__int64); + int64_t initial = (int64_t)_InterlockedCompareExchange64( + (volatile __int64 *)obj, + (__int64)value, + (__int64)*expected); + if (initial == *expected) { + return 1; + } + *expected = initial; + return 0; +} + +static inline int +_Py_atomic_compare_exchange_ptr(void *obj, void *expected, void *value) +{ + void *initial = _InterlockedCompareExchangePointer( + (void**)obj, + value, + *(void**)expected); + if (initial == *(void**)expected) { + return 1; + } + *(void**)expected = initial; + return 0; +} + + +static inline int +_Py_atomic_compare_exchange_uint8(uint8_t *obj, uint8_t *expected, uint8_t value) +{ + return _Py_atomic_compare_exchange_int8((int8_t *)obj, + (int8_t *)expected, + (int8_t)value); +} + +static inline int +_Py_atomic_compare_exchange_uint16(uint16_t *obj, uint16_t *expected, uint16_t value) +{ + return _Py_atomic_compare_exchange_int16((int16_t *)obj, + (int16_t *)expected, + (int16_t)value); +} + +static inline int +_Py_atomic_compare_exchange_uint32(uint32_t *obj, uint32_t *expected, uint32_t value) +{ + return _Py_atomic_compare_exchange_int32((int32_t *)obj, + (int32_t *)expected, + (int32_t)value); +} + +static inline int +_Py_atomic_compare_exchange_int(int *obj, int *expected, int value) +{ + _Py_atomic_ASSERT_ARG_TYPE(int32_t); + return _Py_atomic_compare_exchange_int32((int32_t *)obj, + (int32_t *)expected, + (int32_t)value); +} + +static inline int +_Py_atomic_compare_exchange_uint(unsigned int *obj, unsigned int *expected, unsigned int value) +{ + _Py_atomic_ASSERT_ARG_TYPE(int32_t); + return _Py_atomic_compare_exchange_int32((int32_t *)obj, + (int32_t *)expected, + (int32_t)value); +} + +static inline int +_Py_atomic_compare_exchange_uint64(uint64_t *obj, uint64_t *expected, uint64_t value) +{ + return _Py_atomic_compare_exchange_int64((int64_t *)obj, + (int64_t *)expected, + (int64_t)value); +} + +static inline int +_Py_atomic_compare_exchange_intptr(intptr_t *obj, intptr_t *expected, intptr_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(void*); + return _Py_atomic_compare_exchange_ptr((void**)obj, + (void**)expected, + (void*)value); +} + +static inline int +_Py_atomic_compare_exchange_uintptr(uintptr_t *obj, uintptr_t *expected, uintptr_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(void*); + return _Py_atomic_compare_exchange_ptr((void**)obj, + (void**)expected, + (void*)value); +} + +static inline int +_Py_atomic_compare_exchange_ssize(Py_ssize_t *obj, Py_ssize_t *expected, Py_ssize_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(void*); + return _Py_atomic_compare_exchange_ptr((void**)obj, + (void**)expected, + (void*)value); +} + + +// --- _Py_atomic_exchange --------------------------------------------------- + +static inline int8_t +_Py_atomic_exchange_int8(int8_t *obj, int8_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(char); + return (int8_t)_InterlockedExchange8((volatile char *)obj, (char)value); +} + +static inline int16_t +_Py_atomic_exchange_int16(int16_t *obj, int16_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(short); + return (int16_t)_InterlockedExchange16((volatile short *)obj, (short)value); +} + +static inline int32_t +_Py_atomic_exchange_int32(int32_t *obj, int32_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(long); + return (int32_t)_InterlockedExchange((volatile long *)obj, (long)value); +} + +static inline int64_t +_Py_atomic_exchange_int64(int64_t *obj, int64_t value) +{ +#if defined(_M_X64) || defined(_M_ARM64) + _Py_atomic_ASSERT_ARG_TYPE(__int64); + return (int64_t)_InterlockedExchange64((volatile __int64 *)obj, (__int64)value); +#else + int64_t old_value = _Py_atomic_load_int64_relaxed(obj); + for (;;) { + if (_Py_atomic_compare_exchange_int64(obj, &old_value, value)) { + return old_value; + } + } +#endif +} + +static inline void* +_Py_atomic_exchange_ptr(void *obj, void *value) +{ + return (void*)_InterlockedExchangePointer((void * volatile *)obj, (void *)value); +} + + +static inline uint8_t +_Py_atomic_exchange_uint8(uint8_t *obj, uint8_t value) +{ + return (uint8_t)_Py_atomic_exchange_int8((int8_t *)obj, + (int8_t)value); +} + +static inline uint16_t +_Py_atomic_exchange_uint16(uint16_t *obj, uint16_t value) +{ + return (uint16_t)_Py_atomic_exchange_int16((int16_t *)obj, + (int16_t)value); +} + +static inline uint32_t +_Py_atomic_exchange_uint32(uint32_t *obj, uint32_t value) +{ + return (uint32_t)_Py_atomic_exchange_int32((int32_t *)obj, + (int32_t)value); +} + +static inline int +_Py_atomic_exchange_int(int *obj, int value) +{ + _Py_atomic_ASSERT_ARG_TYPE(int32_t); + return (int)_Py_atomic_exchange_int32((int32_t *)obj, + (int32_t)value); +} + +static inline unsigned int +_Py_atomic_exchange_uint(unsigned int *obj, unsigned int value) +{ + _Py_atomic_ASSERT_ARG_TYPE(int32_t); + return (unsigned int)_Py_atomic_exchange_int32((int32_t *)obj, + (int32_t)value); +} + +static inline uint64_t +_Py_atomic_exchange_uint64(uint64_t *obj, uint64_t value) +{ + return (uint64_t)_Py_atomic_exchange_int64((int64_t *)obj, + (int64_t)value); +} + +static inline intptr_t +_Py_atomic_exchange_intptr(intptr_t *obj, intptr_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(void*); + return (intptr_t)_Py_atomic_exchange_ptr((void**)obj, + (void*)value); +} + +static inline uintptr_t +_Py_atomic_exchange_uintptr(uintptr_t *obj, uintptr_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(void*); + return (uintptr_t)_Py_atomic_exchange_ptr((void**)obj, + (void*)value); +} + +static inline Py_ssize_t +_Py_atomic_exchange_ssize(Py_ssize_t *obj, Py_ssize_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(void*); + return (Py_ssize_t)_Py_atomic_exchange_ptr((void**)obj, + (void*)value); +} + + +// --- _Py_atomic_and -------------------------------------------------------- + +static inline uint8_t +_Py_atomic_and_uint8(uint8_t *obj, uint8_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(char); + return (uint8_t)_InterlockedAnd8((volatile char *)obj, (char)value); +} + +static inline uint16_t +_Py_atomic_and_uint16(uint16_t *obj, uint16_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(short); + return (uint16_t)_InterlockedAnd16((volatile short *)obj, (short)value); +} + +static inline uint32_t +_Py_atomic_and_uint32(uint32_t *obj, uint32_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(long); + return (uint32_t)_InterlockedAnd((volatile long *)obj, (long)value); +} + +static inline uint64_t +_Py_atomic_and_uint64(uint64_t *obj, uint64_t value) +{ +#if defined(_M_X64) || defined(_M_ARM64) + _Py_atomic_ASSERT_ARG_TYPE(__int64); + return (uint64_t)_InterlockedAnd64((volatile __int64 *)obj, (__int64)value); +#else + uint64_t old_value = _Py_atomic_load_uint64_relaxed(obj); + for (;;) { + uint64_t new_value = old_value & value; + if (_Py_atomic_compare_exchange_uint64(obj, &old_value, new_value)) { + return old_value; + } + } +#endif +} + +static inline uintptr_t +_Py_atomic_and_uintptr(uintptr_t *obj, uintptr_t value) +{ +#if SIZEOF_VOID_P == 8 + _Py_atomic_ASSERT_ARG_TYPE(uint64_t); + return (uintptr_t)_Py_atomic_and_uint64((uint64_t *)obj, + (uint64_t)value); +#else + _Py_atomic_ASSERT_ARG_TYPE(uint32_t); + return (uintptr_t)_Py_atomic_and_uint32((uint32_t *)obj, + (uint32_t)value); +#endif +} + + +// --- _Py_atomic_or --------------------------------------------------------- + +static inline uint8_t +_Py_atomic_or_uint8(uint8_t *obj, uint8_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(char); + return (uint8_t)_InterlockedOr8((volatile char *)obj, (char)value); +} + +static inline uint16_t +_Py_atomic_or_uint16(uint16_t *obj, uint16_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(short); + return (uint16_t)_InterlockedOr16((volatile short *)obj, (short)value); +} + +static inline uint32_t +_Py_atomic_or_uint32(uint32_t *obj, uint32_t value) +{ + _Py_atomic_ASSERT_ARG_TYPE(long); + return (uint32_t)_InterlockedOr((volatile long *)obj, (long)value); +} + +static inline uint64_t +_Py_atomic_or_uint64(uint64_t *obj, uint64_t value) +{ +#if defined(_M_X64) || defined(_M_ARM64) + _Py_atomic_ASSERT_ARG_TYPE(__int64); + return (uint64_t)_InterlockedOr64((volatile __int64 *)obj, (__int64)value); +#else + uint64_t old_value = _Py_atomic_load_uint64_relaxed(obj); + for (;;) { + uint64_t new_value = old_value | value; + if (_Py_atomic_compare_exchange_uint64(obj, &old_value, new_value)) { + return old_value; + } + } +#endif +} + + +static inline uintptr_t +_Py_atomic_or_uintptr(uintptr_t *obj, uintptr_t value) +{ +#if SIZEOF_VOID_P == 8 + _Py_atomic_ASSERT_ARG_TYPE(uint64_t); + return (uintptr_t)_Py_atomic_or_uint64((uint64_t *)obj, + (uint64_t)value); +#else + _Py_atomic_ASSERT_ARG_TYPE(uint32_t); + return (uintptr_t)_Py_atomic_or_uint32((uint32_t *)obj, + (uint32_t)value); +#endif +} + + +// --- _Py_atomic_load ------------------------------------------------------- + +static inline uint8_t +_Py_atomic_load_uint8(const uint8_t *obj) +{ +#if defined(_M_X64) || defined(_M_IX86) + return *(volatile uint8_t *)obj; +#elif defined(_M_ARM64) + return (uint8_t)__ldar8((unsigned __int8 volatile *)obj); +#else +# error "no implementation of _Py_atomic_load_uint8" +#endif +} + +static inline uint16_t +_Py_atomic_load_uint16(const uint16_t *obj) +{ +#if defined(_M_X64) || defined(_M_IX86) + return *(volatile uint16_t *)obj; +#elif defined(_M_ARM64) + return (uint16_t)__ldar16((unsigned __int16 volatile *)obj); +#else +# error "no implementation of _Py_atomic_load_uint16" +#endif +} + +static inline uint32_t +_Py_atomic_load_uint32(const uint32_t *obj) +{ +#if defined(_M_X64) || defined(_M_IX86) + return *(volatile uint32_t *)obj; +#elif defined(_M_ARM64) + return (uint32_t)__ldar32((unsigned __int32 volatile *)obj); +#else +# error "no implementation of _Py_atomic_load_uint32" +#endif +} + +static inline uint64_t +_Py_atomic_load_uint64(const uint64_t *obj) +{ +#if defined(_M_X64) || defined(_M_IX86) + return *(volatile uint64_t *)obj; +#elif defined(_M_ARM64) + return (uint64_t)__ldar64((unsigned __int64 volatile *)obj); +#else +# error "no implementation of _Py_atomic_load_uint64" +#endif +} + +static inline int8_t +_Py_atomic_load_int8(const int8_t *obj) +{ + return (int8_t)_Py_atomic_load_uint8((const uint8_t *)obj); +} + +static inline int16_t +_Py_atomic_load_int16(const int16_t *obj) +{ + return (int16_t)_Py_atomic_load_uint16((const uint16_t *)obj); +} + +static inline int32_t +_Py_atomic_load_int32(const int32_t *obj) +{ + return (int32_t)_Py_atomic_load_uint32((const uint32_t *)obj); +} + +static inline int +_Py_atomic_load_int(const int *obj) +{ + _Py_atomic_ASSERT_ARG_TYPE(uint32_t); + return (int)_Py_atomic_load_uint32((uint32_t *)obj); +} + +static inline unsigned int +_Py_atomic_load_uint(const unsigned int *obj) +{ + _Py_atomic_ASSERT_ARG_TYPE(uint32_t); + return (unsigned int)_Py_atomic_load_uint32((uint32_t *)obj); +} + +static inline int64_t +_Py_atomic_load_int64(const int64_t *obj) +{ + return (int64_t)_Py_atomic_load_uint64((const uint64_t *)obj); +} + +static inline void* +_Py_atomic_load_ptr(const void *obj) +{ +#if SIZEOF_VOID_P == 8 + return (void*)_Py_atomic_load_uint64((const uint64_t *)obj); +#else + return (void*)_Py_atomic_load_uint32((const uint32_t *)obj); +#endif +} + +static inline intptr_t +_Py_atomic_load_intptr(const intptr_t *obj) +{ + _Py_atomic_ASSERT_ARG_TYPE(void*); + return (intptr_t)_Py_atomic_load_ptr((void*)obj); +} + +static inline uintptr_t +_Py_atomic_load_uintptr(const uintptr_t *obj) +{ + _Py_atomic_ASSERT_ARG_TYPE(void*); + return (uintptr_t)_Py_atomic_load_ptr((void*)obj); +} + +static inline Py_ssize_t +_Py_atomic_load_ssize(const Py_ssize_t *obj) +{ + _Py_atomic_ASSERT_ARG_TYPE(void*); + return (Py_ssize_t)_Py_atomic_load_ptr((void*)obj); +} + + +// --- _Py_atomic_load_relaxed ----------------------------------------------- + +static inline int +_Py_atomic_load_int_relaxed(const int *obj) +{ + return *(volatile int *)obj; +} + +static inline char +_Py_atomic_load_char_relaxed(const char *obj) +{ + return *(volatile char *)obj; +} + +static inline unsigned char +_Py_atomic_load_uchar_relaxed(const unsigned char *obj) +{ + return *(volatile unsigned char *)obj; +} + +static inline short +_Py_atomic_load_short_relaxed(const short *obj) +{ + return *(volatile short *)obj; +} + +static inline unsigned short +_Py_atomic_load_ushort_relaxed(const unsigned short *obj) +{ + return *(volatile unsigned short *)obj; +} + +static inline long +_Py_atomic_load_long_relaxed(const long *obj) +{ + return *(volatile long *)obj; +} + +static inline float +_Py_atomic_load_float_relaxed(const float *obj) +{ + return *(volatile float *)obj; +} + +static inline double +_Py_atomic_load_double_relaxed(const double *obj) +{ + return *(volatile double *)obj; +} + +static inline int8_t +_Py_atomic_load_int8_relaxed(const int8_t *obj) +{ + return *(volatile int8_t *)obj; +} + +static inline int16_t +_Py_atomic_load_int16_relaxed(const int16_t *obj) +{ + return *(volatile int16_t *)obj; +} + +static inline int32_t +_Py_atomic_load_int32_relaxed(const int32_t *obj) +{ + return *(volatile int32_t *)obj; +} + +static inline int64_t +_Py_atomic_load_int64_relaxed(const int64_t *obj) +{ + return *(volatile int64_t *)obj; +} + +static inline intptr_t +_Py_atomic_load_intptr_relaxed(const intptr_t *obj) +{ + return *(volatile intptr_t *)obj; +} + +static inline uint8_t +_Py_atomic_load_uint8_relaxed(const uint8_t *obj) +{ + return *(volatile uint8_t *)obj; +} + +static inline uint16_t +_Py_atomic_load_uint16_relaxed(const uint16_t *obj) +{ + return *(volatile uint16_t *)obj; +} + +static inline uint32_t +_Py_atomic_load_uint32_relaxed(const uint32_t *obj) +{ + return *(volatile uint32_t *)obj; +} + +static inline uint64_t +_Py_atomic_load_uint64_relaxed(const uint64_t *obj) +{ + return *(volatile uint64_t *)obj; +} + +static inline uintptr_t +_Py_atomic_load_uintptr_relaxed(const uintptr_t *obj) +{ + return *(volatile uintptr_t *)obj; +} + +static inline unsigned int +_Py_atomic_load_uint_relaxed(const unsigned int *obj) +{ + return *(volatile unsigned int *)obj; +} + +static inline Py_ssize_t +_Py_atomic_load_ssize_relaxed(const Py_ssize_t *obj) +{ + return *(volatile Py_ssize_t *)obj; +} + +static inline void* +_Py_atomic_load_ptr_relaxed(const void *obj) +{ + return *(void * volatile *)obj; +} + +static inline unsigned long long +_Py_atomic_load_ullong_relaxed(const unsigned long long *obj) +{ + return *(volatile unsigned long long *)obj; +} + +static inline long long +_Py_atomic_load_llong_relaxed(const long long *obj) +{ + return *(volatile long long *)obj; +} + + +// --- _Py_atomic_store ------------------------------------------------------ + +static inline void +_Py_atomic_store_int(int *obj, int value) +{ + (void)_Py_atomic_exchange_int(obj, value); +} + +static inline void +_Py_atomic_store_int8(int8_t *obj, int8_t value) +{ + (void)_Py_atomic_exchange_int8(obj, value); +} + +static inline void +_Py_atomic_store_int16(int16_t *obj, int16_t value) +{ + (void)_Py_atomic_exchange_int16(obj, value); +} + +static inline void +_Py_atomic_store_int32(int32_t *obj, int32_t value) +{ + (void)_Py_atomic_exchange_int32(obj, value); +} + +static inline void +_Py_atomic_store_int64(int64_t *obj, int64_t value) +{ + (void)_Py_atomic_exchange_int64(obj, value); +} + +static inline void +_Py_atomic_store_intptr(intptr_t *obj, intptr_t value) +{ + (void)_Py_atomic_exchange_intptr(obj, value); +} + +static inline void +_Py_atomic_store_uint8(uint8_t *obj, uint8_t value) +{ + (void)_Py_atomic_exchange_uint8(obj, value); +} + +static inline void +_Py_atomic_store_uint16(uint16_t *obj, uint16_t value) +{ + (void)_Py_atomic_exchange_uint16(obj, value); +} + +static inline void +_Py_atomic_store_uint32(uint32_t *obj, uint32_t value) +{ + (void)_Py_atomic_exchange_uint32(obj, value); +} + +static inline void +_Py_atomic_store_uint64(uint64_t *obj, uint64_t value) +{ + (void)_Py_atomic_exchange_uint64(obj, value); +} + +static inline void +_Py_atomic_store_uintptr(uintptr_t *obj, uintptr_t value) +{ + (void)_Py_atomic_exchange_uintptr(obj, value); +} + +static inline void +_Py_atomic_store_uint(unsigned int *obj, unsigned int value) +{ + (void)_Py_atomic_exchange_uint(obj, value); +} + +static inline void +_Py_atomic_store_ptr(void *obj, void *value) +{ + (void)_Py_atomic_exchange_ptr(obj, value); +} + +static inline void +_Py_atomic_store_ssize(Py_ssize_t *obj, Py_ssize_t value) +{ + (void)_Py_atomic_exchange_ssize(obj, value); +} + + +// --- _Py_atomic_store_relaxed ---------------------------------------------- + +static inline void +_Py_atomic_store_int_relaxed(int *obj, int value) +{ + *(volatile int *)obj = value; +} + +static inline void +_Py_atomic_store_int8_relaxed(int8_t *obj, int8_t value) +{ + *(volatile int8_t *)obj = value; +} + +static inline void +_Py_atomic_store_int16_relaxed(int16_t *obj, int16_t value) +{ + *(volatile int16_t *)obj = value; +} + +static inline void +_Py_atomic_store_int32_relaxed(int32_t *obj, int32_t value) +{ + *(volatile int32_t *)obj = value; +} + +static inline void +_Py_atomic_store_int64_relaxed(int64_t *obj, int64_t value) +{ + *(volatile int64_t *)obj = value; +} + +static inline void +_Py_atomic_store_intptr_relaxed(intptr_t *obj, intptr_t value) +{ + *(volatile intptr_t *)obj = value; +} + +static inline void +_Py_atomic_store_uint8_relaxed(uint8_t *obj, uint8_t value) +{ + *(volatile uint8_t *)obj = value; +} + +static inline void +_Py_atomic_store_uint16_relaxed(uint16_t *obj, uint16_t value) +{ + *(volatile uint16_t *)obj = value; +} + +static inline void +_Py_atomic_store_uint32_relaxed(uint32_t *obj, uint32_t value) +{ + *(volatile uint32_t *)obj = value; +} + +static inline void +_Py_atomic_store_uint64_relaxed(uint64_t *obj, uint64_t value) +{ + *(volatile uint64_t *)obj = value; +} + +static inline void +_Py_atomic_store_uintptr_relaxed(uintptr_t *obj, uintptr_t value) +{ + *(volatile uintptr_t *)obj = value; +} + +static inline void +_Py_atomic_store_uint_relaxed(unsigned int *obj, unsigned int value) +{ + *(volatile unsigned int *)obj = value; +} + +static inline void +_Py_atomic_store_ptr_relaxed(void *obj, void* value) +{ + *(void * volatile *)obj = value; +} + +static inline void +_Py_atomic_store_ssize_relaxed(Py_ssize_t *obj, Py_ssize_t value) +{ + *(volatile Py_ssize_t *)obj = value; +} + +static inline void +_Py_atomic_store_ullong_relaxed(unsigned long long *obj, + unsigned long long value) +{ + *(volatile unsigned long long *)obj = value; +} + +static inline void +_Py_atomic_store_char_relaxed(char *obj, char value) +{ + *(volatile char *)obj = value; +} + +static inline void +_Py_atomic_store_uchar_relaxed(unsigned char *obj, unsigned char value) +{ + *(volatile unsigned char *)obj = value; +} + +static inline void +_Py_atomic_store_short_relaxed(short *obj, short value) +{ + *(volatile short *)obj = value; +} + +static inline void +_Py_atomic_store_ushort_relaxed(unsigned short *obj, unsigned short value) +{ + *(volatile unsigned short *)obj = value; +} + +static inline void +_Py_atomic_store_long_relaxed(long *obj, long value) +{ + *(volatile long *)obj = value; +} + +static inline void +_Py_atomic_store_float_relaxed(float *obj, float value) +{ + *(volatile float *)obj = value; +} + +static inline void +_Py_atomic_store_double_relaxed(double *obj, double value) +{ + *(volatile double *)obj = value; +} + +static inline void +_Py_atomic_store_llong_relaxed(long long *obj, long long value) +{ + *(volatile long long *)obj = value; +} + + +// --- _Py_atomic_load_ptr_acquire / _Py_atomic_store_ptr_release ------------ + +static inline void * +_Py_atomic_load_ptr_acquire(const void *obj) +{ +#if defined(_M_X64) || defined(_M_IX86) + return *(void * volatile *)obj; +#elif defined(_M_ARM64) + return (void *)__ldar64((unsigned __int64 volatile *)obj); +#else +# error "no implementation of _Py_atomic_load_ptr_acquire" +#endif +} + +static inline uintptr_t +_Py_atomic_load_uintptr_acquire(const uintptr_t *obj) +{ +#if defined(_M_X64) || defined(_M_IX86) + return *(uintptr_t volatile *)obj; +#elif defined(_M_ARM64) + return (uintptr_t)__ldar64((unsigned __int64 volatile *)obj); +#else +# error "no implementation of _Py_atomic_load_uintptr_acquire" +#endif +} + +static inline void +_Py_atomic_store_ptr_release(void *obj, void *value) +{ +#if defined(_M_X64) || defined(_M_IX86) + *(void * volatile *)obj = value; +#elif defined(_M_ARM64) + __stlr64((unsigned __int64 volatile *)obj, (uintptr_t)value); +#else +# error "no implementation of _Py_atomic_store_ptr_release" +#endif +} + +static inline void +_Py_atomic_store_uintptr_release(uintptr_t *obj, uintptr_t value) +{ +#if defined(_M_X64) || defined(_M_IX86) + *(uintptr_t volatile *)obj = value; +#elif defined(_M_ARM64) + _Py_atomic_ASSERT_ARG_TYPE(unsigned __int64); + __stlr64((unsigned __int64 volatile *)obj, (unsigned __int64)value); +#else +# error "no implementation of _Py_atomic_store_uintptr_release" +#endif +} + +static inline void +_Py_atomic_store_int_release(int *obj, int value) +{ +#if defined(_M_X64) || defined(_M_IX86) + *(int volatile *)obj = value; +#elif defined(_M_ARM64) + _Py_atomic_ASSERT_ARG_TYPE(unsigned __int32); + __stlr32((unsigned __int32 volatile *)obj, (unsigned __int32)value); +#else +# error "no implementation of _Py_atomic_store_int_release" +#endif +} + +static inline void +_Py_atomic_store_uint_release(unsigned int *obj, unsigned int value) +{ +#if defined(_M_X64) || defined(_M_IX86) + *(volatile unsigned int *)obj = value; +#elif defined(_M_ARM64) + _Py_atomic_ASSERT_ARG_TYPE(unsigned __int32); + __stlr32((unsigned __int32 volatile *)obj, (unsigned __int32)value); +#else +# error "no implementation of _Py_atomic_store_uint_release" +#endif +} + +static inline void +_Py_atomic_store_ssize_release(Py_ssize_t *obj, Py_ssize_t value) +{ +#if defined(_M_X64) || defined(_M_IX86) + *(Py_ssize_t volatile *)obj = value; +#elif defined(_M_ARM64) + __stlr64((unsigned __int64 volatile *)obj, (unsigned __int64)value); +#else +# error "no implementation of _Py_atomic_store_ssize_release" +#endif +} + +static inline int +_Py_atomic_load_int_acquire(const int *obj) +{ +#if defined(_M_X64) || defined(_M_IX86) + return *(int volatile *)obj; +#elif defined(_M_ARM64) + _Py_atomic_ASSERT_ARG_TYPE(unsigned __int32); + return (int)__ldar32((unsigned __int32 volatile *)obj); +#else +# error "no implementation of _Py_atomic_load_int_acquire" +#endif +} + +static inline void +_Py_atomic_store_uint32_release(uint32_t *obj, uint32_t value) +{ +#if defined(_M_X64) || defined(_M_IX86) + *(uint32_t volatile *)obj = value; +#elif defined(_M_ARM64) + _Py_atomic_ASSERT_ARG_TYPE(unsigned __int32); + __stlr32((unsigned __int32 volatile *)obj, (unsigned __int32)value); +#else +# error "no implementation of _Py_atomic_store_uint32_release" +#endif +} + +static inline void +_Py_atomic_store_uint64_release(uint64_t *obj, uint64_t value) +{ +#if defined(_M_X64) || defined(_M_IX86) + *(uint64_t volatile *)obj = value; +#elif defined(_M_ARM64) + _Py_atomic_ASSERT_ARG_TYPE(unsigned __int64); + __stlr64((unsigned __int64 volatile *)obj, (unsigned __int64)value); +#else +# error "no implementation of _Py_atomic_store_uint64_release" +#endif +} + +static inline uint64_t +_Py_atomic_load_uint64_acquire(const uint64_t *obj) +{ +#if defined(_M_X64) || defined(_M_IX86) + return *(uint64_t volatile *)obj; +#elif defined(_M_ARM64) + _Py_atomic_ASSERT_ARG_TYPE(__int64); + return (uint64_t)__ldar64((unsigned __int64 volatile *)obj); +#else +# error "no implementation of _Py_atomic_load_uint64_acquire" +#endif +} + +static inline uint32_t +_Py_atomic_load_uint32_acquire(const uint32_t *obj) +{ +#if defined(_M_X64) || defined(_M_IX86) + return *(uint32_t volatile *)obj; +#elif defined(_M_ARM64) + return (uint32_t)__ldar32((uint32_t volatile *)obj); +#else +# error "no implementation of _Py_atomic_load_uint32_acquire" +#endif +} + +static inline Py_ssize_t +_Py_atomic_load_ssize_acquire(const Py_ssize_t *obj) +{ +#if defined(_M_X64) || defined(_M_IX86) + return *(Py_ssize_t volatile *)obj; +#elif defined(_M_ARM64) + return (Py_ssize_t)__ldar64((unsigned __int64 volatile *)obj); +#else +# error "no implementation of _Py_atomic_load_ssize_acquire" +#endif +} + +// --- _Py_atomic_fence ------------------------------------------------------ + + static inline void +_Py_atomic_fence_seq_cst(void) +{ +#if defined(_M_ARM64) + __dmb(_ARM64_BARRIER_ISH); +#elif defined(_M_X64) + __faststorefence(); +#elif defined(_M_IX86) + _mm_mfence(); +#else +# error "no implementation of _Py_atomic_fence_seq_cst" +#endif +} + + static inline void +_Py_atomic_fence_acquire(void) +{ +#if defined(_M_ARM64) + __dmb(_ARM64_BARRIER_ISHLD); +#elif defined(_M_X64) || defined(_M_IX86) + _ReadBarrier(); +#else +# error "no implementation of _Py_atomic_fence_acquire" +#endif +} + + static inline void +_Py_atomic_fence_release(void) +{ +#if defined(_M_ARM64) + __dmb(_ARM64_BARRIER_ISH); +#elif defined(_M_X64) || defined(_M_IX86) + _ReadWriteBarrier(); +#else +# error "no implementation of _Py_atomic_fence_release" +#endif +} + +#undef _Py_atomic_ASSERT_ARG_TYPE diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyatomic_std.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyatomic_std.h new file mode 100644 index 0000000000000000000000000000000000000000..1a2ccd0cc12b4886fe708270e4d066f697d1cbaf --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyatomic_std.h @@ -0,0 +1,1112 @@ +// This is the implementation of Python atomic operations using C++11 or C11 +// atomics. Note that the pyatomic_gcc.h implementation is preferred for GCC +// compatible compilers, even if they support C++11 atomics. + +#ifndef Py_ATOMIC_STD_H +# error "this header file must not be included directly" +#endif + +#ifdef __cplusplus +extern "C++" { +# include +} +# define _Py_USING_STD using namespace std +# define _Atomic(tp) atomic +#else +# define _Py_USING_STD +# include +#endif + + +// --- _Py_atomic_add -------------------------------------------------------- + +static inline int +_Py_atomic_add_int(int *obj, int value) +{ + _Py_USING_STD; + return atomic_fetch_add((_Atomic(int)*)obj, value); +} + +static inline int8_t +_Py_atomic_add_int8(int8_t *obj, int8_t value) +{ + _Py_USING_STD; + return atomic_fetch_add((_Atomic(int8_t)*)obj, value); +} + +static inline int16_t +_Py_atomic_add_int16(int16_t *obj, int16_t value) +{ + _Py_USING_STD; + return atomic_fetch_add((_Atomic(int16_t)*)obj, value); +} + +static inline int32_t +_Py_atomic_add_int32(int32_t *obj, int32_t value) +{ + _Py_USING_STD; + return atomic_fetch_add((_Atomic(int32_t)*)obj, value); +} + +static inline int64_t +_Py_atomic_add_int64(int64_t *obj, int64_t value) +{ + _Py_USING_STD; + return atomic_fetch_add((_Atomic(int64_t)*)obj, value); +} + +static inline intptr_t +_Py_atomic_add_intptr(intptr_t *obj, intptr_t value) +{ + _Py_USING_STD; + return atomic_fetch_add((_Atomic(intptr_t)*)obj, value); +} + +static inline unsigned int +_Py_atomic_add_uint(unsigned int *obj, unsigned int value) +{ + _Py_USING_STD; + return atomic_fetch_add((_Atomic(unsigned int)*)obj, value); +} + +static inline uint8_t +_Py_atomic_add_uint8(uint8_t *obj, uint8_t value) +{ + _Py_USING_STD; + return atomic_fetch_add((_Atomic(uint8_t)*)obj, value); +} + +static inline uint16_t +_Py_atomic_add_uint16(uint16_t *obj, uint16_t value) +{ + _Py_USING_STD; + return atomic_fetch_add((_Atomic(uint16_t)*)obj, value); +} + +static inline uint32_t +_Py_atomic_add_uint32(uint32_t *obj, uint32_t value) +{ + _Py_USING_STD; + return atomic_fetch_add((_Atomic(uint32_t)*)obj, value); +} + +static inline uint64_t +_Py_atomic_add_uint64(uint64_t *obj, uint64_t value) +{ + _Py_USING_STD; + return atomic_fetch_add((_Atomic(uint64_t)*)obj, value); +} + +static inline uintptr_t +_Py_atomic_add_uintptr(uintptr_t *obj, uintptr_t value) +{ + _Py_USING_STD; + return atomic_fetch_add((_Atomic(uintptr_t)*)obj, value); +} + +static inline Py_ssize_t +_Py_atomic_add_ssize(Py_ssize_t *obj, Py_ssize_t value) +{ + _Py_USING_STD; + return atomic_fetch_add((_Atomic(Py_ssize_t)*)obj, value); +} + + +// --- _Py_atomic_compare_exchange ------------------------------------------- + +static inline int +_Py_atomic_compare_exchange_int(int *obj, int *expected, int desired) +{ + _Py_USING_STD; + return atomic_compare_exchange_strong((_Atomic(int)*)obj, + expected, desired); +} + +static inline int +_Py_atomic_compare_exchange_int8(int8_t *obj, int8_t *expected, int8_t desired) +{ + _Py_USING_STD; + return atomic_compare_exchange_strong((_Atomic(int8_t)*)obj, + expected, desired); +} + +static inline int +_Py_atomic_compare_exchange_int16(int16_t *obj, int16_t *expected, int16_t desired) +{ + _Py_USING_STD; + return atomic_compare_exchange_strong((_Atomic(int16_t)*)obj, + expected, desired); +} + +static inline int +_Py_atomic_compare_exchange_int32(int32_t *obj, int32_t *expected, int32_t desired) +{ + _Py_USING_STD; + return atomic_compare_exchange_strong((_Atomic(int32_t)*)obj, + expected, desired); +} + +static inline int +_Py_atomic_compare_exchange_int64(int64_t *obj, int64_t *expected, int64_t desired) +{ + _Py_USING_STD; + return atomic_compare_exchange_strong((_Atomic(int64_t)*)obj, + expected, desired); +} + +static inline int +_Py_atomic_compare_exchange_intptr(intptr_t *obj, intptr_t *expected, intptr_t desired) +{ + _Py_USING_STD; + return atomic_compare_exchange_strong((_Atomic(intptr_t)*)obj, + expected, desired); +} + +static inline int +_Py_atomic_compare_exchange_uint(unsigned int *obj, unsigned int *expected, unsigned int desired) +{ + _Py_USING_STD; + return atomic_compare_exchange_strong((_Atomic(unsigned int)*)obj, + expected, desired); +} + +static inline int +_Py_atomic_compare_exchange_uint8(uint8_t *obj, uint8_t *expected, uint8_t desired) +{ + _Py_USING_STD; + return atomic_compare_exchange_strong((_Atomic(uint8_t)*)obj, + expected, desired); +} + +static inline int +_Py_atomic_compare_exchange_uint16(uint16_t *obj, uint16_t *expected, uint16_t desired) +{ + _Py_USING_STD; + return atomic_compare_exchange_strong((_Atomic(uint16_t)*)obj, + expected, desired); +} + +static inline int +_Py_atomic_compare_exchange_uint32(uint32_t *obj, uint32_t *expected, uint32_t desired) +{ + _Py_USING_STD; + return atomic_compare_exchange_strong((_Atomic(uint32_t)*)obj, + expected, desired); +} + +static inline int +_Py_atomic_compare_exchange_uint64(uint64_t *obj, uint64_t *expected, uint64_t desired) +{ + _Py_USING_STD; + return atomic_compare_exchange_strong((_Atomic(uint64_t)*)obj, + expected, desired); +} + +static inline int +_Py_atomic_compare_exchange_uintptr(uintptr_t *obj, uintptr_t *expected, uintptr_t desired) +{ + _Py_USING_STD; + return atomic_compare_exchange_strong((_Atomic(uintptr_t)*)obj, + expected, desired); +} + +static inline int +_Py_atomic_compare_exchange_ssize(Py_ssize_t *obj, Py_ssize_t *expected, Py_ssize_t desired) +{ + _Py_USING_STD; + return atomic_compare_exchange_strong((_Atomic(Py_ssize_t)*)obj, + expected, desired); +} + +static inline int +_Py_atomic_compare_exchange_ptr(void *obj, void *expected, void *desired) +{ + _Py_USING_STD; + return atomic_compare_exchange_strong((_Atomic(void *)*)obj, + (void **)expected, desired); +} + + +// --- _Py_atomic_exchange --------------------------------------------------- + +static inline int +_Py_atomic_exchange_int(int *obj, int value) +{ + _Py_USING_STD; + return atomic_exchange((_Atomic(int)*)obj, value); +} + +static inline int8_t +_Py_atomic_exchange_int8(int8_t *obj, int8_t value) +{ + _Py_USING_STD; + return atomic_exchange((_Atomic(int8_t)*)obj, value); +} + +static inline int16_t +_Py_atomic_exchange_int16(int16_t *obj, int16_t value) +{ + _Py_USING_STD; + return atomic_exchange((_Atomic(int16_t)*)obj, value); +} + +static inline int32_t +_Py_atomic_exchange_int32(int32_t *obj, int32_t value) +{ + _Py_USING_STD; + return atomic_exchange((_Atomic(int32_t)*)obj, value); +} + +static inline int64_t +_Py_atomic_exchange_int64(int64_t *obj, int64_t value) +{ + _Py_USING_STD; + return atomic_exchange((_Atomic(int64_t)*)obj, value); +} + +static inline intptr_t +_Py_atomic_exchange_intptr(intptr_t *obj, intptr_t value) +{ + _Py_USING_STD; + return atomic_exchange((_Atomic(intptr_t)*)obj, value); +} + +static inline unsigned int +_Py_atomic_exchange_uint(unsigned int *obj, unsigned int value) +{ + _Py_USING_STD; + return atomic_exchange((_Atomic(unsigned int)*)obj, value); +} + +static inline uint8_t +_Py_atomic_exchange_uint8(uint8_t *obj, uint8_t value) +{ + _Py_USING_STD; + return atomic_exchange((_Atomic(uint8_t)*)obj, value); +} + +static inline uint16_t +_Py_atomic_exchange_uint16(uint16_t *obj, uint16_t value) +{ + _Py_USING_STD; + return atomic_exchange((_Atomic(uint16_t)*)obj, value); +} + +static inline uint32_t +_Py_atomic_exchange_uint32(uint32_t *obj, uint32_t value) +{ + _Py_USING_STD; + return atomic_exchange((_Atomic(uint32_t)*)obj, value); +} + +static inline uint64_t +_Py_atomic_exchange_uint64(uint64_t *obj, uint64_t value) +{ + _Py_USING_STD; + return atomic_exchange((_Atomic(uint64_t)*)obj, value); +} + +static inline uintptr_t +_Py_atomic_exchange_uintptr(uintptr_t *obj, uintptr_t value) +{ + _Py_USING_STD; + return atomic_exchange((_Atomic(uintptr_t)*)obj, value); +} + +static inline Py_ssize_t +_Py_atomic_exchange_ssize(Py_ssize_t *obj, Py_ssize_t value) +{ + _Py_USING_STD; + return atomic_exchange((_Atomic(Py_ssize_t)*)obj, value); +} + +static inline void* +_Py_atomic_exchange_ptr(void *obj, void *value) +{ + _Py_USING_STD; + return atomic_exchange((_Atomic(void *)*)obj, value); +} + + +// --- _Py_atomic_and -------------------------------------------------------- + +static inline uint8_t +_Py_atomic_and_uint8(uint8_t *obj, uint8_t value) +{ + _Py_USING_STD; + return atomic_fetch_and((_Atomic(uint8_t)*)obj, value); +} + +static inline uint16_t +_Py_atomic_and_uint16(uint16_t *obj, uint16_t value) +{ + _Py_USING_STD; + return atomic_fetch_and((_Atomic(uint16_t)*)obj, value); +} + +static inline uint32_t +_Py_atomic_and_uint32(uint32_t *obj, uint32_t value) +{ + _Py_USING_STD; + return atomic_fetch_and((_Atomic(uint32_t)*)obj, value); +} + +static inline uint64_t +_Py_atomic_and_uint64(uint64_t *obj, uint64_t value) +{ + _Py_USING_STD; + return atomic_fetch_and((_Atomic(uint64_t)*)obj, value); +} + +static inline uintptr_t +_Py_atomic_and_uintptr(uintptr_t *obj, uintptr_t value) +{ + _Py_USING_STD; + return atomic_fetch_and((_Atomic(uintptr_t)*)obj, value); +} + + +// --- _Py_atomic_or --------------------------------------------------------- + +static inline uint8_t +_Py_atomic_or_uint8(uint8_t *obj, uint8_t value) +{ + _Py_USING_STD; + return atomic_fetch_or((_Atomic(uint8_t)*)obj, value); +} + +static inline uint16_t +_Py_atomic_or_uint16(uint16_t *obj, uint16_t value) +{ + _Py_USING_STD; + return atomic_fetch_or((_Atomic(uint16_t)*)obj, value); +} + +static inline uint32_t +_Py_atomic_or_uint32(uint32_t *obj, uint32_t value) +{ + _Py_USING_STD; + return atomic_fetch_or((_Atomic(uint32_t)*)obj, value); +} + +static inline uint64_t +_Py_atomic_or_uint64(uint64_t *obj, uint64_t value) +{ + _Py_USING_STD; + return atomic_fetch_or((_Atomic(uint64_t)*)obj, value); +} + +static inline uintptr_t +_Py_atomic_or_uintptr(uintptr_t *obj, uintptr_t value) +{ + _Py_USING_STD; + return atomic_fetch_or((_Atomic(uintptr_t)*)obj, value); +} + + +// --- _Py_atomic_load ------------------------------------------------------- + +static inline int +_Py_atomic_load_int(const int *obj) +{ + _Py_USING_STD; + return atomic_load((const _Atomic(int)*)obj); +} + +static inline int8_t +_Py_atomic_load_int8(const int8_t *obj) +{ + _Py_USING_STD; + return atomic_load((const _Atomic(int8_t)*)obj); +} + +static inline int16_t +_Py_atomic_load_int16(const int16_t *obj) +{ + _Py_USING_STD; + return atomic_load((const _Atomic(int16_t)*)obj); +} + +static inline int32_t +_Py_atomic_load_int32(const int32_t *obj) +{ + _Py_USING_STD; + return atomic_load((const _Atomic(int32_t)*)obj); +} + +static inline int64_t +_Py_atomic_load_int64(const int64_t *obj) +{ + _Py_USING_STD; + return atomic_load((const _Atomic(int64_t)*)obj); +} + +static inline intptr_t +_Py_atomic_load_intptr(const intptr_t *obj) +{ + _Py_USING_STD; + return atomic_load((const _Atomic(intptr_t)*)obj); +} + +static inline uint8_t +_Py_atomic_load_uint8(const uint8_t *obj) +{ + _Py_USING_STD; + return atomic_load((const _Atomic(uint8_t)*)obj); +} + +static inline uint16_t +_Py_atomic_load_uint16(const uint16_t *obj) +{ + _Py_USING_STD; + return atomic_load((const _Atomic(uint16_t)*)obj); +} + +static inline uint32_t +_Py_atomic_load_uint32(const uint32_t *obj) +{ + _Py_USING_STD; + return atomic_load((const _Atomic(uint32_t)*)obj); +} + +static inline uint64_t +_Py_atomic_load_uint64(const uint64_t *obj) +{ + _Py_USING_STD; + return atomic_load((const _Atomic(uint64_t)*)obj); +} + +static inline uintptr_t +_Py_atomic_load_uintptr(const uintptr_t *obj) +{ + _Py_USING_STD; + return atomic_load((const _Atomic(uintptr_t)*)obj); +} + +static inline unsigned int +_Py_atomic_load_uint(const unsigned int *obj) +{ + _Py_USING_STD; + return atomic_load((const _Atomic(unsigned int)*)obj); +} + +static inline Py_ssize_t +_Py_atomic_load_ssize(const Py_ssize_t *obj) +{ + _Py_USING_STD; + return atomic_load((const _Atomic(Py_ssize_t)*)obj); +} + +static inline void* +_Py_atomic_load_ptr(const void *obj) +{ + _Py_USING_STD; + return atomic_load((const _Atomic(void*)*)obj); +} + + +// --- _Py_atomic_load_relaxed ----------------------------------------------- + +static inline int +_Py_atomic_load_int_relaxed(const int *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(int)*)obj, + memory_order_relaxed); +} + +static inline char +_Py_atomic_load_char_relaxed(const char *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(char)*)obj, + memory_order_relaxed); +} + +static inline unsigned char +_Py_atomic_load_uchar_relaxed(const unsigned char *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(unsigned char)*)obj, + memory_order_relaxed); +} + +static inline short +_Py_atomic_load_short_relaxed(const short *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(short)*)obj, + memory_order_relaxed); +} + +static inline unsigned short +_Py_atomic_load_ushort_relaxed(const unsigned short *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(unsigned short)*)obj, + memory_order_relaxed); +} + +static inline long +_Py_atomic_load_long_relaxed(const long *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(long)*)obj, + memory_order_relaxed); +} + +static inline float +_Py_atomic_load_float_relaxed(const float *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(float)*)obj, + memory_order_relaxed); +} + +static inline double +_Py_atomic_load_double_relaxed(const double *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(double)*)obj, + memory_order_relaxed); +} + +static inline int8_t +_Py_atomic_load_int8_relaxed(const int8_t *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(int8_t)*)obj, + memory_order_relaxed); +} + +static inline int16_t +_Py_atomic_load_int16_relaxed(const int16_t *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(int16_t)*)obj, + memory_order_relaxed); +} + +static inline int32_t +_Py_atomic_load_int32_relaxed(const int32_t *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(int32_t)*)obj, + memory_order_relaxed); +} + +static inline int64_t +_Py_atomic_load_int64_relaxed(const int64_t *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(int64_t)*)obj, + memory_order_relaxed); +} + +static inline intptr_t +_Py_atomic_load_intptr_relaxed(const intptr_t *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(intptr_t)*)obj, + memory_order_relaxed); +} + +static inline uint8_t +_Py_atomic_load_uint8_relaxed(const uint8_t *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(uint8_t)*)obj, + memory_order_relaxed); +} + +static inline uint16_t +_Py_atomic_load_uint16_relaxed(const uint16_t *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(uint16_t)*)obj, + memory_order_relaxed); +} + +static inline uint32_t +_Py_atomic_load_uint32_relaxed(const uint32_t *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(uint32_t)*)obj, + memory_order_relaxed); +} + +static inline uint64_t +_Py_atomic_load_uint64_relaxed(const uint64_t *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(uint64_t)*)obj, + memory_order_relaxed); +} + +static inline uintptr_t +_Py_atomic_load_uintptr_relaxed(const uintptr_t *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(uintptr_t)*)obj, + memory_order_relaxed); +} + +static inline unsigned int +_Py_atomic_load_uint_relaxed(const unsigned int *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(unsigned int)*)obj, + memory_order_relaxed); +} + +static inline Py_ssize_t +_Py_atomic_load_ssize_relaxed(const Py_ssize_t *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(Py_ssize_t)*)obj, + memory_order_relaxed); +} + +static inline void* +_Py_atomic_load_ptr_relaxed(const void *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(void*)*)obj, + memory_order_relaxed); +} + +static inline unsigned long long +_Py_atomic_load_ullong_relaxed(const unsigned long long *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(unsigned long long)*)obj, + memory_order_relaxed); +} + +static inline long long +_Py_atomic_load_llong_relaxed(const long long *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(long long)*)obj, + memory_order_relaxed); +} + + +// --- _Py_atomic_store ------------------------------------------------------ + +static inline void +_Py_atomic_store_int(int *obj, int value) +{ + _Py_USING_STD; + atomic_store((_Atomic(int)*)obj, value); +} + +static inline void +_Py_atomic_store_int8(int8_t *obj, int8_t value) +{ + _Py_USING_STD; + atomic_store((_Atomic(int8_t)*)obj, value); +} + +static inline void +_Py_atomic_store_int16(int16_t *obj, int16_t value) +{ + _Py_USING_STD; + atomic_store((_Atomic(int16_t)*)obj, value); +} + +static inline void +_Py_atomic_store_int32(int32_t *obj, int32_t value) +{ + _Py_USING_STD; + atomic_store((_Atomic(int32_t)*)obj, value); +} + +static inline void +_Py_atomic_store_int64(int64_t *obj, int64_t value) +{ + _Py_USING_STD; + atomic_store((_Atomic(int64_t)*)obj, value); +} + +static inline void +_Py_atomic_store_intptr(intptr_t *obj, intptr_t value) +{ + _Py_USING_STD; + atomic_store((_Atomic(intptr_t)*)obj, value); +} + +static inline void +_Py_atomic_store_uint8(uint8_t *obj, uint8_t value) +{ + _Py_USING_STD; + atomic_store((_Atomic(uint8_t)*)obj, value); +} + +static inline void +_Py_atomic_store_uint16(uint16_t *obj, uint16_t value) +{ + _Py_USING_STD; + atomic_store((_Atomic(uint16_t)*)obj, value); +} + +static inline void +_Py_atomic_store_uint32(uint32_t *obj, uint32_t value) +{ + _Py_USING_STD; + atomic_store((_Atomic(uint32_t)*)obj, value); +} + +static inline void +_Py_atomic_store_uint64(uint64_t *obj, uint64_t value) +{ + _Py_USING_STD; + atomic_store((_Atomic(uint64_t)*)obj, value); +} + +static inline void +_Py_atomic_store_uintptr(uintptr_t *obj, uintptr_t value) +{ + _Py_USING_STD; + atomic_store((_Atomic(uintptr_t)*)obj, value); +} + +static inline void +_Py_atomic_store_uint(unsigned int *obj, unsigned int value) +{ + _Py_USING_STD; + atomic_store((_Atomic(unsigned int)*)obj, value); +} + +static inline void +_Py_atomic_store_ptr(void *obj, void *value) +{ + _Py_USING_STD; + atomic_store((_Atomic(void*)*)obj, value); +} + +static inline void +_Py_atomic_store_ssize(Py_ssize_t *obj, Py_ssize_t value) +{ + _Py_USING_STD; + atomic_store((_Atomic(Py_ssize_t)*)obj, value); +} + + +// --- _Py_atomic_store_relaxed ---------------------------------------------- + +static inline void +_Py_atomic_store_int_relaxed(int *obj, int value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(int)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_int8_relaxed(int8_t *obj, int8_t value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(int8_t)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_int16_relaxed(int16_t *obj, int16_t value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(int16_t)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_int32_relaxed(int32_t *obj, int32_t value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(int32_t)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_int64_relaxed(int64_t *obj, int64_t value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(int64_t)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_intptr_relaxed(intptr_t *obj, intptr_t value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(intptr_t)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_uint8_relaxed(uint8_t *obj, uint8_t value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(uint8_t)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_uint16_relaxed(uint16_t *obj, uint16_t value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(uint16_t)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_uint32_relaxed(uint32_t *obj, uint32_t value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(uint32_t)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_uint64_relaxed(uint64_t *obj, uint64_t value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(uint64_t)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_uintptr_relaxed(uintptr_t *obj, uintptr_t value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(uintptr_t)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_uint_relaxed(unsigned int *obj, unsigned int value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(unsigned int)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_ptr_relaxed(void *obj, void *value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(void*)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_ssize_relaxed(Py_ssize_t *obj, Py_ssize_t value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(Py_ssize_t)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_ullong_relaxed(unsigned long long *obj, + unsigned long long value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(unsigned long long)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_char_relaxed(char *obj, char value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(char)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_uchar_relaxed(unsigned char *obj, unsigned char value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(unsigned char)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_short_relaxed(short *obj, short value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(short)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_ushort_relaxed(unsigned short *obj, unsigned short value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(unsigned short)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_long_relaxed(long *obj, long value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(long)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_float_relaxed(float *obj, float value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(float)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_double_relaxed(double *obj, double value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(double)*)obj, value, + memory_order_relaxed); +} + +static inline void +_Py_atomic_store_llong_relaxed(long long *obj, long long value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(long long)*)obj, value, + memory_order_relaxed); +} + + +// --- _Py_atomic_load_ptr_acquire / _Py_atomic_store_ptr_release ------------ + +static inline void * +_Py_atomic_load_ptr_acquire(const void *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(void*)*)obj, + memory_order_acquire); +} + +static inline uintptr_t +_Py_atomic_load_uintptr_acquire(const uintptr_t *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(uintptr_t)*)obj, + memory_order_acquire); +} + +static inline void +_Py_atomic_store_ptr_release(void *obj, void *value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(void*)*)obj, value, + memory_order_release); +} + +static inline void +_Py_atomic_store_uintptr_release(uintptr_t *obj, uintptr_t value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(uintptr_t)*)obj, value, + memory_order_release); +} + +static inline void +_Py_atomic_store_int_release(int *obj, int value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(int)*)obj, value, + memory_order_release); +} + +static inline void +_Py_atomic_store_uint_release(unsigned int *obj, unsigned int value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(unsigned int)*)obj, value, + memory_order_release); +} + +static inline void +_Py_atomic_store_ssize_release(Py_ssize_t *obj, Py_ssize_t value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(Py_ssize_t)*)obj, value, + memory_order_release); +} + +static inline int +_Py_atomic_load_int_acquire(const int *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(int)*)obj, + memory_order_acquire); +} + +static inline void +_Py_atomic_store_uint32_release(uint32_t *obj, uint32_t value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(uint32_t)*)obj, value, + memory_order_release); +} + +static inline void +_Py_atomic_store_uint64_release(uint64_t *obj, uint64_t value) +{ + _Py_USING_STD; + atomic_store_explicit((_Atomic(uint64_t)*)obj, value, + memory_order_release); +} + +static inline uint64_t +_Py_atomic_load_uint64_acquire(const uint64_t *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(uint64_t)*)obj, + memory_order_acquire); +} + +static inline uint32_t +_Py_atomic_load_uint32_acquire(const uint32_t *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(uint32_t)*)obj, + memory_order_acquire); +} + +static inline Py_ssize_t +_Py_atomic_load_ssize_acquire(const Py_ssize_t *obj) +{ + _Py_USING_STD; + return atomic_load_explicit((const _Atomic(Py_ssize_t)*)obj, + memory_order_acquire); +} + + +// --- _Py_atomic_fence ------------------------------------------------------ + + static inline void +_Py_atomic_fence_seq_cst(void) +{ + _Py_USING_STD; + atomic_thread_fence(memory_order_seq_cst); +} + + static inline void +_Py_atomic_fence_acquire(void) +{ + _Py_USING_STD; + atomic_thread_fence(memory_order_acquire); +} + + static inline void +_Py_atomic_fence_release(void) +{ + _Py_USING_STD; + atomic_thread_fence(memory_order_release); +} diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyctype.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyctype.h new file mode 100644 index 0000000000000000000000000000000000000000..729d93275e6c5365fb26fd521b1ff58de22b5fdb --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyctype.h @@ -0,0 +1,39 @@ +#ifndef Py_LIMITED_API +#ifndef PYCTYPE_H +#define PYCTYPE_H +#ifdef __cplusplus +extern "C" { +#endif + +#define PY_CTF_LOWER 0x01 +#define PY_CTF_UPPER 0x02 +#define PY_CTF_ALPHA (PY_CTF_LOWER|PY_CTF_UPPER) +#define PY_CTF_DIGIT 0x04 +#define PY_CTF_ALNUM (PY_CTF_ALPHA|PY_CTF_DIGIT) +#define PY_CTF_SPACE 0x08 +#define PY_CTF_XDIGIT 0x10 + +PyAPI_DATA(const unsigned int) _Py_ctype_table[256]; + +/* Unlike their C counterparts, the following macros are not meant to + * handle an int with any of the values [EOF, 0-UCHAR_MAX]. The argument + * must be a signed/unsigned char. */ +#define Py_ISLOWER(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_LOWER) +#define Py_ISUPPER(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_UPPER) +#define Py_ISALPHA(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_ALPHA) +#define Py_ISDIGIT(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_DIGIT) +#define Py_ISXDIGIT(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_XDIGIT) +#define Py_ISALNUM(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_ALNUM) +#define Py_ISSPACE(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_SPACE) + +PyAPI_DATA(const unsigned char) _Py_ctype_tolower[256]; +PyAPI_DATA(const unsigned char) _Py_ctype_toupper[256]; + +#define Py_TOLOWER(c) (_Py_ctype_tolower[Py_CHARMASK(c)]) +#define Py_TOUPPER(c) (_Py_ctype_toupper[Py_CHARMASK(c)]) + +#ifdef __cplusplus +} +#endif +#endif /* !PYCTYPE_H */ +#endif /* !Py_LIMITED_API */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pydebug.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pydebug.h new file mode 100644 index 0000000000000000000000000000000000000000..f6ebd99ed7e2ff2755d7fdd1d11fa77ff374088b --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pydebug.h @@ -0,0 +1,38 @@ +#ifndef Py_LIMITED_API +#ifndef Py_PYDEBUG_H +#define Py_PYDEBUG_H +#ifdef __cplusplus +extern "C" { +#endif + +Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_DebugFlag; +Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_VerboseFlag; +Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_QuietFlag; +Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_InteractiveFlag; +Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_InspectFlag; +Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_OptimizeFlag; +Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_NoSiteFlag; +Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_BytesWarningFlag; +Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_FrozenFlag; +Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_IgnoreEnvironmentFlag; +Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_DontWriteBytecodeFlag; +Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_NoUserSiteDirectory; +Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_UnbufferedStdioFlag; +Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_HashRandomizationFlag; +Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_IsolatedFlag; + +#ifdef MS_WINDOWS +Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_LegacyWindowsFSEncodingFlag; +Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_LegacyWindowsStdioFlag; +#endif + +/* this is a wrapper around getenv() that pays attention to + Py_IgnoreEnvironmentFlag. It should be used for getting variables like + PYTHONPATH and PYTHONHOME from the environment */ +PyAPI_FUNC(char*) Py_GETENV(const char *name); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_PYDEBUG_H */ +#endif /* Py_LIMITED_API */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyerrors.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyerrors.h new file mode 100644 index 0000000000000000000000000000000000000000..be2e3b641c25cb67dc6b61eac74cf3139d6e328a --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyerrors.h @@ -0,0 +1,133 @@ +#ifndef Py_CPYTHON_ERRORS_H +# error "this header file must not be included directly" +#endif + +/* Error objects */ + +/* PyException_HEAD defines the initial segment of every exception class. */ +#define PyException_HEAD PyObject_HEAD PyObject *dict;\ + PyObject *args; PyObject *notes; PyObject *traceback;\ + PyObject *context; PyObject *cause;\ + char suppress_context; + +typedef struct { + PyException_HEAD +} PyBaseExceptionObject; + +typedef struct { + PyException_HEAD + PyObject *msg; + PyObject *excs; + PyObject *excs_str; +} PyBaseExceptionGroupObject; + +typedef struct { + PyException_HEAD + PyObject *msg; + PyObject *filename; + PyObject *lineno; + PyObject *offset; + PyObject *end_lineno; + PyObject *end_offset; + PyObject *text; + PyObject *print_file_and_line; + PyObject *metadata; +} PySyntaxErrorObject; + +typedef struct { + PyException_HEAD + PyObject *msg; + PyObject *name; + PyObject *path; + PyObject *name_from; +} PyImportErrorObject; + +typedef struct { + PyException_HEAD + PyObject *encoding; + PyObject *object; + Py_ssize_t start; + Py_ssize_t end; + PyObject *reason; +} PyUnicodeErrorObject; + +typedef struct { + PyException_HEAD + PyObject *code; +} PySystemExitObject; + +typedef struct { + PyException_HEAD + PyObject *myerrno; + PyObject *strerror; + PyObject *filename; + PyObject *filename2; +#ifdef MS_WINDOWS + PyObject *winerror; +#endif + Py_ssize_t written; /* only for BlockingIOError, -1 otherwise */ +} PyOSErrorObject; + +typedef struct { + PyException_HEAD + PyObject *value; +} PyStopIterationObject; + +typedef struct { + PyException_HEAD + PyObject *name; +} PyNameErrorObject; + +typedef struct { + PyException_HEAD + PyObject *obj; + PyObject *name; +} PyAttributeErrorObject; + +/* Compatibility typedefs */ +typedef PyOSErrorObject PyEnvironmentErrorObject; +#ifdef MS_WINDOWS +typedef PyOSErrorObject PyWindowsErrorObject; +#endif + +/* Context manipulation (PEP 3134) */ + +PyAPI_FUNC(void) _PyErr_ChainExceptions1(PyObject *); + +/* In exceptions.c */ + +PyAPI_FUNC(PyObject*) PyUnstable_Exc_PrepReraiseStar( + PyObject *orig, + PyObject *excs); + +/* In signalmodule.c */ + +PyAPI_FUNC(int) PySignal_SetWakeupFd(int fd); + +/* Support for adding program text to SyntaxErrors */ + +PyAPI_FUNC(void) PyErr_SyntaxLocationObject( + PyObject *filename, + int lineno, + int col_offset); + +PyAPI_FUNC(void) PyErr_RangedSyntaxLocationObject( + PyObject *filename, + int lineno, + int col_offset, + int end_lineno, + int end_col_offset); + +PyAPI_FUNC(PyObject *) PyErr_ProgramTextObject( + PyObject *filename, + int lineno); + +PyAPI_FUNC(void) _Py_NO_RETURN _Py_FatalErrorFunc( + const char *func, + const char *message); + +PyAPI_FUNC(void) PyErr_FormatUnraisable(const char *, ...); + +PyAPI_DATA(PyObject *) PyExc_PythonFinalizationError; + +#define Py_FatalError(message) _Py_FatalErrorFunc(__func__, (message)) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyfpe.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyfpe.h new file mode 100644 index 0000000000000000000000000000000000000000..cc2def63aa5527f4ac192aa663a14353a88e1774 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyfpe.h @@ -0,0 +1,15 @@ +#ifndef Py_PYFPE_H +#define Py_PYFPE_H +/* Header excluded from the stable API */ +#ifndef Py_LIMITED_API + +/* These macros used to do something when Python was built with --with-fpectl, + * but support for that was dropped in 3.7. We continue to define them though, + * to avoid breaking API users. + */ + +#define PyFPE_START_PROTECT(err_string, leave_stmt) +#define PyFPE_END_PROTECT(v) + +#endif /* !defined(Py_LIMITED_API) */ +#endif /* !Py_PYFPE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyframe.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyframe.h new file mode 100644 index 0000000000000000000000000000000000000000..51529763923ec3a48662219f08928b6b79ddd5fb --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyframe.h @@ -0,0 +1,45 @@ +#ifndef Py_CPYTHON_PYFRAME_H +# error "this header file must not be included directly" +#endif + +PyAPI_DATA(PyTypeObject) PyFrame_Type; +PyAPI_DATA(PyTypeObject) PyFrameLocalsProxy_Type; + +#define PyFrame_Check(op) Py_IS_TYPE((op), &PyFrame_Type) +#define PyFrameLocalsProxy_Check(op) Py_IS_TYPE((op), &PyFrameLocalsProxy_Type) + +PyAPI_FUNC(PyFrameObject *) PyFrame_GetBack(PyFrameObject *frame); +PyAPI_FUNC(PyObject *) PyFrame_GetLocals(PyFrameObject *frame); + +PyAPI_FUNC(PyObject *) PyFrame_GetGlobals(PyFrameObject *frame); +PyAPI_FUNC(PyObject *) PyFrame_GetBuiltins(PyFrameObject *frame); + +PyAPI_FUNC(PyObject *) PyFrame_GetGenerator(PyFrameObject *frame); +PyAPI_FUNC(int) PyFrame_GetLasti(PyFrameObject *frame); +PyAPI_FUNC(PyObject*) PyFrame_GetVar(PyFrameObject *frame, PyObject *name); +PyAPI_FUNC(PyObject*) PyFrame_GetVarString(PyFrameObject *frame, const char *name); + +/* The following functions are for use by debuggers and other tools + * implementing custom frame evaluators with PEP 523. */ + +struct _PyInterpreterFrame; + +/* Returns the code object of the frame (strong reference). + * Does not raise an exception. */ +PyAPI_FUNC(PyObject *) PyUnstable_InterpreterFrame_GetCode(struct _PyInterpreterFrame *frame); + +/* Returns a byte offset into the last executed instruction. + * Does not raise an exception. */ +PyAPI_FUNC(int) PyUnstable_InterpreterFrame_GetLasti(struct _PyInterpreterFrame *frame); + +/* Returns the currently executing line number, or -1 if there is no line number. + * Does not raise an exception. */ +PyAPI_FUNC(int) PyUnstable_InterpreterFrame_GetLine(struct _PyInterpreterFrame *frame); + +#define PyUnstable_EXECUTABLE_KIND_SKIP 0 +#define PyUnstable_EXECUTABLE_KIND_PY_FUNCTION 1 +#define PyUnstable_EXECUTABLE_KIND_BUILTIN_FUNCTION 3 +#define PyUnstable_EXECUTABLE_KIND_METHOD_DESCRIPTOR 4 +#define PyUnstable_EXECUTABLE_KINDS 5 + +PyAPI_DATA(const PyTypeObject *) const PyUnstable_ExecutableKinds[PyUnstable_EXECUTABLE_KINDS+1]; diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyhash.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyhash.h new file mode 100644 index 0000000000000000000000000000000000000000..a33ba10b8d3a37c2d9d2a0005a6c976084bd185a --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pyhash.h @@ -0,0 +1,54 @@ +#ifndef Py_CPYTHON_HASH_H +# error "this header file must not be included directly" +#endif + +/* Prime multiplier used in string and various other hashes. */ +#define PyHASH_MULTIPLIER 1000003UL /* 0xf4243 */ + +/* Parameters used for the numeric hash implementation. See notes for + _Py_HashDouble in Python/pyhash.c. Numeric hashes are based on + reduction modulo the prime 2**_PyHASH_BITS - 1. */ + +#if SIZEOF_VOID_P >= 8 +# define PyHASH_BITS 61 +#else +# define PyHASH_BITS 31 +#endif + +#define PyHASH_MODULUS (((size_t)1 << _PyHASH_BITS) - 1) +#define PyHASH_INF 314159 +#define PyHASH_IMAG PyHASH_MULTIPLIER + +/* Aliases kept for backward compatibility with Python 3.12 */ +#define _PyHASH_MULTIPLIER PyHASH_MULTIPLIER +#define _PyHASH_BITS PyHASH_BITS +#define _PyHASH_MODULUS PyHASH_MODULUS +#define _PyHASH_INF PyHASH_INF +#define _PyHASH_IMAG PyHASH_IMAG + +/* Helpers for hash functions */ +PyAPI_FUNC(Py_hash_t) _Py_HashDouble(PyObject *, double); + + +/* hash function definition */ +typedef struct { + Py_hash_t (*const hash)(const void *, Py_ssize_t); + const char *name; + const int hash_bits; + const int seed_bits; +} PyHash_FuncDef; + +PyAPI_FUNC(PyHash_FuncDef*) PyHash_GetFuncDef(void); + +PyAPI_FUNC(Py_hash_t) Py_HashPointer(const void *ptr); + +// Deprecated alias kept for backward compatibility +Py_DEPRECATED(3.14) static inline Py_hash_t +_Py_HashPointer(const void *ptr) +{ + return Py_HashPointer(ptr); +} + +PyAPI_FUNC(Py_hash_t) PyObject_GenericHash(PyObject *); + +PyAPI_FUNC(Py_hash_t) Py_HashBuffer(const void *ptr, Py_ssize_t len); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pylifecycle.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pylifecycle.h new file mode 100644 index 0000000000000000000000000000000000000000..86ce6e6f79824a76aeb0d8c0903d379757c09ece --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pylifecycle.h @@ -0,0 +1,89 @@ +#ifndef Py_CPYTHON_PYLIFECYCLE_H +# error "this header file must not be included directly" +#endif + +/* Py_FrozenMain is kept out of the Limited API until documented and present + in all builds of Python */ +PyAPI_FUNC(int) Py_FrozenMain(int argc, char **argv); + +/* PEP 432 Multi-phase initialization API (Private while provisional!) */ + +PyAPI_FUNC(PyStatus) Py_PreInitialize( + const PyPreConfig *src_config); +PyAPI_FUNC(PyStatus) Py_PreInitializeFromBytesArgs( + const PyPreConfig *src_config, + Py_ssize_t argc, + char **argv); +PyAPI_FUNC(PyStatus) Py_PreInitializeFromArgs( + const PyPreConfig *src_config, + Py_ssize_t argc, + wchar_t **argv); + + +/* Initialization and finalization */ + +PyAPI_FUNC(PyStatus) Py_InitializeFromConfig( + const PyConfig *config); + +PyAPI_FUNC(int) Py_RunMain(void); + + +PyAPI_FUNC(void) _Py_NO_RETURN Py_ExitStatusException(PyStatus err); + +PyAPI_FUNC(int) Py_FdIsInteractive(FILE *, const char *); + +/* --- PyInterpreterConfig ------------------------------------ */ + +#define PyInterpreterConfig_DEFAULT_GIL (0) +#define PyInterpreterConfig_SHARED_GIL (1) +#define PyInterpreterConfig_OWN_GIL (2) + +typedef struct { + // XXX "allow_object_sharing"? "own_objects"? + int use_main_obmalloc; + int allow_fork; + int allow_exec; + int allow_threads; + int allow_daemon_threads; + int check_multi_interp_extensions; + int gil; +} PyInterpreterConfig; + +#define _PyInterpreterConfig_INIT \ + { \ + .use_main_obmalloc = 0, \ + .allow_fork = 0, \ + .allow_exec = 0, \ + .allow_threads = 1, \ + .allow_daemon_threads = 0, \ + .check_multi_interp_extensions = 1, \ + .gil = PyInterpreterConfig_OWN_GIL, \ + } + +// gh-117649: The free-threaded build does not currently support single-phase +// init extensions in subinterpreters. For now, we ensure that +// `check_multi_interp_extensions` is always `1`, even in the legacy config. +#ifdef Py_GIL_DISABLED +# define _PyInterpreterConfig_LEGACY_CHECK_MULTI_INTERP_EXTENSIONS 1 +#else +# define _PyInterpreterConfig_LEGACY_CHECK_MULTI_INTERP_EXTENSIONS 0 +#endif + +#define _PyInterpreterConfig_LEGACY_INIT \ + { \ + .use_main_obmalloc = 1, \ + .allow_fork = 1, \ + .allow_exec = 1, \ + .allow_threads = 1, \ + .allow_daemon_threads = 1, \ + .check_multi_interp_extensions = _PyInterpreterConfig_LEGACY_CHECK_MULTI_INTERP_EXTENSIONS, \ + .gil = PyInterpreterConfig_SHARED_GIL, \ + } + +PyAPI_FUNC(PyStatus) Py_NewInterpreterFromConfig( + PyThreadState **tstate_p, + const PyInterpreterConfig *config); + +typedef void (*atexit_datacallbackfunc)(void *); +PyAPI_FUNC(int) PyUnstable_AtExit( + PyInterpreterState *, atexit_datacallbackfunc, void *); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pymem.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pymem.h new file mode 100644 index 0000000000000000000000000000000000000000..76b3221f7b9f39f50fa60ef6b5777eed5e00dc04 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pymem.h @@ -0,0 +1,84 @@ +#ifndef Py_CPYTHON_PYMEM_H +# error "this header file must not be included directly" +#endif + +typedef enum { + /* PyMem_RawMalloc(), PyMem_RawRealloc() and PyMem_RawFree() */ + PYMEM_DOMAIN_RAW, + + /* PyMem_Malloc(), PyMem_Realloc() and PyMem_Free() */ + PYMEM_DOMAIN_MEM, + + /* PyObject_Malloc(), PyObject_Realloc() and PyObject_Free() */ + PYMEM_DOMAIN_OBJ +} PyMemAllocatorDomain; + +typedef enum { + PYMEM_ALLOCATOR_NOT_SET = 0, + PYMEM_ALLOCATOR_DEFAULT = 1, + PYMEM_ALLOCATOR_DEBUG = 2, + PYMEM_ALLOCATOR_MALLOC = 3, + PYMEM_ALLOCATOR_MALLOC_DEBUG = 4, +#ifdef WITH_PYMALLOC + PYMEM_ALLOCATOR_PYMALLOC = 5, + PYMEM_ALLOCATOR_PYMALLOC_DEBUG = 6, +#endif +#ifdef WITH_MIMALLOC + PYMEM_ALLOCATOR_MIMALLOC = 7, + PYMEM_ALLOCATOR_MIMALLOC_DEBUG = 8, +#endif +} PyMemAllocatorName; + + +typedef struct { + /* user context passed as the first argument to the 4 functions */ + void *ctx; + + /* allocate a memory block */ + void* (*malloc) (void *ctx, size_t size); + + /* allocate a memory block initialized by zeros */ + void* (*calloc) (void *ctx, size_t nelem, size_t elsize); + + /* allocate or resize a memory block */ + void* (*realloc) (void *ctx, void *ptr, size_t new_size); + + /* release a memory block */ + void (*free) (void *ctx, void *ptr); +} PyMemAllocatorEx; + +/* Get the memory block allocator of the specified domain. */ +PyAPI_FUNC(void) PyMem_GetAllocator(PyMemAllocatorDomain domain, + PyMemAllocatorEx *allocator); + +/* Set the memory block allocator of the specified domain. + + The new allocator must return a distinct non-NULL pointer when requesting + zero bytes. + + For the PYMEM_DOMAIN_RAW domain, the allocator must be thread-safe: the GIL + is not held when the allocator is called. + + If the new allocator is not a hook (don't call the previous allocator), the + PyMem_SetupDebugHooks() function must be called to reinstall the debug hooks + on top on the new allocator. */ +PyAPI_FUNC(void) PyMem_SetAllocator(PyMemAllocatorDomain domain, + PyMemAllocatorEx *allocator); + +/* Setup hooks to detect bugs in the following Python memory allocator + functions: + + - PyMem_RawMalloc(), PyMem_RawRealloc(), PyMem_RawFree() + - PyMem_Malloc(), PyMem_Realloc(), PyMem_Free() + - PyObject_Malloc(), PyObject_Realloc() and PyObject_Free() + + Newly allocated memory is filled with the byte 0xCB, freed memory is filled + with the byte 0xDB. Additional checks: + + - detect API violations, ex: PyObject_Free() called on a buffer allocated + by PyMem_Malloc() + - detect write before the start of the buffer (buffer underflow) + - detect write after the end of the buffer (buffer overflow) + + The function does nothing if Python is not compiled is debug mode. */ +PyAPI_FUNC(void) PyMem_SetupDebugHooks(void); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pystate.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pystate.h new file mode 100644 index 0000000000000000000000000000000000000000..c1b97d428e2e9b67482183640344dfcb297e27c9 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pystate.h @@ -0,0 +1,277 @@ +#ifndef Py_CPYTHON_PYSTATE_H +# error "this header file must not be included directly" +#endif + + +/* private interpreter helpers */ + +PyAPI_FUNC(int) _PyInterpreterState_RequiresIDRef(PyInterpreterState *); +PyAPI_FUNC(void) _PyInterpreterState_RequireIDRef(PyInterpreterState *, int); + +/* State unique per thread */ + +/* Py_tracefunc return -1 when raising an exception, or 0 for success. */ +typedef int (*Py_tracefunc)(PyObject *, PyFrameObject *, int, PyObject *); + +/* The following values are used for 'what' for tracefunc functions + * + * To add a new kind of trace event, also update "trace_init" in + * Python/sysmodule.c to define the Python level event name + */ +#define PyTrace_CALL 0 +#define PyTrace_EXCEPTION 1 +#define PyTrace_LINE 2 +#define PyTrace_RETURN 3 +#define PyTrace_C_CALL 4 +#define PyTrace_C_EXCEPTION 5 +#define PyTrace_C_RETURN 6 +#define PyTrace_OPCODE 7 + +/* Remote debugger support */ +#define _Py_MAX_SCRIPT_PATH_SIZE 512 +typedef struct { + int32_t debugger_pending_call; + char debugger_script_path[_Py_MAX_SCRIPT_PATH_SIZE]; +} _PyRemoteDebuggerSupport; + +typedef struct _err_stackitem { + /* This struct represents a single execution context where we might + * be currently handling an exception. It is a per-coroutine state + * (coroutine in the computer science sense, including the thread + * and generators). + * + * This is used as an entry on the exception stack, where each + * entry indicates if it is currently handling an exception. + * This ensures that the exception state is not impacted + * by "yields" from an except handler. The thread + * always has an entry (the bottom-most one). + */ + + /* The exception currently being handled in this context, if any. */ + PyObject *exc_value; + + struct _err_stackitem *previous_item; + +} _PyErr_StackItem; + +typedef struct _stack_chunk { + struct _stack_chunk *previous; + size_t size; + size_t top; + PyObject * data[1]; /* Variable sized */ +} _PyStackChunk; + +/* Minimum size of data stack chunk */ +#define _PY_DATA_STACK_CHUNK_SIZE (16*1024) +struct _ts { + /* See Python/ceval.c for comments explaining most fields */ + + PyThreadState *prev; + PyThreadState *next; + PyInterpreterState *interp; + + /* The global instrumentation version in high bits, plus flags indicating + when to break out of the interpreter loop in lower bits. See details in + pycore_ceval.h. */ + uintptr_t eval_breaker; + + struct { + /* Has been initialized to a safe state. + + In order to be effective, this must be set to 0 during or right + after allocation. */ + unsigned int initialized:1; + + /* Has been bound to an OS thread. */ + unsigned int bound:1; + /* Has been unbound from its OS thread. */ + unsigned int unbound:1; + /* Has been bound aa current for the GILState API. */ + unsigned int bound_gilstate:1; + /* Currently in use (maybe holds the GIL). */ + unsigned int active:1; + + /* various stages of finalization */ + unsigned int finalizing:1; + unsigned int cleared:1; + unsigned int finalized:1; + + /* padding to align to 4 bytes */ + unsigned int :24; + } _status; +#ifdef Py_BUILD_CORE +# define _PyThreadState_WHENCE_NOTSET -1 +# define _PyThreadState_WHENCE_UNKNOWN 0 +# define _PyThreadState_WHENCE_INIT 1 +# define _PyThreadState_WHENCE_FINI 2 +# define _PyThreadState_WHENCE_THREADING 3 +# define _PyThreadState_WHENCE_GILSTATE 4 +# define _PyThreadState_WHENCE_EXEC 5 +#endif + + /* Currently holds the GIL. Must be its own field to avoid data races */ + int holds_gil; + + int _whence; + + /* Thread state (_Py_THREAD_ATTACHED, _Py_THREAD_DETACHED, _Py_THREAD_SUSPENDED). + See Include/internal/pycore_pystate.h for more details. */ + int state; + + int py_recursion_remaining; + int py_recursion_limit; + int recursion_headroom; /* Allow 50 more calls to handle any errors. */ + + /* 'tracing' keeps track of the execution depth when tracing/profiling. + This is to prevent the actual trace/profile code from being recorded in + the trace/profile. */ + int tracing; + int what_event; /* The event currently being monitored, if any. */ + + /* Pointer to currently executing frame. */ + struct _PyInterpreterFrame *current_frame; + + Py_tracefunc c_profilefunc; + Py_tracefunc c_tracefunc; + PyObject *c_profileobj; + PyObject *c_traceobj; + + /* The exception currently being raised */ + PyObject *current_exception; + + /* Pointer to the top of the exception stack for the exceptions + * we may be currently handling. (See _PyErr_StackItem above.) + * This is never NULL. */ + _PyErr_StackItem *exc_info; + + PyObject *dict; /* Stores per-thread state */ + + int gilstate_counter; + + PyObject *async_exc; /* Asynchronous exception to raise */ + unsigned long thread_id; /* Thread id where this tstate was created */ + + /* Native thread id where this tstate was created. This will be 0 except on + * those platforms that have the notion of native thread id, for which the + * macro PY_HAVE_THREAD_NATIVE_ID is then defined. + */ + unsigned long native_thread_id; + + PyObject *delete_later; + + /* Tagged pointer to top-most critical section, or zero if there is no + * active critical section. Critical sections are only used in + * `--disable-gil` builds (i.e., when Py_GIL_DISABLED is defined to 1). In the + * default build, this field is always zero. + */ + uintptr_t critical_section; + + int coroutine_origin_tracking_depth; + + PyObject *async_gen_firstiter; + PyObject *async_gen_finalizer; + + PyObject *context; + uint64_t context_ver; + + /* Unique thread state id. */ + uint64_t id; + + _PyStackChunk *datastack_chunk; + PyObject **datastack_top; + PyObject **datastack_limit; + /* XXX signal handlers should also be here */ + + /* The following fields are here to avoid allocation during init. + The data is exposed through PyThreadState pointer fields. + These fields should not be accessed directly outside of init. + This is indicated by an underscore prefix on the field names. + + All other PyInterpreterState pointer fields are populated when + needed and default to NULL. + */ + // Note some fields do not have a leading underscore for backward + // compatibility. See https://bugs.python.org/issue45953#msg412046. + + /* The thread's exception stack entry. (Always the last entry.) */ + _PyErr_StackItem exc_state; + + PyObject *current_executor; + + uint64_t dict_global_version; + + /* Used to store/retrieve `threading.local` keys/values for this thread */ + PyObject *threading_local_key; + + /* Used by `threading.local`s to be remove keys/values for dying threads. + The PyThreadObject must hold the only reference to this value. + */ + PyObject *threading_local_sentinel; + _PyRemoteDebuggerSupport remote_debugger_support; + + _PyStackChunk *datastack_cached_chunk; +}; + +/* other API */ + +/* Similar to PyThreadState_Get(), but don't issue a fatal error + * if it is NULL. */ +PyAPI_FUNC(PyThreadState *) PyThreadState_GetUnchecked(void); + +// Deprecated alias kept for backward compatibility +Py_DEPRECATED(3.14) static inline PyThreadState* +_PyThreadState_UncheckedGet(void) +{ + return PyThreadState_GetUnchecked(); +} + +// Disable tracing and profiling. +PyAPI_FUNC(void) PyThreadState_EnterTracing(PyThreadState *tstate); + +// Reset tracing and profiling: enable them if a trace function or a profile +// function is set, otherwise disable them. +PyAPI_FUNC(void) PyThreadState_LeaveTracing(PyThreadState *tstate); + +/* PyGILState */ + +/* Helper/diagnostic function - return 1 if the current thread + currently holds the GIL, 0 otherwise. + + The function returns 1 if _PyGILState_check_enabled is non-zero. */ +PyAPI_FUNC(int) PyGILState_Check(void); + +/* The implementation of sys._current_frames() Returns a dict mapping + thread id to that thread's current frame. +*/ +PyAPI_FUNC(PyObject*) _PyThread_CurrentFrames(void); + +// Set the stack protection start address and stack protection size +// of a Python thread state +PyAPI_FUNC(int) PyUnstable_ThreadState_SetStackProtection( + PyThreadState *tstate, + void *stack_start_addr, // Stack start address + size_t stack_size); // Stack size (in bytes) + +// Reset the stack protection start address and stack protection size +// of a Python thread state +PyAPI_FUNC(void) PyUnstable_ThreadState_ResetStackProtection( + PyThreadState *tstate); + +/* Routines for advanced debuggers, requested by David Beazley. + Don't use unless you know what you are doing! */ +PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Main(void); +PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Head(void); +PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Next(PyInterpreterState *); +PyAPI_FUNC(PyThreadState *) PyInterpreterState_ThreadHead(PyInterpreterState *); +PyAPI_FUNC(PyThreadState *) PyThreadState_Next(PyThreadState *); +PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void); + +/* Frame evaluation API */ + +typedef PyObject* (*_PyFrameEvalFunction)(PyThreadState *tstate, struct _PyInterpreterFrame *, int); + +PyAPI_FUNC(_PyFrameEvalFunction) _PyInterpreterState_GetEvalFrameFunc( + PyInterpreterState *interp); +PyAPI_FUNC(void) _PyInterpreterState_SetEvalFrameFunc( + PyInterpreterState *interp, + _PyFrameEvalFunction eval_frame); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pystats.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pystats.h new file mode 100644 index 0000000000000000000000000000000000000000..cf830b6066f4abac07e395fb8a0c67f64ebbcf98 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pystats.h @@ -0,0 +1,194 @@ +// Statistics on Python performance. +// +// API: +// +// - _Py_INCREF_STAT_INC() and _Py_DECREF_STAT_INC() used by Py_INCREF() +// and Py_DECREF(). +// - _Py_stats variable +// +// Functions of the sys module: +// +// - sys._stats_on() +// - sys._stats_off() +// - sys._stats_clear() +// - sys._stats_dump() +// +// Python must be built with ./configure --enable-pystats to define the +// Py_STATS macro. +// +// Define _PY_INTERPRETER macro to increment interpreter_increfs and +// interpreter_decrefs. Otherwise, increment increfs and decrefs. +// +// The number of incref operations counted by `incref` and +// `interpreter_incref` is the number of increment operations, which is +// not equal to the total of all reference counts. A single increment +// operation may increase the reference count of an object by more than +// one. For example, see `_Py_RefcntAdd`. + +#ifndef Py_CPYTHON_PYSTATS_H +# error "this header file must not be included directly" +#endif + +#define PYSTATS_MAX_UOP_ID 1024 + +#define SPECIALIZATION_FAILURE_KINDS 60 + +/* Stats for determining who is calling PyEval_EvalFrame */ +#define EVAL_CALL_TOTAL 0 +#define EVAL_CALL_VECTOR 1 +#define EVAL_CALL_GENERATOR 2 +#define EVAL_CALL_LEGACY 3 +#define EVAL_CALL_FUNCTION_VECTORCALL 4 +#define EVAL_CALL_BUILD_CLASS 5 +#define EVAL_CALL_SLOT 6 +#define EVAL_CALL_FUNCTION_EX 7 +#define EVAL_CALL_API 8 +#define EVAL_CALL_METHOD 9 + +#define EVAL_CALL_KINDS 10 + +typedef struct _specialization_stats { + uint64_t success; + uint64_t failure; + uint64_t hit; + uint64_t deferred; + uint64_t miss; + uint64_t deopt; + uint64_t failure_kinds[SPECIALIZATION_FAILURE_KINDS]; +} SpecializationStats; + +typedef struct _opcode_stats { + SpecializationStats specialization; + uint64_t execution_count; + uint64_t pair_count[256]; +} OpcodeStats; + +typedef struct _call_stats { + uint64_t inlined_py_calls; + uint64_t pyeval_calls; + uint64_t frames_pushed; + uint64_t frame_objects_created; + uint64_t eval_calls[EVAL_CALL_KINDS]; +} CallStats; + +typedef struct _object_stats { + uint64_t increfs; + uint64_t decrefs; + uint64_t interpreter_increfs; + uint64_t interpreter_decrefs; + uint64_t immortal_increfs; + uint64_t immortal_decrefs; + uint64_t interpreter_immortal_increfs; + uint64_t interpreter_immortal_decrefs; + uint64_t allocations; + uint64_t allocations512; + uint64_t allocations4k; + uint64_t allocations_big; + uint64_t frees; + uint64_t to_freelist; + uint64_t from_freelist; + uint64_t inline_values; + uint64_t dict_materialized_on_request; + uint64_t dict_materialized_new_key; + uint64_t dict_materialized_too_big; + uint64_t dict_materialized_str_subclass; + uint64_t type_cache_hits; + uint64_t type_cache_misses; + uint64_t type_cache_dunder_hits; + uint64_t type_cache_dunder_misses; + uint64_t type_cache_collisions; + /* Temporary value used during GC */ + uint64_t object_visits; +} ObjectStats; + +typedef struct _gc_stats { + uint64_t collections; + uint64_t object_visits; + uint64_t objects_collected; + uint64_t objects_transitively_reachable; + uint64_t objects_not_transitively_reachable; +} GCStats; + +typedef struct _uop_stats { + uint64_t execution_count; + uint64_t miss; + uint64_t pair_count[PYSTATS_MAX_UOP_ID + 1]; +} UOpStats; + +#define _Py_UOP_HIST_SIZE 32 + +typedef struct _optimization_stats { + uint64_t attempts; + uint64_t traces_created; + uint64_t traces_executed; + uint64_t uops_executed; + uint64_t trace_stack_overflow; + uint64_t trace_stack_underflow; + uint64_t trace_too_long; + uint64_t trace_too_short; + uint64_t inner_loop; + uint64_t recursive_call; + uint64_t low_confidence; + uint64_t unknown_callee; + uint64_t executors_invalidated; + UOpStats opcode[PYSTATS_MAX_UOP_ID + 1]; + uint64_t unsupported_opcode[256]; + uint64_t trace_length_hist[_Py_UOP_HIST_SIZE]; + uint64_t trace_run_length_hist[_Py_UOP_HIST_SIZE]; + uint64_t optimized_trace_length_hist[_Py_UOP_HIST_SIZE]; + uint64_t optimizer_attempts; + uint64_t optimizer_successes; + uint64_t optimizer_failure_reason_no_memory; + uint64_t remove_globals_builtins_changed; + uint64_t remove_globals_incorrect_keys; + uint64_t error_in_opcode[PYSTATS_MAX_UOP_ID + 1]; + // JIT memory stats + uint64_t jit_total_memory_size; + uint64_t jit_code_size; + uint64_t jit_trampoline_size; + uint64_t jit_data_size; + uint64_t jit_padding_size; + uint64_t jit_freed_memory_size; + uint64_t trace_total_memory_hist[_Py_UOP_HIST_SIZE]; +} OptimizationStats; + +typedef struct _rare_event_stats { + /* Setting an object's class, obj.__class__ = ... */ + uint64_t set_class; + /* Setting the bases of a class, cls.__bases__ = ... */ + uint64_t set_bases; + /* Setting the PEP 523 frame eval function, _PyInterpreterState_SetFrameEvalFunc() */ + uint64_t set_eval_frame_func; + /* Modifying the builtins, __builtins__.__dict__[var] = ... */ + uint64_t builtin_dict; + /* Modifying a function, e.g. func.__defaults__ = ..., etc. */ + uint64_t func_modification; + /* Modifying a dict that is being watched */ + uint64_t watched_dict_modification; + uint64_t watched_globals_modification; +} RareEventStats; + +typedef struct _stats { + OpcodeStats opcode_stats[256]; + CallStats call_stats; + ObjectStats object_stats; + OptimizationStats optimization_stats; + RareEventStats rare_event_stats; + GCStats *gc_stats; +} PyStats; + + +// Export for shared extensions like 'math' +PyAPI_DATA(PyStats*) _Py_stats; + +#ifdef _PY_INTERPRETER +# define _Py_INCREF_STAT_INC() do { if (_Py_stats) _Py_stats->object_stats.interpreter_increfs++; } while (0) +# define _Py_DECREF_STAT_INC() do { if (_Py_stats) _Py_stats->object_stats.interpreter_decrefs++; } while (0) +# define _Py_INCREF_IMMORTAL_STAT_INC() do { if (_Py_stats) _Py_stats->object_stats.interpreter_immortal_increfs++; } while (0) +# define _Py_DECREF_IMMORTAL_STAT_INC() do { if (_Py_stats) _Py_stats->object_stats.interpreter_immortal_decrefs++; } while (0) +#else +# define _Py_INCREF_STAT_INC() do { if (_Py_stats) _Py_stats->object_stats.increfs++; } while (0) +# define _Py_DECREF_STAT_INC() do { if (_Py_stats) _Py_stats->object_stats.decrefs++; } while (0) +# define _Py_INCREF_IMMORTAL_STAT_INC() do { if (_Py_stats) _Py_stats->object_stats.immortal_increfs++; } while (0) +# define _Py_DECREF_IMMORTAL_STAT_INC() do { if (_Py_stats) _Py_stats->object_stats.immortal_decrefs++; } while (0) +#endif diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pythonrun.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pythonrun.h new file mode 100644 index 0000000000000000000000000000000000000000..edc40952254029f8c8f2927f4e3324a14d40fba6 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pythonrun.h @@ -0,0 +1,96 @@ +#ifndef Py_CPYTHON_PYTHONRUN_H +# error "this header file must not be included directly" +#endif + +PyAPI_FUNC(int) PyRun_SimpleStringFlags(const char *, PyCompilerFlags *); +PyAPI_FUNC(int) PyRun_AnyFileExFlags( + FILE *fp, + const char *filename, /* decoded from the filesystem encoding */ + int closeit, + PyCompilerFlags *flags); +PyAPI_FUNC(int) PyRun_SimpleFileExFlags( + FILE *fp, + const char *filename, /* decoded from the filesystem encoding */ + int closeit, + PyCompilerFlags *flags); +PyAPI_FUNC(int) PyRun_InteractiveOneFlags( + FILE *fp, + const char *filename, /* decoded from the filesystem encoding */ + PyCompilerFlags *flags); +PyAPI_FUNC(int) PyRun_InteractiveOneObject( + FILE *fp, + PyObject *filename, + PyCompilerFlags *flags); +PyAPI_FUNC(int) PyRun_InteractiveLoopFlags( + FILE *fp, + const char *filename, /* decoded from the filesystem encoding */ + PyCompilerFlags *flags); + + +PyAPI_FUNC(PyObject *) PyRun_StringFlags(const char *, int, PyObject *, + PyObject *, PyCompilerFlags *); + +PyAPI_FUNC(PyObject *) PyRun_FileExFlags( + FILE *fp, + const char *filename, /* decoded from the filesystem encoding */ + int start, + PyObject *globals, + PyObject *locals, + int closeit, + PyCompilerFlags *flags); + + +PyAPI_FUNC(PyObject *) Py_CompileStringExFlags( + const char *str, + const char *filename, /* decoded from the filesystem encoding */ + int start, + PyCompilerFlags *flags, + int optimize); +PyAPI_FUNC(PyObject *) Py_CompileStringObject( + const char *str, + PyObject *filename, int start, + PyCompilerFlags *flags, + int optimize); + +#define Py_CompileString(str, p, s) Py_CompileStringExFlags((str), (p), (s), NULL, -1) +#define Py_CompileStringFlags(str, p, s, f) Py_CompileStringExFlags((str), (p), (s), (f), -1) + +/* A function flavor is also exported by libpython. It is required when + libpython is accessed directly rather than using header files which defines + macros below. On Windows, for example, PyAPI_FUNC() uses dllexport to + export functions in pythonXX.dll. */ +PyAPI_FUNC(PyObject *) PyRun_String(const char *str, int s, PyObject *g, PyObject *l); +PyAPI_FUNC(int) PyRun_AnyFile(FILE *fp, const char *name); +PyAPI_FUNC(int) PyRun_AnyFileEx(FILE *fp, const char *name, int closeit); +PyAPI_FUNC(int) PyRun_AnyFileFlags(FILE *, const char *, PyCompilerFlags *); +PyAPI_FUNC(int) PyRun_SimpleString(const char *s); +PyAPI_FUNC(int) PyRun_SimpleFile(FILE *f, const char *p); +PyAPI_FUNC(int) PyRun_SimpleFileEx(FILE *f, const char *p, int c); +PyAPI_FUNC(int) PyRun_InteractiveOne(FILE *f, const char *p); +PyAPI_FUNC(int) PyRun_InteractiveLoop(FILE *f, const char *p); +PyAPI_FUNC(PyObject *) PyRun_File(FILE *fp, const char *p, int s, PyObject *g, PyObject *l); +PyAPI_FUNC(PyObject *) PyRun_FileEx(FILE *fp, const char *p, int s, PyObject *g, PyObject *l, int c); +PyAPI_FUNC(PyObject *) PyRun_FileFlags(FILE *fp, const char *p, int s, PyObject *g, PyObject *l, PyCompilerFlags *flags); + +/* Use macros for a bunch of old variants */ +#define PyRun_String(str, s, g, l) PyRun_StringFlags((str), (s), (g), (l), NULL) +#define PyRun_AnyFile(fp, name) PyRun_AnyFileExFlags((fp), (name), 0, NULL) +#define PyRun_AnyFileEx(fp, name, closeit) \ + PyRun_AnyFileExFlags((fp), (name), (closeit), NULL) +#define PyRun_AnyFileFlags(fp, name, flags) \ + PyRun_AnyFileExFlags((fp), (name), 0, (flags)) +#define PyRun_SimpleString(s) PyRun_SimpleStringFlags((s), NULL) +#define PyRun_SimpleFile(f, p) PyRun_SimpleFileExFlags((f), (p), 0, NULL) +#define PyRun_SimpleFileEx(f, p, c) PyRun_SimpleFileExFlags((f), (p), (c), NULL) +#define PyRun_InteractiveOne(f, p) PyRun_InteractiveOneFlags((f), (p), NULL) +#define PyRun_InteractiveLoop(f, p) PyRun_InteractiveLoopFlags((f), (p), NULL) +#define PyRun_File(fp, p, s, g, l) \ + PyRun_FileExFlags((fp), (p), (s), (g), (l), 0, NULL) +#define PyRun_FileEx(fp, p, s, g, l, c) \ + PyRun_FileExFlags((fp), (p), (s), (g), (l), (c), NULL) +#define PyRun_FileFlags(fp, p, s, g, l, flags) \ + PyRun_FileExFlags((fp), (p), (s), (g), (l), 0, (flags)) + +/* Stuff with no proper home (yet) */ +PyAPI_FUNC(char *) PyOS_Readline(FILE *, FILE *, const char *); +PyAPI_DATA(char) *(*PyOS_ReadlineFunctionPointer)(FILE *, FILE *, const char *); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pythread.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pythread.h new file mode 100644 index 0000000000000000000000000000000000000000..e658b35bd90700eb1dabad03497c2b52452db9ff --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pythread.h @@ -0,0 +1,43 @@ +#ifndef Py_CPYTHON_PYTHREAD_H +# error "this header file must not be included directly" +#endif + +// PY_TIMEOUT_MAX is the highest usable value (in microseconds) of PY_TIMEOUT_T +// type, and depends on the system threading API. +// +// NOTE: this isn't the same value as `_thread.TIMEOUT_MAX`. The _thread module +// exposes a higher-level API, with timeouts expressed in seconds and +// floating-point numbers allowed. +PyAPI_DATA(const long long) PY_TIMEOUT_MAX; + +#define PYTHREAD_INVALID_THREAD_ID ((unsigned long)-1) + +#ifdef HAVE_PTHREAD_H + /* Darwin needs pthread.h to know type name the pthread_key_t. */ +# include +# define NATIVE_TSS_KEY_T pthread_key_t +#elif defined(NT_THREADS) + /* In Windows, native TSS key type is DWORD, + but hardcode the unsigned long to avoid errors for include directive. + */ +# define NATIVE_TSS_KEY_T unsigned long +#elif defined(HAVE_PTHREAD_STUBS) +# include "pthread_stubs.h" +# define NATIVE_TSS_KEY_T pthread_key_t +#else +# error "Require native threads. See https://bugs.python.org/issue31370" +#endif + +/* When Py_LIMITED_API is not defined, the type layout of Py_tss_t is + exposed to allow static allocation in the API clients. Even in this case, + you must handle TSS keys through API functions due to compatibility. +*/ +struct _Py_tss_t { + int _is_initialized; + NATIVE_TSS_KEY_T _key; +}; + +#undef NATIVE_TSS_KEY_T + +/* When static allocation, you must initialize with Py_tss_NEEDS_INIT. */ +#define Py_tss_NEEDS_INIT {0} diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pytime.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pytime.h new file mode 100644 index 0000000000000000000000000000000000000000..5c68110aeedb867ba90c8cab047fed1489e083ff --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/pytime.h @@ -0,0 +1,27 @@ +// PyTime_t C API: see Doc/c-api/time.rst for the documentation. + +#ifndef Py_LIMITED_API +#ifndef Py_PYTIME_H +#define Py_PYTIME_H +#ifdef __cplusplus +extern "C" { +#endif + +typedef int64_t PyTime_t; +#define PyTime_MIN INT64_MIN +#define PyTime_MAX INT64_MAX + +PyAPI_FUNC(double) PyTime_AsSecondsDouble(PyTime_t t); +PyAPI_FUNC(int) PyTime_Monotonic(PyTime_t *result); +PyAPI_FUNC(int) PyTime_PerfCounter(PyTime_t *result); +PyAPI_FUNC(int) PyTime_Time(PyTime_t *result); + +PyAPI_FUNC(int) PyTime_MonotonicRaw(PyTime_t *result); +PyAPI_FUNC(int) PyTime_PerfCounterRaw(PyTime_t *result); +PyAPI_FUNC(int) PyTime_TimeRaw(PyTime_t *result); + +#ifdef __cplusplus +} +#endif +#endif /* Py_PYTIME_H */ +#endif /* Py_LIMITED_API */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/setobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/setobject.h new file mode 100644 index 0000000000000000000000000000000000000000..89565cb29212fc172d82e2b5cf52295dcd3a6184 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/setobject.h @@ -0,0 +1,71 @@ +#ifndef Py_CPYTHON_SETOBJECT_H +# error "this header file must not be included directly" +#endif + +/* There are three kinds of entries in the table: + +1. Unused: key == NULL and hash == 0 +2. Dummy: key == dummy and hash == -1 +3. Active: key != NULL and key != dummy and hash != -1 + +The hash field of Unused slots is always zero. + +The hash field of Dummy slots are set to -1 +meaning that dummy entries can be detected by +either entry->key==dummy or by entry->hash==-1. +*/ + +#define PySet_MINSIZE 8 + +typedef struct { + PyObject *key; + Py_hash_t hash; /* Cached hash code of the key */ +} setentry; + +/* The SetObject data structure is shared by set and frozenset objects. + +Invariant for sets: + - hash is -1 + +Invariants for frozensets: + - data is immutable. + - hash is the hash of the frozenset or -1 if not computed yet. + +*/ + +typedef struct { + PyObject_HEAD + + Py_ssize_t fill; /* Number active and dummy entries*/ + Py_ssize_t used; /* Number active entries */ + + /* The table contains mask + 1 slots, and that's a power of 2. + * We store the mask instead of the size because the mask is more + * frequently needed. + */ + Py_ssize_t mask; + + /* The table points to a fixed-size smalltable for small tables + * or to additional malloc'ed memory for bigger tables. + * The table pointer is never NULL which saves us from repeated + * runtime null-tests. + */ + setentry *table; + Py_hash_t hash; /* Only used by frozenset objects */ + Py_ssize_t finger; /* Search finger for pop() */ + + setentry smalltable[PySet_MINSIZE]; + PyObject *weakreflist; /* List of weak references */ +} PySetObject; + +#define _PySet_CAST(so) \ + (assert(PyAnySet_Check(so)), _Py_CAST(PySetObject*, so)) + +static inline Py_ssize_t PySet_GET_SIZE(PyObject *so) { +#ifdef Py_GIL_DISABLED + return _Py_atomic_load_ssize_relaxed(&(_PySet_CAST(so)->used)); +#else + return _PySet_CAST(so)->used; +#endif +} +#define PySet_GET_SIZE(so) PySet_GET_SIZE(_PyObject_CAST(so)) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/traceback.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/traceback.h new file mode 100644 index 0000000000000000000000000000000000000000..81c51944f136f29396699dbcf8a3ddbd5c21b75a --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/traceback.h @@ -0,0 +1,13 @@ +#ifndef Py_CPYTHON_TRACEBACK_H +# error "this header file must not be included directly" +#endif + +typedef struct _traceback PyTracebackObject; + +struct _traceback { + PyObject_HEAD + PyTracebackObject *tb_next; + PyFrameObject *tb_frame; + int tb_lasti; + int tb_lineno; +}; diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/tracemalloc.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/tracemalloc.h new file mode 100644 index 0000000000000000000000000000000000000000..6d094291ae2e906451675b94836919b63a7c29f0 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/tracemalloc.h @@ -0,0 +1,32 @@ +#ifndef Py_LIMITED_API +#ifndef Py_TRACEMALLOC_H +#define Py_TRACEMALLOC_H +#ifdef __cplusplus +extern "C" { +#endif + +/* Track an allocated memory block in the tracemalloc module. + Return 0 on success, return -1 on error (failed to allocate memory to store + the trace). + + Return -2 if tracemalloc is disabled. + + If memory block is already tracked, update the existing trace. */ +PyAPI_FUNC(int) PyTraceMalloc_Track( + unsigned int domain, + uintptr_t ptr, + size_t size); + +/* Untrack an allocated memory block in the tracemalloc module. + Do nothing if the block was not tracked. + + Return -2 if tracemalloc is disabled, otherwise return 0. */ +PyAPI_FUNC(int) PyTraceMalloc_Untrack( + unsigned int domain, + uintptr_t ptr); + +#ifdef __cplusplus +} +#endif +#endif // !Py_TRACEMALLOC_H +#endif // !Py_LIMITED_API diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/tupleobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/tupleobject.h new file mode 100644 index 0000000000000000000000000000000000000000..afb98ccbb81b2de63febb25bb19dce489191f2e2 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/tupleobject.h @@ -0,0 +1,40 @@ +#ifndef Py_CPYTHON_TUPLEOBJECT_H +# error "this header file must not be included directly" +#endif + +typedef struct { + PyObject_VAR_HEAD + /* Cached hash. Initially set to -1. */ + Py_hash_t ob_hash; + /* ob_item contains space for 'ob_size' elements. + Items must normally not be NULL, except during construction when + the tuple is not yet visible outside the function that builds it. */ + PyObject *ob_item[1]; +} PyTupleObject; + +PyAPI_FUNC(int) _PyTuple_Resize(PyObject **, Py_ssize_t); + +/* Cast argument to PyTupleObject* type. */ +#define _PyTuple_CAST(op) \ + (assert(PyTuple_Check(op)), _Py_CAST(PyTupleObject*, (op))) + +// Macros and static inline functions, trading safety for speed + +static inline Py_ssize_t PyTuple_GET_SIZE(PyObject *op) { + PyTupleObject *tuple = _PyTuple_CAST(op); + return Py_SIZE(tuple); +} +#define PyTuple_GET_SIZE(op) PyTuple_GET_SIZE(_PyObject_CAST(op)) + +#define PyTuple_GET_ITEM(op, index) (_PyTuple_CAST(op)->ob_item[(index)]) + +/* Function *only* to be used to fill in brand new tuples */ +static inline void +PyTuple_SET_ITEM(PyObject *op, Py_ssize_t index, PyObject *value) { + PyTupleObject *tuple = _PyTuple_CAST(op); + assert(0 <= index); + assert(index < Py_SIZE(tuple)); + tuple->ob_item[index] = value; +} +#define PyTuple_SET_ITEM(op, index, value) \ + PyTuple_SET_ITEM(_PyObject_CAST(op), (index), _PyObject_CAST(value)) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/unicodeobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/unicodeobject.h new file mode 100644 index 0000000000000000000000000000000000000000..3d0414f5291fe457929d73d1fa71196c334c740e --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/unicodeobject.h @@ -0,0 +1,773 @@ +#ifndef Py_CPYTHON_UNICODEOBJECT_H +# error "this header file must not be included directly" +#endif + +/* Py_UNICODE was the native Unicode storage format (code unit) used by + Python and represents a single Unicode element in the Unicode type. + With PEP 393, Py_UNICODE is deprecated and replaced with a + typedef to wchar_t. */ +Py_DEPRECATED(3.13) typedef wchar_t PY_UNICODE_TYPE; +Py_DEPRECATED(3.13) typedef wchar_t Py_UNICODE; + + +/* --- Internal Unicode Operations ---------------------------------------- */ + +// Static inline functions to work with surrogates +static inline int Py_UNICODE_IS_SURROGATE(Py_UCS4 ch) { + return (0xD800 <= ch && ch <= 0xDFFF); +} +static inline int Py_UNICODE_IS_HIGH_SURROGATE(Py_UCS4 ch) { + return (0xD800 <= ch && ch <= 0xDBFF); +} +static inline int Py_UNICODE_IS_LOW_SURROGATE(Py_UCS4 ch) { + return (0xDC00 <= ch && ch <= 0xDFFF); +} + +// Join two surrogate characters and return a single Py_UCS4 value. +static inline Py_UCS4 Py_UNICODE_JOIN_SURROGATES(Py_UCS4 high, Py_UCS4 low) { + assert(Py_UNICODE_IS_HIGH_SURROGATE(high)); + assert(Py_UNICODE_IS_LOW_SURROGATE(low)); + return 0x10000 + (((high & 0x03FF) << 10) | (low & 0x03FF)); +} + +// High surrogate = top 10 bits added to 0xD800. +// The character must be in the range [U+10000; U+10ffff]. +static inline Py_UCS4 Py_UNICODE_HIGH_SURROGATE(Py_UCS4 ch) { + assert(0x10000 <= ch && ch <= 0x10ffff); + return (0xD800 - (0x10000 >> 10) + (ch >> 10)); +} + +// Low surrogate = bottom 10 bits added to 0xDC00. +// The character must be in the range [U+10000; U+10ffff]. +static inline Py_UCS4 Py_UNICODE_LOW_SURROGATE(Py_UCS4 ch) { + assert(0x10000 <= ch && ch <= 0x10ffff); + return (0xDC00 + (ch & 0x3FF)); +} + + +/* --- Unicode Type ------------------------------------------------------- */ + +/* ASCII-only strings created through PyUnicode_New use the PyASCIIObject + structure. state.ascii and state.compact are set, and the data + immediately follow the structure. utf8_length can be found + in the length field; the utf8 pointer is equal to the data pointer. */ +typedef struct { + /* There are 4 forms of Unicode strings: + + - compact ascii: + + * structure = PyASCIIObject + * test: PyUnicode_IS_COMPACT_ASCII(op) + * kind = PyUnicode_1BYTE_KIND + * compact = 1 + * ascii = 1 + * (length is the length of the utf8) + * (data starts just after the structure) + * (since ASCII is decoded from UTF-8, the utf8 string are the data) + + - compact: + + * structure = PyCompactUnicodeObject + * test: PyUnicode_IS_COMPACT(op) && !PyUnicode_IS_ASCII(op) + * kind = PyUnicode_1BYTE_KIND, PyUnicode_2BYTE_KIND or + PyUnicode_4BYTE_KIND + * compact = 1 + * ascii = 0 + * utf8 is not shared with data + * utf8_length = 0 if utf8 is NULL + * (data starts just after the structure) + + - legacy string: + + * structure = PyUnicodeObject structure + * test: !PyUnicode_IS_COMPACT(op) + * kind = PyUnicode_1BYTE_KIND, PyUnicode_2BYTE_KIND or + PyUnicode_4BYTE_KIND + * compact = 0 + * data.any is not NULL + * utf8 is shared and utf8_length = length with data.any if ascii = 1 + * utf8_length = 0 if utf8 is NULL + + Compact strings use only one memory block (structure + characters), + whereas legacy strings use one block for the structure and one block + for characters. + + Legacy strings are created by subclasses of Unicode. + + See also _PyUnicode_CheckConsistency(). + */ + PyObject_HEAD + Py_ssize_t length; /* Number of code points in the string */ + Py_hash_t hash; /* Hash value; -1 if not set */ +#ifdef Py_GIL_DISABLED + /* Ensure 4 byte alignment for PyUnicode_DATA(), see gh-63736 on m68k. + In the non-free-threaded build, we'll use explicit padding instead */ + _Py_ALIGN_AS(4) +#endif + struct { + /* If interned is non-zero, the two references from the + dictionary to this object are *not* counted in ob_refcnt. + The possible values here are: + 0: Not Interned + 1: Interned + 2: Interned and Immortal + 3: Interned, Immortal, and Static + This categorization allows the runtime to determine the right + cleanup mechanism at runtime shutdown. */ +#ifdef Py_GIL_DISABLED + // Needs to be accessed atomically, so can't be a bit field. + unsigned char interned; +#else + unsigned int interned:2; +#endif + /* Character size: + + - PyUnicode_1BYTE_KIND (1): + + * character type = Py_UCS1 (8 bits, unsigned) + * all characters are in the range U+0000-U+00FF (latin1) + * if ascii is set, all characters are in the range U+0000-U+007F + (ASCII), otherwise at least one character is in the range + U+0080-U+00FF + + - PyUnicode_2BYTE_KIND (2): + + * character type = Py_UCS2 (16 bits, unsigned) + * all characters are in the range U+0000-U+FFFF (BMP) + * at least one character is in the range U+0100-U+FFFF + + - PyUnicode_4BYTE_KIND (4): + + * character type = Py_UCS4 (32 bits, unsigned) + * all characters are in the range U+0000-U+10FFFF + * at least one character is in the range U+10000-U+10FFFF + */ + unsigned int kind:3; + /* Compact is with respect to the allocation scheme. Compact unicode + objects only require one memory block while non-compact objects use + one block for the PyUnicodeObject struct and another for its data + buffer. */ + unsigned int compact:1; + /* The string only contains characters in the range U+0000-U+007F (ASCII) + and the kind is PyUnicode_1BYTE_KIND. If ascii is set and compact is + set, use the PyASCIIObject structure. */ + unsigned int ascii:1; + /* The object is statically allocated. */ + unsigned int statically_allocated:1; +#ifndef Py_GIL_DISABLED + /* Padding to ensure that PyUnicode_DATA() is always aligned to + 4 bytes (see issue gh-63736 on m68k) */ + unsigned int :24; +#endif + } state; +} PyASCIIObject; + +/* Non-ASCII strings allocated through PyUnicode_New use the + PyCompactUnicodeObject structure. state.compact is set, and the data + immediately follow the structure. */ +typedef struct { + PyASCIIObject _base; + Py_ssize_t utf8_length; /* Number of bytes in utf8, excluding the + * terminating \0. */ + char *utf8; /* UTF-8 representation (null-terminated) */ +} PyCompactUnicodeObject; + +/* Object format for Unicode subclasses. */ +typedef struct { + PyCompactUnicodeObject _base; + union { + void *any; + Py_UCS1 *latin1; + Py_UCS2 *ucs2; + Py_UCS4 *ucs4; + } data; /* Canonical, smallest-form Unicode buffer */ +} PyUnicodeObject; + + +#define _PyASCIIObject_CAST(op) \ + (assert(PyUnicode_Check(op)), \ + _Py_CAST(PyASCIIObject*, (op))) +#define _PyCompactUnicodeObject_CAST(op) \ + (assert(PyUnicode_Check(op)), \ + _Py_CAST(PyCompactUnicodeObject*, (op))) +#define _PyUnicodeObject_CAST(op) \ + (assert(PyUnicode_Check(op)), \ + _Py_CAST(PyUnicodeObject*, (op))) + + +/* --- Flexible String Representation Helper Macros (PEP 393) -------------- */ + +/* Values for PyASCIIObject.state: */ + +/* Interning state. */ +#define SSTATE_NOT_INTERNED 0 +#define SSTATE_INTERNED_MORTAL 1 +#define SSTATE_INTERNED_IMMORTAL 2 +#define SSTATE_INTERNED_IMMORTAL_STATIC 3 + +/* Use only if you know it's a string */ +static inline unsigned int PyUnicode_CHECK_INTERNED(PyObject *op) { +#ifdef Py_GIL_DISABLED + return _Py_atomic_load_uint8_relaxed(&_PyASCIIObject_CAST(op)->state.interned); +#else + return _PyASCIIObject_CAST(op)->state.interned; +#endif +} +#define PyUnicode_CHECK_INTERNED(op) PyUnicode_CHECK_INTERNED(_PyObject_CAST(op)) + +/* For backward compatibility. Soft-deprecated. */ +static inline unsigned int PyUnicode_IS_READY(PyObject* Py_UNUSED(op)) { + return 1; +} +#define PyUnicode_IS_READY(op) PyUnicode_IS_READY(_PyObject_CAST(op)) + +/* Return true if the string contains only ASCII characters, or 0 if not. The + string may be compact (PyUnicode_IS_COMPACT_ASCII) or not. */ +static inline unsigned int PyUnicode_IS_ASCII(PyObject *op) { + return _PyASCIIObject_CAST(op)->state.ascii; +} +#define PyUnicode_IS_ASCII(op) PyUnicode_IS_ASCII(_PyObject_CAST(op)) + +/* Return true if the string is compact or 0 if not. + No type checks are performed. */ +static inline unsigned int PyUnicode_IS_COMPACT(PyObject *op) { + return _PyASCIIObject_CAST(op)->state.compact; +} +#define PyUnicode_IS_COMPACT(op) PyUnicode_IS_COMPACT(_PyObject_CAST(op)) + +/* Return true if the string is a compact ASCII string (use PyASCIIObject + structure), or 0 if not. No type checks are performed. */ +static inline int PyUnicode_IS_COMPACT_ASCII(PyObject *op) { + return (_PyASCIIObject_CAST(op)->state.ascii && PyUnicode_IS_COMPACT(op)); +} +#define PyUnicode_IS_COMPACT_ASCII(op) PyUnicode_IS_COMPACT_ASCII(_PyObject_CAST(op)) + +enum PyUnicode_Kind { +/* Return values of the PyUnicode_KIND() function: */ + PyUnicode_1BYTE_KIND = 1, + PyUnicode_2BYTE_KIND = 2, + PyUnicode_4BYTE_KIND = 4 +}; + +PyAPI_FUNC(int) PyUnicode_KIND(PyObject *op); + +// PyUnicode_KIND(): Return one of the PyUnicode_*_KIND values defined above. +// +// gh-89653: Converting this macro to a static inline function would introduce +// new compiler warnings on "kind < PyUnicode_KIND(str)" (compare signed and +// unsigned numbers) where kind type is an int or on +// "unsigned int kind = PyUnicode_KIND(str)" (cast signed to unsigned). +#define PyUnicode_KIND(op) _Py_RVALUE(_PyASCIIObject_CAST(op)->state.kind) + +/* Return a void pointer to the raw unicode buffer. */ +static inline void* _PyUnicode_COMPACT_DATA(PyObject *op) { + if (PyUnicode_IS_ASCII(op)) { + return _Py_STATIC_CAST(void*, (_PyASCIIObject_CAST(op) + 1)); + } + return _Py_STATIC_CAST(void*, (_PyCompactUnicodeObject_CAST(op) + 1)); +} + +static inline void* _PyUnicode_NONCOMPACT_DATA(PyObject *op) { + void *data; + assert(!PyUnicode_IS_COMPACT(op)); + data = _PyUnicodeObject_CAST(op)->data.any; + assert(data != NULL); + return data; +} + +PyAPI_FUNC(void*) PyUnicode_DATA(PyObject *op); + +static inline void* _PyUnicode_DATA(PyObject *op) { + if (PyUnicode_IS_COMPACT(op)) { + return _PyUnicode_COMPACT_DATA(op); + } + return _PyUnicode_NONCOMPACT_DATA(op); +} +#define PyUnicode_DATA(op) _PyUnicode_DATA(_PyObject_CAST(op)) + +/* Return pointers to the canonical representation cast to unsigned char, + Py_UCS2, or Py_UCS4 for direct character access. + No checks are performed, use PyUnicode_KIND() before to ensure + these will work correctly. */ + +#define PyUnicode_1BYTE_DATA(op) _Py_STATIC_CAST(Py_UCS1*, PyUnicode_DATA(op)) +#define PyUnicode_2BYTE_DATA(op) _Py_STATIC_CAST(Py_UCS2*, PyUnicode_DATA(op)) +#define PyUnicode_4BYTE_DATA(op) _Py_STATIC_CAST(Py_UCS4*, PyUnicode_DATA(op)) + +/* Returns the length of the unicode string. */ +static inline Py_ssize_t PyUnicode_GET_LENGTH(PyObject *op) { + return _PyASCIIObject_CAST(op)->length; +} +#define PyUnicode_GET_LENGTH(op) PyUnicode_GET_LENGTH(_PyObject_CAST(op)) + +/* Write into the canonical representation, this function does not do any sanity + checks and is intended for usage in loops. The caller should cache the + kind and data pointers obtained from other function calls. + index is the index in the string (starts at 0) and value is the new + code point value which should be written to that location. */ +static inline void PyUnicode_WRITE(int kind, void *data, + Py_ssize_t index, Py_UCS4 value) +{ + assert(index >= 0); + if (kind == PyUnicode_1BYTE_KIND) { + assert(value <= 0xffU); + _Py_STATIC_CAST(Py_UCS1*, data)[index] = _Py_STATIC_CAST(Py_UCS1, value); + } + else if (kind == PyUnicode_2BYTE_KIND) { + assert(value <= 0xffffU); + _Py_STATIC_CAST(Py_UCS2*, data)[index] = _Py_STATIC_CAST(Py_UCS2, value); + } + else { + assert(kind == PyUnicode_4BYTE_KIND); + assert(value <= 0x10ffffU); + _Py_STATIC_CAST(Py_UCS4*, data)[index] = value; + } +} +#define PyUnicode_WRITE(kind, data, index, value) \ + PyUnicode_WRITE(_Py_STATIC_CAST(int, kind), _Py_CAST(void*, data), \ + (index), _Py_STATIC_CAST(Py_UCS4, value)) + +/* Read a code point from the string's canonical representation. No checks + are performed. */ +static inline Py_UCS4 PyUnicode_READ(int kind, + const void *data, Py_ssize_t index) +{ + assert(index >= 0); + if (kind == PyUnicode_1BYTE_KIND) { + return _Py_STATIC_CAST(const Py_UCS1*, data)[index]; + } + if (kind == PyUnicode_2BYTE_KIND) { + return _Py_STATIC_CAST(const Py_UCS2*, data)[index]; + } + assert(kind == PyUnicode_4BYTE_KIND); + return _Py_STATIC_CAST(const Py_UCS4*, data)[index]; +} +#define PyUnicode_READ(kind, data, index) \ + PyUnicode_READ(_Py_STATIC_CAST(int, kind), \ + _Py_STATIC_CAST(const void*, data), \ + (index)) + +/* PyUnicode_READ_CHAR() is less efficient than PyUnicode_READ() because it + calls PyUnicode_KIND() and might call it twice. For single reads, use + PyUnicode_READ_CHAR, for multiple consecutive reads callers should + cache kind and use PyUnicode_READ instead. */ +static inline Py_UCS4 PyUnicode_READ_CHAR(PyObject *unicode, Py_ssize_t index) +{ + int kind; + + assert(index >= 0); + // Tolerate reading the NUL character at str[len(str)] + assert(index <= PyUnicode_GET_LENGTH(unicode)); + + kind = PyUnicode_KIND(unicode); + if (kind == PyUnicode_1BYTE_KIND) { + return PyUnicode_1BYTE_DATA(unicode)[index]; + } + if (kind == PyUnicode_2BYTE_KIND) { + return PyUnicode_2BYTE_DATA(unicode)[index]; + } + assert(kind == PyUnicode_4BYTE_KIND); + return PyUnicode_4BYTE_DATA(unicode)[index]; +} +#define PyUnicode_READ_CHAR(unicode, index) \ + PyUnicode_READ_CHAR(_PyObject_CAST(unicode), (index)) + +/* Return a maximum character value which is suitable for creating another + string based on op. This is always an approximation but more efficient + than iterating over the string. */ +static inline Py_UCS4 PyUnicode_MAX_CHAR_VALUE(PyObject *op) +{ + int kind; + + if (PyUnicode_IS_ASCII(op)) { + return 0x7fU; + } + + kind = PyUnicode_KIND(op); + if (kind == PyUnicode_1BYTE_KIND) { + return 0xffU; + } + if (kind == PyUnicode_2BYTE_KIND) { + return 0xffffU; + } + assert(kind == PyUnicode_4BYTE_KIND); + return 0x10ffffU; +} +#define PyUnicode_MAX_CHAR_VALUE(op) \ + PyUnicode_MAX_CHAR_VALUE(_PyObject_CAST(op)) + + +/* === Public API ========================================================= */ + +/* With PEP 393, this is the recommended way to allocate a new unicode object. + This function will allocate the object and its buffer in a single memory + block. Objects created using this function are not resizable. */ +PyAPI_FUNC(PyObject*) PyUnicode_New( + Py_ssize_t size, /* Number of code points in the new string */ + Py_UCS4 maxchar /* maximum code point value in the string */ + ); + +/* For backward compatibility. Soft-deprecated. */ +static inline int PyUnicode_READY(PyObject* Py_UNUSED(op)) +{ + return 0; +} +#define PyUnicode_READY(op) PyUnicode_READY(_PyObject_CAST(op)) + +/* Copy character from one unicode object into another, this function performs + character conversion when necessary and falls back to memcpy() if possible. + + Fail if to is too small (smaller than *how_many* or smaller than + len(from)-from_start), or if kind(from[from_start:from_start+how_many]) > + kind(to), or if *to* has more than 1 reference. + + Return the number of written character, or return -1 and raise an exception + on error. + + Pseudo-code: + + how_many = min(how_many, len(from) - from_start) + to[to_start:to_start+how_many] = from[from_start:from_start+how_many] + return how_many + + Note: The function doesn't write a terminating null character. + */ +PyAPI_FUNC(Py_ssize_t) PyUnicode_CopyCharacters( + PyObject *to, + Py_ssize_t to_start, + PyObject *from, + Py_ssize_t from_start, + Py_ssize_t how_many + ); + +/* Fill a string with a character: write fill_char into + unicode[start:start+length]. + + Fail if fill_char is bigger than the string maximum character, or if the + string has more than 1 reference. + + Return the number of written character, or return -1 and raise an exception + on error. */ +PyAPI_FUNC(Py_ssize_t) PyUnicode_Fill( + PyObject *unicode, + Py_ssize_t start, + Py_ssize_t length, + Py_UCS4 fill_char + ); + +/* Create a new string from a buffer of Py_UCS1, Py_UCS2 or Py_UCS4 characters. + Scan the string to find the maximum character. */ +PyAPI_FUNC(PyObject*) PyUnicode_FromKindAndData( + int kind, + const void *buffer, + Py_ssize_t size); + + +/* --- Public PyUnicodeWriter API ----------------------------------------- */ + +typedef struct PyUnicodeWriter PyUnicodeWriter; + +PyAPI_FUNC(PyUnicodeWriter*) PyUnicodeWriter_Create(Py_ssize_t length); +PyAPI_FUNC(void) PyUnicodeWriter_Discard(PyUnicodeWriter *writer); +PyAPI_FUNC(PyObject*) PyUnicodeWriter_Finish(PyUnicodeWriter *writer); + +PyAPI_FUNC(int) PyUnicodeWriter_WriteChar( + PyUnicodeWriter *writer, + Py_UCS4 ch); +PyAPI_FUNC(int) PyUnicodeWriter_WriteUTF8( + PyUnicodeWriter *writer, + const char *str, + Py_ssize_t size); +PyAPI_FUNC(int) PyUnicodeWriter_WriteASCII( + PyUnicodeWriter *writer, + const char *str, + Py_ssize_t size); +PyAPI_FUNC(int) PyUnicodeWriter_WriteWideChar( + PyUnicodeWriter *writer, + const wchar_t *str, + Py_ssize_t size); +PyAPI_FUNC(int) PyUnicodeWriter_WriteUCS4( + PyUnicodeWriter *writer, + Py_UCS4 *str, + Py_ssize_t size); + +PyAPI_FUNC(int) PyUnicodeWriter_WriteStr( + PyUnicodeWriter *writer, + PyObject *obj); +PyAPI_FUNC(int) PyUnicodeWriter_WriteRepr( + PyUnicodeWriter *writer, + PyObject *obj); +PyAPI_FUNC(int) PyUnicodeWriter_WriteSubstring( + PyUnicodeWriter *writer, + PyObject *str, + Py_ssize_t start, + Py_ssize_t end); +PyAPI_FUNC(int) PyUnicodeWriter_Format( + PyUnicodeWriter *writer, + const char *format, + ...); +PyAPI_FUNC(int) PyUnicodeWriter_DecodeUTF8Stateful( + PyUnicodeWriter *writer, + const char *string, /* UTF-8 encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors, /* error handling */ + Py_ssize_t *consumed); /* bytes consumed */ + + +/* --- Private _PyUnicodeWriter API --------------------------------------- */ + +typedef struct { + PyObject *buffer; + void *data; + int kind; + Py_UCS4 maxchar; + Py_ssize_t size; + Py_ssize_t pos; + + /* minimum number of allocated characters (default: 0) */ + Py_ssize_t min_length; + + /* minimum character (default: 127, ASCII) */ + Py_UCS4 min_char; + + /* If non-zero, overallocate the buffer (default: 0). */ + unsigned char overallocate; + + /* If readonly is 1, buffer is a shared string (cannot be modified) + and size is set to 0. */ + unsigned char readonly; +} _PyUnicodeWriter; + +// Initialize a Unicode writer. +// +// By default, the minimum buffer size is 0 character and overallocation is +// disabled. Set min_length, min_char and overallocate attributes to control +// the allocation of the buffer. +_Py_DEPRECATED_EXTERNALLY(3.14) PyAPI_FUNC(void) _PyUnicodeWriter_Init( + _PyUnicodeWriter *writer); + +/* Prepare the buffer to write 'length' characters + with the specified maximum character. + + Return 0 on success, raise an exception and return -1 on error. */ +#define _PyUnicodeWriter_Prepare(WRITER, LENGTH, MAXCHAR) \ + (((MAXCHAR) <= (WRITER)->maxchar \ + && (LENGTH) <= (WRITER)->size - (WRITER)->pos) \ + ? 0 \ + : (((LENGTH) == 0) \ + ? 0 \ + : _PyUnicodeWriter_PrepareInternal((WRITER), (LENGTH), (MAXCHAR)))) + +/* Don't call this function directly, use the _PyUnicodeWriter_Prepare() macro + instead. */ +_Py_DEPRECATED_EXTERNALLY(3.14) PyAPI_FUNC(int) _PyUnicodeWriter_PrepareInternal( + _PyUnicodeWriter *writer, + Py_ssize_t length, + Py_UCS4 maxchar); + +/* Prepare the buffer to have at least the kind KIND. + For example, kind=PyUnicode_2BYTE_KIND ensures that the writer will + support characters in range U+000-U+FFFF. + + Return 0 on success, raise an exception and return -1 on error. */ +#define _PyUnicodeWriter_PrepareKind(WRITER, KIND) \ + ((KIND) <= (WRITER)->kind \ + ? 0 \ + : _PyUnicodeWriter_PrepareKindInternal((WRITER), (KIND))) + +/* Don't call this function directly, use the _PyUnicodeWriter_PrepareKind() + macro instead. */ +_Py_DEPRECATED_EXTERNALLY(3.14) PyAPI_FUNC(int) _PyUnicodeWriter_PrepareKindInternal( + _PyUnicodeWriter *writer, + int kind); + +/* Append a Unicode character. + Return 0 on success, raise an exception and return -1 on error. */ +_Py_DEPRECATED_EXTERNALLY(3.14) PyAPI_FUNC(int) _PyUnicodeWriter_WriteChar( + _PyUnicodeWriter *writer, + Py_UCS4 ch); + +/* Append a Unicode string. + Return 0 on success, raise an exception and return -1 on error. */ +_Py_DEPRECATED_EXTERNALLY(3.14) PyAPI_FUNC(int) _PyUnicodeWriter_WriteStr( + _PyUnicodeWriter *writer, + PyObject *str); /* Unicode string */ + +/* Append a substring of a Unicode string. + Return 0 on success, raise an exception and return -1 on error. */ +_Py_DEPRECATED_EXTERNALLY(3.14) PyAPI_FUNC(int) _PyUnicodeWriter_WriteSubstring( + _PyUnicodeWriter *writer, + PyObject *str, /* Unicode string */ + Py_ssize_t start, + Py_ssize_t end); + +/* Append an ASCII-encoded byte string. + Return 0 on success, raise an exception and return -1 on error. */ +_Py_DEPRECATED_EXTERNALLY(3.14) PyAPI_FUNC(int) _PyUnicodeWriter_WriteASCIIString( + _PyUnicodeWriter *writer, + const char *str, /* ASCII-encoded byte string */ + Py_ssize_t len); /* number of bytes, or -1 if unknown */ + +/* Append a latin1-encoded byte string. + Return 0 on success, raise an exception and return -1 on error. */ +_Py_DEPRECATED_EXTERNALLY(3.14) PyAPI_FUNC(int) _PyUnicodeWriter_WriteLatin1String( + _PyUnicodeWriter *writer, + const char *str, /* latin1-encoded byte string */ + Py_ssize_t len); /* length in bytes */ + +/* Get the value of the writer as a Unicode string. Clear the + buffer of the writer. Raise an exception and return NULL + on error. */ +_Py_DEPRECATED_EXTERNALLY(3.14) PyAPI_FUNC(PyObject *) _PyUnicodeWriter_Finish( + _PyUnicodeWriter *writer); + +/* Deallocate memory of a writer (clear its internal buffer). */ +_Py_DEPRECATED_EXTERNALLY(3.14) PyAPI_FUNC(void) _PyUnicodeWriter_Dealloc( + _PyUnicodeWriter *writer); + + +/* --- Manage the default encoding ---------------------------------------- */ + +/* Returns a pointer to the default encoding (UTF-8) of the + Unicode object unicode. + + Like PyUnicode_AsUTF8AndSize(), this also caches the UTF-8 representation + in the unicodeobject. + + _PyUnicode_AsString is a #define for PyUnicode_AsUTF8 to + support the previous internal function with the same behaviour. + + Use of this API is DEPRECATED since no size information can be + extracted from the returned data. +*/ + +PyAPI_FUNC(const char *) PyUnicode_AsUTF8(PyObject *unicode); + +// Deprecated alias kept for backward compatibility +Py_DEPRECATED(3.14) static inline const char* +_PyUnicode_AsString(PyObject *unicode) +{ + return PyUnicode_AsUTF8(unicode); +} + + +/* === Characters Type APIs =============================================== */ + +/* These should not be used directly. Use the Py_UNICODE_IS* and + Py_UNICODE_TO* macros instead. + + These APIs are implemented in Objects/unicodectype.c. + +*/ + +PyAPI_FUNC(int) _PyUnicode_IsLowercase( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_IsUppercase( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_IsTitlecase( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_IsWhitespace( + const Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_IsLinebreak( + const Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(Py_UCS4) _PyUnicode_ToLowercase( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(Py_UCS4) _PyUnicode_ToUppercase( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(Py_UCS4) _PyUnicode_ToTitlecase( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_ToDecimalDigit( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_ToDigit( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(double) _PyUnicode_ToNumeric( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_IsDecimalDigit( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_IsDigit( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_IsNumeric( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_IsPrintable( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_IsAlpha( + Py_UCS4 ch /* Unicode character */ + ); + +// Helper array used by Py_UNICODE_ISSPACE(). +PyAPI_DATA(const unsigned char) _Py_ascii_whitespace[]; + +// Since splitting on whitespace is an important use case, and +// whitespace in most situations is solely ASCII whitespace, we +// optimize for the common case by using a quick look-up table +// _Py_ascii_whitespace (see below) with an inlined check. +static inline int Py_UNICODE_ISSPACE(Py_UCS4 ch) { + if (ch < 128) { + return _Py_ascii_whitespace[ch]; + } + return _PyUnicode_IsWhitespace(ch); +} + +#define Py_UNICODE_ISLOWER(ch) _PyUnicode_IsLowercase(ch) +#define Py_UNICODE_ISUPPER(ch) _PyUnicode_IsUppercase(ch) +#define Py_UNICODE_ISTITLE(ch) _PyUnicode_IsTitlecase(ch) +#define Py_UNICODE_ISLINEBREAK(ch) _PyUnicode_IsLinebreak(ch) + +#define Py_UNICODE_TOLOWER(ch) _PyUnicode_ToLowercase(ch) +#define Py_UNICODE_TOUPPER(ch) _PyUnicode_ToUppercase(ch) +#define Py_UNICODE_TOTITLE(ch) _PyUnicode_ToTitlecase(ch) + +#define Py_UNICODE_ISDECIMAL(ch) _PyUnicode_IsDecimalDigit(ch) +#define Py_UNICODE_ISDIGIT(ch) _PyUnicode_IsDigit(ch) +#define Py_UNICODE_ISNUMERIC(ch) _PyUnicode_IsNumeric(ch) +#define Py_UNICODE_ISPRINTABLE(ch) _PyUnicode_IsPrintable(ch) + +#define Py_UNICODE_TODECIMAL(ch) _PyUnicode_ToDecimalDigit(ch) +#define Py_UNICODE_TODIGIT(ch) _PyUnicode_ToDigit(ch) +#define Py_UNICODE_TONUMERIC(ch) _PyUnicode_ToNumeric(ch) + +#define Py_UNICODE_ISALPHA(ch) _PyUnicode_IsAlpha(ch) + +static inline int Py_UNICODE_ISALNUM(Py_UCS4 ch) { + return (Py_UNICODE_ISALPHA(ch) + || Py_UNICODE_ISDECIMAL(ch) + || Py_UNICODE_ISDIGIT(ch) + || Py_UNICODE_ISNUMERIC(ch)); +} + + +/* === Misc functions ===================================================== */ + +// Return an interned Unicode object for an Identifier; may fail if there is no +// memory. +PyAPI_FUNC(PyObject*) _PyUnicode_FromId(_Py_Identifier*); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/warnings.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/warnings.h new file mode 100644 index 0000000000000000000000000000000000000000..4e3eb88e8ff4472b37f1903184097757271d6c5b --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/warnings.h @@ -0,0 +1,20 @@ +#ifndef Py_CPYTHON_WARNINGS_H +# error "this header file must not be included directly" +#endif + +PyAPI_FUNC(int) PyErr_WarnExplicitObject( + PyObject *category, + PyObject *message, + PyObject *filename, + int lineno, + PyObject *module, + PyObject *registry); + +PyAPI_FUNC(int) PyErr_WarnExplicitFormat( + PyObject *category, + const char *filename, int lineno, + const char *module, PyObject *registry, + const char *format, ...); + +// DEPRECATED: Use PyErr_WarnEx() instead. +#define PyErr_Warn(category, msg) PyErr_WarnEx((category), (msg), 1) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/weakrefobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/weakrefobject.h new file mode 100644 index 0000000000000000000000000000000000000000..da8e77cddaca63823c65e577b0b23f664bf4a32a --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/cpython/weakrefobject.h @@ -0,0 +1,66 @@ +#ifndef Py_CPYTHON_WEAKREFOBJECT_H +# error "this header file must not be included directly" +#endif + +/* PyWeakReference is the base struct for the Python ReferenceType, ProxyType, + * and CallableProxyType. + */ +struct _PyWeakReference { + PyObject_HEAD + + /* The object to which this is a weak reference, or Py_None if none. + * Note that this is a stealth reference: wr_object's refcount is + * not incremented to reflect this pointer. + */ + PyObject *wr_object; + + /* A callable to invoke when wr_object dies, or NULL if none. */ + PyObject *wr_callback; + + /* A cache for wr_object's hash code. As usual for hashes, this is -1 + * if the hash code isn't known yet. + */ + Py_hash_t hash; + + /* If wr_object is weakly referenced, wr_object has a doubly-linked NULL- + * terminated list of weak references to it. These are the list pointers. + * If wr_object goes away, wr_object is set to Py_None, and these pointers + * have no meaning then. + */ + PyWeakReference *wr_prev; + PyWeakReference *wr_next; + vectorcallfunc vectorcall; + +#ifdef Py_GIL_DISABLED + /* Pointer to the lock used when clearing in free-threaded builds. + * Normally this can be derived from wr_object, but in some cases we need + * to lock after wr_object has been set to Py_None. + */ + PyMutex *weakrefs_lock; +#endif +}; + +PyAPI_FUNC(void) _PyWeakref_ClearRef(PyWeakReference *self); + +#define _PyWeakref_CAST(op) \ + (assert(PyWeakref_Check(op)), _Py_CAST(PyWeakReference*, (op))) + +// Test if a weak reference is dead. +PyAPI_FUNC(int) PyWeakref_IsDead(PyObject *ref); + +Py_DEPRECATED(3.13) static inline PyObject* PyWeakref_GET_OBJECT(PyObject *ref_obj) +{ + PyWeakReference *ref = _PyWeakref_CAST(ref_obj); + PyObject *obj = ref->wr_object; + // Explanation for the Py_REFCNT() check: when a weakref's target is part + // of a long chain of deallocations which triggers the trashcan mechanism, + // clearing the weakrefs can be delayed long after the target's refcount + // has dropped to zero. In the meantime, code accessing the weakref will + // be able to "see" the target object even though it is supposed to be + // unreachable. See issue gh-60806. + if (Py_REFCNT(obj) > 0) { + return obj; + } + return Py_None; +} +#define PyWeakref_GET_OBJECT(ref) PyWeakref_GET_OBJECT(_PyObject_CAST(ref)) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/mimalloc/mimalloc.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/mimalloc/mimalloc.h new file mode 100644 index 0000000000000000000000000000000000000000..821129e7690b1b267dfe802a8c8a8b913f7299ea --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/mimalloc/mimalloc.h @@ -0,0 +1,565 @@ +/* ---------------------------------------------------------------------------- +Copyright (c) 2018-2023, Microsoft Research, Daan Leijen +This is free software; you can redistribute it and/or modify it under the +terms of the MIT license. A copy of the license can be found in the file +"LICENSE" at the root of this distribution. +-----------------------------------------------------------------------------*/ +#pragma once +#ifndef MIMALLOC_H +#define MIMALLOC_H + +#define MI_MALLOC_VERSION 212 // major + 2 digits minor + +// ------------------------------------------------------ +// Compiler specific attributes +// ------------------------------------------------------ + +#ifdef __cplusplus + #if (__cplusplus >= 201103L) || (_MSC_VER > 1900) // C++11 + #define mi_attr_noexcept noexcept + #else + #define mi_attr_noexcept throw() + #endif +#else + #define mi_attr_noexcept +#endif + +#if defined(__cplusplus) && (__cplusplus >= 201703) + #define mi_decl_nodiscard [[nodiscard]] +#elif (defined(__GNUC__) && (__GNUC__ >= 4)) || defined(__clang__) // includes clang, icc, and clang-cl + #define mi_decl_nodiscard __attribute__((warn_unused_result)) +#elif defined(_HAS_NODISCARD) + #define mi_decl_nodiscard _NODISCARD +#elif (_MSC_VER >= 1700) + #define mi_decl_nodiscard _Check_return_ +#else + #define mi_decl_nodiscard +#endif + +#if defined(_MSC_VER) || defined(__MINGW32__) + #if !defined(MI_SHARED_LIB) + #define mi_decl_export + #elif defined(MI_SHARED_LIB_EXPORT) + #define mi_decl_export __declspec(dllexport) + #else + #define mi_decl_export __declspec(dllimport) + #endif + #if defined(__MINGW32__) + #define mi_decl_restrict + #define mi_attr_malloc __attribute__((malloc)) + #else + #if (_MSC_VER >= 1900) && !defined(__EDG__) + #define mi_decl_restrict __declspec(allocator) __declspec(restrict) + #else + #define mi_decl_restrict __declspec(restrict) + #endif + #define mi_attr_malloc + #endif + #define mi_cdecl __cdecl + #define mi_attr_alloc_size(s) + #define mi_attr_alloc_size2(s1,s2) + #define mi_attr_alloc_align(p) +#elif defined(__GNUC__) // includes clang and icc + #if defined(MI_SHARED_LIB) && defined(MI_SHARED_LIB_EXPORT) + #define mi_decl_export __attribute__((visibility("default"))) + #else + #define mi_decl_export + #endif + #define mi_cdecl // leads to warnings... __attribute__((cdecl)) + #define mi_decl_restrict + #define mi_attr_malloc __attribute__((malloc)) + #if (defined(__clang_major__) && (__clang_major__ < 4)) || (__GNUC__ < 5) + #define mi_attr_alloc_size(s) + #define mi_attr_alloc_size2(s1,s2) + #define mi_attr_alloc_align(p) + #elif defined(__INTEL_COMPILER) + #define mi_attr_alloc_size(s) __attribute__((alloc_size(s))) + #define mi_attr_alloc_size2(s1,s2) __attribute__((alloc_size(s1,s2))) + #define mi_attr_alloc_align(p) + #else + #define mi_attr_alloc_size(s) __attribute__((alloc_size(s))) + #define mi_attr_alloc_size2(s1,s2) __attribute__((alloc_size(s1,s2))) + #define mi_attr_alloc_align(p) __attribute__((alloc_align(p))) + #endif +#else + #define mi_cdecl + #define mi_decl_export + #define mi_decl_restrict + #define mi_attr_malloc + #define mi_attr_alloc_size(s) + #define mi_attr_alloc_size2(s1,s2) + #define mi_attr_alloc_align(p) +#endif + +// ------------------------------------------------------ +// Includes +// ------------------------------------------------------ + +#include // size_t +#include // bool +#include // INTPTR_MAX + +#ifdef __cplusplus +extern "C" { +#endif + +// ------------------------------------------------------ +// Standard malloc interface +// ------------------------------------------------------ + +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_malloc(size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_calloc(size_t count, size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size2(1,2); +mi_decl_nodiscard mi_decl_export void* mi_realloc(void* p, size_t newsize) mi_attr_noexcept mi_attr_alloc_size(2); +mi_decl_export void* mi_expand(void* p, size_t newsize) mi_attr_noexcept mi_attr_alloc_size(2); + +mi_decl_export void mi_free(void* p) mi_attr_noexcept; +mi_decl_nodiscard mi_decl_export mi_decl_restrict char* mi_strdup(const char* s) mi_attr_noexcept mi_attr_malloc; +mi_decl_nodiscard mi_decl_export mi_decl_restrict char* mi_strndup(const char* s, size_t n) mi_attr_noexcept mi_attr_malloc; +mi_decl_nodiscard mi_decl_export mi_decl_restrict char* mi_realpath(const char* fname, char* resolved_name) mi_attr_noexcept mi_attr_malloc; + +// ------------------------------------------------------ +// Extended functionality +// ------------------------------------------------------ +#define MI_SMALL_WSIZE_MAX (128) +#define MI_SMALL_SIZE_MAX (MI_SMALL_WSIZE_MAX*sizeof(void*)) + +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_malloc_small(size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_zalloc_small(size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_zalloc(size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1); + +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_mallocn(size_t count, size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size2(1,2); +mi_decl_nodiscard mi_decl_export void* mi_reallocn(void* p, size_t count, size_t size) mi_attr_noexcept mi_attr_alloc_size2(2,3); +mi_decl_nodiscard mi_decl_export void* mi_reallocf(void* p, size_t newsize) mi_attr_noexcept mi_attr_alloc_size(2); + +mi_decl_nodiscard mi_decl_export size_t mi_usable_size(const void* p) mi_attr_noexcept; +mi_decl_nodiscard mi_decl_export size_t mi_good_size(size_t size) mi_attr_noexcept; + + +// ------------------------------------------------------ +// Internals +// ------------------------------------------------------ + +typedef void (mi_cdecl mi_deferred_free_fun)(bool force, unsigned long long heartbeat, void* arg); +mi_decl_export void mi_register_deferred_free(mi_deferred_free_fun* deferred_free, void* arg) mi_attr_noexcept; + +typedef void (mi_cdecl mi_output_fun)(const char* msg, void* arg); +mi_decl_export void mi_register_output(mi_output_fun* out, void* arg) mi_attr_noexcept; + +typedef void (mi_cdecl mi_error_fun)(int err, void* arg); +mi_decl_export void mi_register_error(mi_error_fun* fun, void* arg); + +mi_decl_export void mi_collect(bool force) mi_attr_noexcept; +mi_decl_export int mi_version(void) mi_attr_noexcept; +mi_decl_export void mi_stats_reset(void) mi_attr_noexcept; +mi_decl_export void mi_stats_merge(void) mi_attr_noexcept; +mi_decl_export void mi_stats_print(void* out) mi_attr_noexcept; // backward compatibility: `out` is ignored and should be NULL +mi_decl_export void mi_stats_print_out(mi_output_fun* out, void* arg) mi_attr_noexcept; + +mi_decl_export void mi_process_init(void) mi_attr_noexcept; +mi_decl_export void mi_thread_init(void) mi_attr_noexcept; +mi_decl_export void mi_thread_done(void) mi_attr_noexcept; +mi_decl_export void mi_thread_stats_print_out(mi_output_fun* out, void* arg) mi_attr_noexcept; + +mi_decl_export void mi_process_info(size_t* elapsed_msecs, size_t* user_msecs, size_t* system_msecs, + size_t* current_rss, size_t* peak_rss, + size_t* current_commit, size_t* peak_commit, size_t* page_faults) mi_attr_noexcept; + +// ------------------------------------------------------------------------------------- +// Aligned allocation +// Note that `alignment` always follows `size` for consistency with unaligned +// allocation, but unfortunately this differs from `posix_memalign` and `aligned_alloc`. +// ------------------------------------------------------------------------------------- + +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_malloc_aligned(size_t size, size_t alignment) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1) mi_attr_alloc_align(2); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_malloc_aligned_at(size_t size, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_zalloc_aligned(size_t size, size_t alignment) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1) mi_attr_alloc_align(2); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_zalloc_aligned_at(size_t size, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_calloc_aligned(size_t count, size_t size, size_t alignment) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size2(1,2) mi_attr_alloc_align(3); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_calloc_aligned_at(size_t count, size_t size, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size2(1,2); +mi_decl_nodiscard mi_decl_export void* mi_realloc_aligned(void* p, size_t newsize, size_t alignment) mi_attr_noexcept mi_attr_alloc_size(2) mi_attr_alloc_align(3); +mi_decl_nodiscard mi_decl_export void* mi_realloc_aligned_at(void* p, size_t newsize, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_alloc_size(2); + + +// ------------------------------------------------------------------------------------- +// Heaps: first-class, but can only allocate from the same thread that created it. +// ------------------------------------------------------------------------------------- + +struct mi_heap_s; +typedef struct mi_heap_s mi_heap_t; + +mi_decl_nodiscard mi_decl_export mi_heap_t* mi_heap_new(void); +mi_decl_export void mi_heap_delete(mi_heap_t* heap); +mi_decl_export void mi_heap_destroy(mi_heap_t* heap); +mi_decl_export mi_heap_t* mi_heap_set_default(mi_heap_t* heap); +mi_decl_export mi_heap_t* mi_heap_get_default(void); +mi_decl_export mi_heap_t* mi_heap_get_backing(void); +mi_decl_export void mi_heap_collect(mi_heap_t* heap, bool force) mi_attr_noexcept; + +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_malloc(mi_heap_t* heap, size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(2); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_zalloc(mi_heap_t* heap, size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(2); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_calloc(mi_heap_t* heap, size_t count, size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size2(2, 3); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_mallocn(mi_heap_t* heap, size_t count, size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size2(2, 3); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_malloc_small(mi_heap_t* heap, size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(2); + +mi_decl_nodiscard mi_decl_export void* mi_heap_realloc(mi_heap_t* heap, void* p, size_t newsize) mi_attr_noexcept mi_attr_alloc_size(3); +mi_decl_nodiscard mi_decl_export void* mi_heap_reallocn(mi_heap_t* heap, void* p, size_t count, size_t size) mi_attr_noexcept mi_attr_alloc_size2(3,4); +mi_decl_nodiscard mi_decl_export void* mi_heap_reallocf(mi_heap_t* heap, void* p, size_t newsize) mi_attr_noexcept mi_attr_alloc_size(3); + +mi_decl_nodiscard mi_decl_export mi_decl_restrict char* mi_heap_strdup(mi_heap_t* heap, const char* s) mi_attr_noexcept mi_attr_malloc; +mi_decl_nodiscard mi_decl_export mi_decl_restrict char* mi_heap_strndup(mi_heap_t* heap, const char* s, size_t n) mi_attr_noexcept mi_attr_malloc; +mi_decl_nodiscard mi_decl_export mi_decl_restrict char* mi_heap_realpath(mi_heap_t* heap, const char* fname, char* resolved_name) mi_attr_noexcept mi_attr_malloc; + +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_malloc_aligned(mi_heap_t* heap, size_t size, size_t alignment) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(2) mi_attr_alloc_align(3); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_malloc_aligned_at(mi_heap_t* heap, size_t size, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(2); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_zalloc_aligned(mi_heap_t* heap, size_t size, size_t alignment) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(2) mi_attr_alloc_align(3); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_zalloc_aligned_at(mi_heap_t* heap, size_t size, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(2); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_calloc_aligned(mi_heap_t* heap, size_t count, size_t size, size_t alignment) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size2(2, 3) mi_attr_alloc_align(4); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_calloc_aligned_at(mi_heap_t* heap, size_t count, size_t size, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size2(2, 3); +mi_decl_nodiscard mi_decl_export void* mi_heap_realloc_aligned(mi_heap_t* heap, void* p, size_t newsize, size_t alignment) mi_attr_noexcept mi_attr_alloc_size(3) mi_attr_alloc_align(4); +mi_decl_nodiscard mi_decl_export void* mi_heap_realloc_aligned_at(mi_heap_t* heap, void* p, size_t newsize, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_alloc_size(3); + + +// -------------------------------------------------------------------------------- +// Zero initialized re-allocation. +// Only valid on memory that was originally allocated with zero initialization too. +// e.g. `mi_calloc`, `mi_zalloc`, `mi_zalloc_aligned` etc. +// see +// -------------------------------------------------------------------------------- + +mi_decl_nodiscard mi_decl_export void* mi_rezalloc(void* p, size_t newsize) mi_attr_noexcept mi_attr_alloc_size(2); +mi_decl_nodiscard mi_decl_export void* mi_recalloc(void* p, size_t newcount, size_t size) mi_attr_noexcept mi_attr_alloc_size2(2,3); + +mi_decl_nodiscard mi_decl_export void* mi_rezalloc_aligned(void* p, size_t newsize, size_t alignment) mi_attr_noexcept mi_attr_alloc_size(2) mi_attr_alloc_align(3); +mi_decl_nodiscard mi_decl_export void* mi_rezalloc_aligned_at(void* p, size_t newsize, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_alloc_size(2); +mi_decl_nodiscard mi_decl_export void* mi_recalloc_aligned(void* p, size_t newcount, size_t size, size_t alignment) mi_attr_noexcept mi_attr_alloc_size2(2,3) mi_attr_alloc_align(4); +mi_decl_nodiscard mi_decl_export void* mi_recalloc_aligned_at(void* p, size_t newcount, size_t size, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_alloc_size2(2,3); + +mi_decl_nodiscard mi_decl_export void* mi_heap_rezalloc(mi_heap_t* heap, void* p, size_t newsize) mi_attr_noexcept mi_attr_alloc_size(3); +mi_decl_nodiscard mi_decl_export void* mi_heap_recalloc(mi_heap_t* heap, void* p, size_t newcount, size_t size) mi_attr_noexcept mi_attr_alloc_size2(3,4); + +mi_decl_nodiscard mi_decl_export void* mi_heap_rezalloc_aligned(mi_heap_t* heap, void* p, size_t newsize, size_t alignment) mi_attr_noexcept mi_attr_alloc_size(3) mi_attr_alloc_align(4); +mi_decl_nodiscard mi_decl_export void* mi_heap_rezalloc_aligned_at(mi_heap_t* heap, void* p, size_t newsize, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_alloc_size(3); +mi_decl_nodiscard mi_decl_export void* mi_heap_recalloc_aligned(mi_heap_t* heap, void* p, size_t newcount, size_t size, size_t alignment) mi_attr_noexcept mi_attr_alloc_size2(3,4) mi_attr_alloc_align(5); +mi_decl_nodiscard mi_decl_export void* mi_heap_recalloc_aligned_at(mi_heap_t* heap, void* p, size_t newcount, size_t size, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_alloc_size2(3,4); + + +// ------------------------------------------------------ +// Analysis +// ------------------------------------------------------ + +mi_decl_export bool mi_heap_contains_block(mi_heap_t* heap, const void* p); +mi_decl_export bool mi_heap_check_owned(mi_heap_t* heap, const void* p); +mi_decl_export bool mi_check_owned(const void* p); + +// An area of heap space contains blocks of a single size. +typedef struct mi_heap_area_s { + void* blocks; // start of the area containing heap blocks + size_t reserved; // bytes reserved for this area (virtual) + size_t committed; // current available bytes for this area + size_t used; // number of allocated blocks + size_t block_size; // size in bytes of each block + size_t full_block_size; // size in bytes of a full block including padding and metadata. +} mi_heap_area_t; + +typedef bool (mi_cdecl mi_block_visit_fun)(const mi_heap_t* heap, const mi_heap_area_t* area, void* block, size_t block_size, void* arg); + +mi_decl_export bool mi_heap_visit_blocks(const mi_heap_t* heap, bool visit_all_blocks, mi_block_visit_fun* visitor, void* arg); + +// Experimental +mi_decl_nodiscard mi_decl_export bool mi_is_in_heap_region(const void* p) mi_attr_noexcept; +mi_decl_nodiscard mi_decl_export bool mi_is_redirected(void) mi_attr_noexcept; + +mi_decl_export int mi_reserve_huge_os_pages_interleave(size_t pages, size_t numa_nodes, size_t timeout_msecs) mi_attr_noexcept; +mi_decl_export int mi_reserve_huge_os_pages_at(size_t pages, int numa_node, size_t timeout_msecs) mi_attr_noexcept; + +mi_decl_export int mi_reserve_os_memory(size_t size, bool commit, bool allow_large) mi_attr_noexcept; +mi_decl_export bool mi_manage_os_memory(void* start, size_t size, bool is_committed, bool is_large, bool is_zero, int numa_node) mi_attr_noexcept; + +mi_decl_export void mi_debug_show_arenas(void) mi_attr_noexcept; + +// Experimental: heaps associated with specific memory arena's +typedef int mi_arena_id_t; +mi_decl_export void* mi_arena_area(mi_arena_id_t arena_id, size_t* size); +mi_decl_export int mi_reserve_huge_os_pages_at_ex(size_t pages, int numa_node, size_t timeout_msecs, bool exclusive, mi_arena_id_t* arena_id) mi_attr_noexcept; +mi_decl_export int mi_reserve_os_memory_ex(size_t size, bool commit, bool allow_large, bool exclusive, mi_arena_id_t* arena_id) mi_attr_noexcept; +mi_decl_export bool mi_manage_os_memory_ex(void* start, size_t size, bool is_committed, bool is_large, bool is_zero, int numa_node, bool exclusive, mi_arena_id_t* arena_id) mi_attr_noexcept; + +#if MI_MALLOC_VERSION >= 182 +// Create a heap that only allocates in the specified arena +mi_decl_nodiscard mi_decl_export mi_heap_t* mi_heap_new_in_arena(mi_arena_id_t arena_id); +#endif + +// deprecated +mi_decl_export int mi_reserve_huge_os_pages(size_t pages, double max_secs, size_t* pages_reserved) mi_attr_noexcept; + + +// ------------------------------------------------------ +// Convenience +// ------------------------------------------------------ + +#define mi_malloc_tp(tp) ((tp*)mi_malloc(sizeof(tp))) +#define mi_zalloc_tp(tp) ((tp*)mi_zalloc(sizeof(tp))) +#define mi_calloc_tp(tp,n) ((tp*)mi_calloc(n,sizeof(tp))) +#define mi_mallocn_tp(tp,n) ((tp*)mi_mallocn(n,sizeof(tp))) +#define mi_reallocn_tp(p,tp,n) ((tp*)mi_reallocn(p,n,sizeof(tp))) +#define mi_recalloc_tp(p,tp,n) ((tp*)mi_recalloc(p,n,sizeof(tp))) + +#define mi_heap_malloc_tp(hp,tp) ((tp*)mi_heap_malloc(hp,sizeof(tp))) +#define mi_heap_zalloc_tp(hp,tp) ((tp*)mi_heap_zalloc(hp,sizeof(tp))) +#define mi_heap_calloc_tp(hp,tp,n) ((tp*)mi_heap_calloc(hp,n,sizeof(tp))) +#define mi_heap_mallocn_tp(hp,tp,n) ((tp*)mi_heap_mallocn(hp,n,sizeof(tp))) +#define mi_heap_reallocn_tp(hp,p,tp,n) ((tp*)mi_heap_reallocn(hp,p,n,sizeof(tp))) +#define mi_heap_recalloc_tp(hp,p,tp,n) ((tp*)mi_heap_recalloc(hp,p,n,sizeof(tp))) + + +// ------------------------------------------------------ +// Options +// ------------------------------------------------------ + +typedef enum mi_option_e { + // stable options + mi_option_show_errors, // print error messages + mi_option_show_stats, // print statistics on termination + mi_option_verbose, // print verbose messages + // the following options are experimental (see src/options.h) + mi_option_eager_commit, // eager commit segments? (after `eager_commit_delay` segments) (=1) + mi_option_arena_eager_commit, // eager commit arenas? Use 2 to enable just on overcommit systems (=2) + mi_option_purge_decommits, // should a memory purge decommit (or only reset) (=1) + mi_option_allow_large_os_pages, // allow large (2MiB) OS pages, implies eager commit + mi_option_reserve_huge_os_pages, // reserve N huge OS pages (1GiB/page) at startup + mi_option_reserve_huge_os_pages_at, // reserve huge OS pages at a specific NUMA node + mi_option_reserve_os_memory, // reserve specified amount of OS memory in an arena at startup + mi_option_deprecated_segment_cache, + mi_option_deprecated_page_reset, + mi_option_abandoned_page_purge, // immediately purge delayed purges on thread termination + mi_option_deprecated_segment_reset, + mi_option_eager_commit_delay, + mi_option_purge_delay, // memory purging is delayed by N milli seconds; use 0 for immediate purging or -1 for no purging at all. + mi_option_use_numa_nodes, // 0 = use all available numa nodes, otherwise use at most N nodes. + mi_option_limit_os_alloc, // 1 = do not use OS memory for allocation (but only programmatically reserved arenas) + mi_option_os_tag, // tag used for OS logging (macOS only for now) + mi_option_max_errors, // issue at most N error messages + mi_option_max_warnings, // issue at most N warning messages + mi_option_max_segment_reclaim, + mi_option_destroy_on_exit, // if set, release all memory on exit; sometimes used for dynamic unloading but can be unsafe. + mi_option_arena_reserve, // initial memory size in KiB for arena reservation (1GiB on 64-bit) + mi_option_arena_purge_mult, + mi_option_purge_extend_delay, + _mi_option_last, + // legacy option names + mi_option_large_os_pages = mi_option_allow_large_os_pages, + mi_option_eager_region_commit = mi_option_arena_eager_commit, + mi_option_reset_decommits = mi_option_purge_decommits, + mi_option_reset_delay = mi_option_purge_delay, + mi_option_abandoned_page_reset = mi_option_abandoned_page_purge +} mi_option_t; + + +mi_decl_nodiscard mi_decl_export bool mi_option_is_enabled(mi_option_t option); +mi_decl_export void mi_option_enable(mi_option_t option); +mi_decl_export void mi_option_disable(mi_option_t option); +mi_decl_export void mi_option_set_enabled(mi_option_t option, bool enable); +mi_decl_export void mi_option_set_enabled_default(mi_option_t option, bool enable); + +mi_decl_nodiscard mi_decl_export long mi_option_get(mi_option_t option); +mi_decl_nodiscard mi_decl_export long mi_option_get_clamp(mi_option_t option, long min, long max); +mi_decl_nodiscard mi_decl_export size_t mi_option_get_size(mi_option_t option); +mi_decl_export void mi_option_set(mi_option_t option, long value); +mi_decl_export void mi_option_set_default(mi_option_t option, long value); + + +// ------------------------------------------------------------------------------------------------------- +// "mi" prefixed implementations of various posix, Unix, Windows, and C++ allocation functions. +// (This can be convenient when providing overrides of these functions as done in `mimalloc-override.h`.) +// note: we use `mi_cfree` as "checked free" and it checks if the pointer is in our heap before free-ing. +// ------------------------------------------------------------------------------------------------------- + +mi_decl_export void mi_cfree(void* p) mi_attr_noexcept; +mi_decl_export void* mi__expand(void* p, size_t newsize) mi_attr_noexcept; +mi_decl_nodiscard mi_decl_export size_t mi_malloc_size(const void* p) mi_attr_noexcept; +mi_decl_nodiscard mi_decl_export size_t mi_malloc_good_size(size_t size) mi_attr_noexcept; +mi_decl_nodiscard mi_decl_export size_t mi_malloc_usable_size(const void *p) mi_attr_noexcept; + +mi_decl_export int mi_posix_memalign(void** p, size_t alignment, size_t size) mi_attr_noexcept; +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_memalign(size_t alignment, size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(2) mi_attr_alloc_align(1); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_valloc(size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_pvalloc(size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_aligned_alloc(size_t alignment, size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(2) mi_attr_alloc_align(1); + +mi_decl_nodiscard mi_decl_export void* mi_reallocarray(void* p, size_t count, size_t size) mi_attr_noexcept mi_attr_alloc_size2(2,3); +mi_decl_nodiscard mi_decl_export int mi_reallocarr(void* p, size_t count, size_t size) mi_attr_noexcept; +mi_decl_nodiscard mi_decl_export void* mi_aligned_recalloc(void* p, size_t newcount, size_t size, size_t alignment) mi_attr_noexcept; +mi_decl_nodiscard mi_decl_export void* mi_aligned_offset_recalloc(void* p, size_t newcount, size_t size, size_t alignment, size_t offset) mi_attr_noexcept; + +mi_decl_nodiscard mi_decl_export mi_decl_restrict unsigned short* mi_wcsdup(const unsigned short* s) mi_attr_noexcept mi_attr_malloc; +mi_decl_nodiscard mi_decl_export mi_decl_restrict unsigned char* mi_mbsdup(const unsigned char* s) mi_attr_noexcept mi_attr_malloc; +mi_decl_export int mi_dupenv_s(char** buf, size_t* size, const char* name) mi_attr_noexcept; +mi_decl_export int mi_wdupenv_s(unsigned short** buf, size_t* size, const unsigned short* name) mi_attr_noexcept; + +mi_decl_export void mi_free_size(void* p, size_t size) mi_attr_noexcept; +mi_decl_export void mi_free_size_aligned(void* p, size_t size, size_t alignment) mi_attr_noexcept; +mi_decl_export void mi_free_aligned(void* p, size_t alignment) mi_attr_noexcept; + +// The `mi_new` wrappers implement C++ semantics on out-of-memory instead of directly returning `NULL`. +// (and call `std::get_new_handler` and potentially raise a `std::bad_alloc` exception). +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_new(size_t size) mi_attr_malloc mi_attr_alloc_size(1); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_new_aligned(size_t size, size_t alignment) mi_attr_malloc mi_attr_alloc_size(1) mi_attr_alloc_align(2); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_new_nothrow(size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_new_aligned_nothrow(size_t size, size_t alignment) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1) mi_attr_alloc_align(2); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_new_n(size_t count, size_t size) mi_attr_malloc mi_attr_alloc_size2(1, 2); +mi_decl_nodiscard mi_decl_export void* mi_new_realloc(void* p, size_t newsize) mi_attr_alloc_size(2); +mi_decl_nodiscard mi_decl_export void* mi_new_reallocn(void* p, size_t newcount, size_t size) mi_attr_alloc_size2(2, 3); + +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_alloc_new(mi_heap_t* heap, size_t size) mi_attr_malloc mi_attr_alloc_size(2); +mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_alloc_new_n(mi_heap_t* heap, size_t count, size_t size) mi_attr_malloc mi_attr_alloc_size2(2, 3); + +#ifdef __cplusplus +} +#endif + +// --------------------------------------------------------------------------------------------- +// Implement the C++ std::allocator interface for use in STL containers. +// (note: see `mimalloc-new-delete.h` for overriding the new/delete operators globally) +// --------------------------------------------------------------------------------------------- +#ifdef __cplusplus + +#include // std::size_t +#include // PTRDIFF_MAX +#if (__cplusplus >= 201103L) || (_MSC_VER > 1900) // C++11 +#include // std::true_type +#include // std::forward +#endif + +template struct _mi_stl_allocator_common { + typedef T value_type; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + typedef value_type& reference; + typedef value_type const& const_reference; + typedef value_type* pointer; + typedef value_type const* const_pointer; + + #if ((__cplusplus >= 201103L) || (_MSC_VER > 1900)) // C++11 + using propagate_on_container_copy_assignment = std::true_type; + using propagate_on_container_move_assignment = std::true_type; + using propagate_on_container_swap = std::true_type; + template void construct(U* p, Args&& ...args) { ::new(p) U(std::forward(args)...); } + template void destroy(U* p) mi_attr_noexcept { p->~U(); } + #else + void construct(pointer p, value_type const& val) { ::new(p) value_type(val); } + void destroy(pointer p) { p->~value_type(); } + #endif + + size_type max_size() const mi_attr_noexcept { return (PTRDIFF_MAX/sizeof(value_type)); } + pointer address(reference x) const { return &x; } + const_pointer address(const_reference x) const { return &x; } +}; + +template struct mi_stl_allocator : public _mi_stl_allocator_common { + using typename _mi_stl_allocator_common::size_type; + using typename _mi_stl_allocator_common::value_type; + using typename _mi_stl_allocator_common::pointer; + template struct rebind { typedef mi_stl_allocator other; }; + + mi_stl_allocator() mi_attr_noexcept = default; + mi_stl_allocator(const mi_stl_allocator&) mi_attr_noexcept = default; + template mi_stl_allocator(const mi_stl_allocator&) mi_attr_noexcept { } + mi_stl_allocator select_on_container_copy_construction() const { return *this; } + void deallocate(T* p, size_type) { mi_free(p); } + + #if (__cplusplus >= 201703L) // C++17 + mi_decl_nodiscard T* allocate(size_type count) { return static_cast(mi_new_n(count, sizeof(T))); } + mi_decl_nodiscard T* allocate(size_type count, const void*) { return allocate(count); } + #else + mi_decl_nodiscard pointer allocate(size_type count, const void* = 0) { return static_cast(mi_new_n(count, sizeof(value_type))); } + #endif + + #if ((__cplusplus >= 201103L) || (_MSC_VER > 1900)) // C++11 + using is_always_equal = std::true_type; + #endif +}; + +template bool operator==(const mi_stl_allocator& , const mi_stl_allocator& ) mi_attr_noexcept { return true; } +template bool operator!=(const mi_stl_allocator& , const mi_stl_allocator& ) mi_attr_noexcept { return false; } + + +#if (__cplusplus >= 201103L) || (_MSC_VER >= 1900) // C++11 +#define MI_HAS_HEAP_STL_ALLOCATOR 1 + +#include // std::shared_ptr + +// Common base class for STL allocators in a specific heap +template struct _mi_heap_stl_allocator_common : public _mi_stl_allocator_common { + using typename _mi_stl_allocator_common::size_type; + using typename _mi_stl_allocator_common::value_type; + using typename _mi_stl_allocator_common::pointer; + + _mi_heap_stl_allocator_common(mi_heap_t* hp) : heap(hp) { } /* will not delete nor destroy the passed in heap */ + + #if (__cplusplus >= 201703L) // C++17 + mi_decl_nodiscard T* allocate(size_type count) { return static_cast(mi_heap_alloc_new_n(this->heap.get(), count, sizeof(T))); } + mi_decl_nodiscard T* allocate(size_type count, const void*) { return allocate(count); } + #else + mi_decl_nodiscard pointer allocate(size_type count, const void* = 0) { return static_cast(mi_heap_alloc_new_n(this->heap.get(), count, sizeof(value_type))); } + #endif + + #if ((__cplusplus >= 201103L) || (_MSC_VER > 1900)) // C++11 + using is_always_equal = std::false_type; + #endif + + void collect(bool force) { mi_heap_collect(this->heap.get(), force); } + template bool is_equal(const _mi_heap_stl_allocator_common& x) const { return (this->heap == x.heap); } + +protected: + std::shared_ptr heap; + template friend struct _mi_heap_stl_allocator_common; + + _mi_heap_stl_allocator_common() { + mi_heap_t* hp = mi_heap_new(); + this->heap.reset(hp, (_mi_destroy ? &heap_destroy : &heap_delete)); /* calls heap_delete/destroy when the refcount drops to zero */ + } + _mi_heap_stl_allocator_common(const _mi_heap_stl_allocator_common& x) mi_attr_noexcept : heap(x.heap) { } + template _mi_heap_stl_allocator_common(const _mi_heap_stl_allocator_common& x) mi_attr_noexcept : heap(x.heap) { } + +private: + static void heap_delete(mi_heap_t* hp) { if (hp != NULL) { mi_heap_delete(hp); } } + static void heap_destroy(mi_heap_t* hp) { if (hp != NULL) { mi_heap_destroy(hp); } } +}; + +// STL allocator allocation in a specific heap +template struct mi_heap_stl_allocator : public _mi_heap_stl_allocator_common { + using typename _mi_heap_stl_allocator_common::size_type; + mi_heap_stl_allocator() : _mi_heap_stl_allocator_common() { } // creates fresh heap that is deleted when the destructor is called + mi_heap_stl_allocator(mi_heap_t* hp) : _mi_heap_stl_allocator_common(hp) { } // no delete nor destroy on the passed in heap + template mi_heap_stl_allocator(const mi_heap_stl_allocator& x) mi_attr_noexcept : _mi_heap_stl_allocator_common(x) { } + + mi_heap_stl_allocator select_on_container_copy_construction() const { return *this; } + void deallocate(T* p, size_type) { mi_free(p); } + template struct rebind { typedef mi_heap_stl_allocator other; }; +}; + +template bool operator==(const mi_heap_stl_allocator& x, const mi_heap_stl_allocator& y) mi_attr_noexcept { return (x.is_equal(y)); } +template bool operator!=(const mi_heap_stl_allocator& x, const mi_heap_stl_allocator& y) mi_attr_noexcept { return (!x.is_equal(y)); } + + +// STL allocator allocation in a specific heap, where `free` does nothing and +// the heap is destroyed in one go on destruction -- use with care! +template struct mi_heap_destroy_stl_allocator : public _mi_heap_stl_allocator_common { + using typename _mi_heap_stl_allocator_common::size_type; + mi_heap_destroy_stl_allocator() : _mi_heap_stl_allocator_common() { } // creates fresh heap that is destroyed when the destructor is called + mi_heap_destroy_stl_allocator(mi_heap_t* hp) : _mi_heap_stl_allocator_common(hp) { } // no delete nor destroy on the passed in heap + template mi_heap_destroy_stl_allocator(const mi_heap_destroy_stl_allocator& x) mi_attr_noexcept : _mi_heap_stl_allocator_common(x) { } + + mi_heap_destroy_stl_allocator select_on_container_copy_construction() const { return *this; } + void deallocate(T*, size_type) { /* do nothing as we destroy the heap on destruct. */ } + template struct rebind { typedef mi_heap_destroy_stl_allocator other; }; +}; + +template bool operator==(const mi_heap_destroy_stl_allocator& x, const mi_heap_destroy_stl_allocator& y) mi_attr_noexcept { return (x.is_equal(y)); } +template bool operator!=(const mi_heap_destroy_stl_allocator& x, const mi_heap_destroy_stl_allocator& y) mi_attr_noexcept { return (!x.is_equal(y)); } + +#endif // C++11 + +#endif // __cplusplus + +#endif diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/mimalloc/mimalloc/atomic.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/mimalloc/mimalloc/atomic.h new file mode 100644 index 0000000000000000000000000000000000000000..65fa477d64378265e6b290328c1d6efca96da78e --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/mimalloc/mimalloc/atomic.h @@ -0,0 +1,392 @@ +/* ---------------------------------------------------------------------------- +Copyright (c) 2018-2023 Microsoft Research, Daan Leijen +This is free software; you can redistribute it and/or modify it under the +terms of the MIT license. A copy of the license can be found in the file +"LICENSE" at the root of this distribution. +-----------------------------------------------------------------------------*/ +#pragma once +#ifndef MIMALLOC_ATOMIC_H +#define MIMALLOC_ATOMIC_H + +// -------------------------------------------------------------------------------------------- +// Atomics +// We need to be portable between C, C++, and MSVC. +// We base the primitives on the C/C++ atomics and create a minimal wrapper for MSVC in C compilation mode. +// This is why we try to use only `uintptr_t` and `*` as atomic types. +// To gain better insight in the range of used atomics, we use explicitly named memory order operations +// instead of passing the memory order as a parameter. +// ----------------------------------------------------------------------------------------------- + +#if defined(__cplusplus) +// Use C++ atomics +#include +#define _Atomic(tp) std::atomic +#define mi_atomic(name) std::atomic_##name +#define mi_memory_order(name) std::memory_order_##name +#if (__cplusplus >= 202002L) // c++20, see issue #571 + #define MI_ATOMIC_VAR_INIT(x) x +#elif !defined(ATOMIC_VAR_INIT) + #define MI_ATOMIC_VAR_INIT(x) x +#else + #define MI_ATOMIC_VAR_INIT(x) ATOMIC_VAR_INIT(x) +#endif +#elif defined(_MSC_VER) +// Use MSVC C wrapper for C11 atomics +#define _Atomic(tp) tp +#define MI_ATOMIC_VAR_INIT(x) x +#define mi_atomic(name) mi_atomic_##name +#define mi_memory_order(name) mi_memory_order_##name +#else +// Use C11 atomics +#include +#define mi_atomic(name) atomic_##name +#define mi_memory_order(name) memory_order_##name +#if (__STDC_VERSION__ >= 201710L) // c17, see issue #735 + #define MI_ATOMIC_VAR_INIT(x) x +#elif !defined(ATOMIC_VAR_INIT) + #define MI_ATOMIC_VAR_INIT(x) x +#else + #define MI_ATOMIC_VAR_INIT(x) ATOMIC_VAR_INIT(x) +#endif +#endif + +// Various defines for all used memory orders in mimalloc +#define mi_atomic_cas_weak(p,expected,desired,mem_success,mem_fail) \ + mi_atomic(compare_exchange_weak_explicit)(p,expected,desired,mem_success,mem_fail) + +#define mi_atomic_cas_strong(p,expected,desired,mem_success,mem_fail) \ + mi_atomic(compare_exchange_strong_explicit)(p,expected,desired,mem_success,mem_fail) + +#define mi_atomic_load_acquire(p) mi_atomic(load_explicit)(p,mi_memory_order(acquire)) +#define mi_atomic_load_relaxed(p) mi_atomic(load_explicit)(p,mi_memory_order(relaxed)) +#define mi_atomic_store_release(p,x) mi_atomic(store_explicit)(p,x,mi_memory_order(release)) +#define mi_atomic_store_relaxed(p,x) mi_atomic(store_explicit)(p,x,mi_memory_order(relaxed)) +#define mi_atomic_exchange_release(p,x) mi_atomic(exchange_explicit)(p,x,mi_memory_order(release)) +#define mi_atomic_exchange_acq_rel(p,x) mi_atomic(exchange_explicit)(p,x,mi_memory_order(acq_rel)) +#define mi_atomic_cas_weak_release(p,exp,des) mi_atomic_cas_weak(p,exp,des,mi_memory_order(release),mi_memory_order(relaxed)) +#define mi_atomic_cas_weak_acq_rel(p,exp,des) mi_atomic_cas_weak(p,exp,des,mi_memory_order(acq_rel),mi_memory_order(acquire)) +#define mi_atomic_cas_strong_release(p,exp,des) mi_atomic_cas_strong(p,exp,des,mi_memory_order(release),mi_memory_order(relaxed)) +#define mi_atomic_cas_strong_acq_rel(p,exp,des) mi_atomic_cas_strong(p,exp,des,mi_memory_order(acq_rel),mi_memory_order(acquire)) + +#define mi_atomic_add_relaxed(p,x) mi_atomic(fetch_add_explicit)(p,x,mi_memory_order(relaxed)) +#define mi_atomic_sub_relaxed(p,x) mi_atomic(fetch_sub_explicit)(p,x,mi_memory_order(relaxed)) +#define mi_atomic_add_acq_rel(p,x) mi_atomic(fetch_add_explicit)(p,x,mi_memory_order(acq_rel)) +#define mi_atomic_sub_acq_rel(p,x) mi_atomic(fetch_sub_explicit)(p,x,mi_memory_order(acq_rel)) +#define mi_atomic_and_acq_rel(p,x) mi_atomic(fetch_and_explicit)(p,x,mi_memory_order(acq_rel)) +#define mi_atomic_or_acq_rel(p,x) mi_atomic(fetch_or_explicit)(p,x,mi_memory_order(acq_rel)) + +#define mi_atomic_increment_relaxed(p) mi_atomic_add_relaxed(p,(uintptr_t)1) +#define mi_atomic_decrement_relaxed(p) mi_atomic_sub_relaxed(p,(uintptr_t)1) +#define mi_atomic_increment_acq_rel(p) mi_atomic_add_acq_rel(p,(uintptr_t)1) +#define mi_atomic_decrement_acq_rel(p) mi_atomic_sub_acq_rel(p,(uintptr_t)1) + +static inline void mi_atomic_yield(void); +static inline intptr_t mi_atomic_addi(_Atomic(intptr_t)*p, intptr_t add); +static inline intptr_t mi_atomic_subi(_Atomic(intptr_t)*p, intptr_t sub); + + +#if defined(__cplusplus) || !defined(_MSC_VER) + +// In C++/C11 atomics we have polymorphic atomics so can use the typed `ptr` variants (where `tp` is the type of atomic value) +// We use these macros so we can provide a typed wrapper in MSVC in C compilation mode as well +#define mi_atomic_load_ptr_acquire(tp,p) mi_atomic_load_acquire(p) +#define mi_atomic_load_ptr_relaxed(tp,p) mi_atomic_load_relaxed(p) + +// In C++ we need to add casts to help resolve templates if NULL is passed +#if defined(__cplusplus) +#define mi_atomic_store_ptr_release(tp,p,x) mi_atomic_store_release(p,(tp*)x) +#define mi_atomic_store_ptr_relaxed(tp,p,x) mi_atomic_store_relaxed(p,(tp*)x) +#define mi_atomic_cas_ptr_weak_release(tp,p,exp,des) mi_atomic_cas_weak_release(p,exp,(tp*)des) +#define mi_atomic_cas_ptr_weak_acq_rel(tp,p,exp,des) mi_atomic_cas_weak_acq_rel(p,exp,(tp*)des) +#define mi_atomic_cas_ptr_strong_release(tp,p,exp,des) mi_atomic_cas_strong_release(p,exp,(tp*)des) +#define mi_atomic_exchange_ptr_release(tp,p,x) mi_atomic_exchange_release(p,(tp*)x) +#define mi_atomic_exchange_ptr_acq_rel(tp,p,x) mi_atomic_exchange_acq_rel(p,(tp*)x) +#else +#define mi_atomic_store_ptr_release(tp,p,x) mi_atomic_store_release(p,x) +#define mi_atomic_store_ptr_relaxed(tp,p,x) mi_atomic_store_relaxed(p,x) +#define mi_atomic_cas_ptr_weak_release(tp,p,exp,des) mi_atomic_cas_weak_release(p,exp,des) +#define mi_atomic_cas_ptr_weak_acq_rel(tp,p,exp,des) mi_atomic_cas_weak_acq_rel(p,exp,des) +#define mi_atomic_cas_ptr_strong_release(tp,p,exp,des) mi_atomic_cas_strong_release(p,exp,des) +#define mi_atomic_exchange_ptr_release(tp,p,x) mi_atomic_exchange_release(p,x) +#define mi_atomic_exchange_ptr_acq_rel(tp,p,x) mi_atomic_exchange_acq_rel(p,x) +#endif + +// These are used by the statistics +static inline int64_t mi_atomic_addi64_relaxed(volatile int64_t* p, int64_t add) { + return mi_atomic(fetch_add_explicit)((_Atomic(int64_t)*)p, add, mi_memory_order(relaxed)); +} +static inline void mi_atomic_maxi64_relaxed(volatile int64_t* p, int64_t x) { + int64_t current = mi_atomic_load_relaxed((_Atomic(int64_t)*)p); + while (current < x && !mi_atomic_cas_weak_release((_Atomic(int64_t)*)p, ¤t, x)) { /* nothing */ }; +} + +// Used by timers +#define mi_atomic_loadi64_acquire(p) mi_atomic(load_explicit)(p,mi_memory_order(acquire)) +#define mi_atomic_loadi64_relaxed(p) mi_atomic(load_explicit)(p,mi_memory_order(relaxed)) +#define mi_atomic_storei64_release(p,x) mi_atomic(store_explicit)(p,x,mi_memory_order(release)) +#define mi_atomic_storei64_relaxed(p,x) mi_atomic(store_explicit)(p,x,mi_memory_order(relaxed)) + +#define mi_atomic_casi64_strong_acq_rel(p,e,d) mi_atomic_cas_strong_acq_rel(p,e,d) +#define mi_atomic_addi64_acq_rel(p,i) mi_atomic_add_acq_rel(p,i) + + +#elif defined(_MSC_VER) + +// MSVC C compilation wrapper that uses Interlocked operations to model C11 atomics. +#define WIN32_LEAN_AND_MEAN +#include +#include +#ifdef _WIN64 +typedef LONG64 msc_intptr_t; +#define MI_64(f) f##64 +#else +typedef LONG msc_intptr_t; +#define MI_64(f) f +#endif + +typedef enum mi_memory_order_e { + mi_memory_order_relaxed, + mi_memory_order_consume, + mi_memory_order_acquire, + mi_memory_order_release, + mi_memory_order_acq_rel, + mi_memory_order_seq_cst +} mi_memory_order; + +static inline uintptr_t mi_atomic_fetch_add_explicit(_Atomic(uintptr_t)*p, uintptr_t add, mi_memory_order mo) { + (void)(mo); + return (uintptr_t)MI_64(_InterlockedExchangeAdd)((volatile msc_intptr_t*)p, (msc_intptr_t)add); +} +static inline uintptr_t mi_atomic_fetch_sub_explicit(_Atomic(uintptr_t)*p, uintptr_t sub, mi_memory_order mo) { + (void)(mo); + return (uintptr_t)MI_64(_InterlockedExchangeAdd)((volatile msc_intptr_t*)p, -((msc_intptr_t)sub)); +} +static inline uintptr_t mi_atomic_fetch_and_explicit(_Atomic(uintptr_t)*p, uintptr_t x, mi_memory_order mo) { + (void)(mo); + return (uintptr_t)MI_64(_InterlockedAnd)((volatile msc_intptr_t*)p, (msc_intptr_t)x); +} +static inline uintptr_t mi_atomic_fetch_or_explicit(_Atomic(uintptr_t)*p, uintptr_t x, mi_memory_order mo) { + (void)(mo); + return (uintptr_t)MI_64(_InterlockedOr)((volatile msc_intptr_t*)p, (msc_intptr_t)x); +} +static inline bool mi_atomic_compare_exchange_strong_explicit(_Atomic(uintptr_t)*p, uintptr_t* expected, uintptr_t desired, mi_memory_order mo1, mi_memory_order mo2) { + (void)(mo1); (void)(mo2); + uintptr_t read = (uintptr_t)MI_64(_InterlockedCompareExchange)((volatile msc_intptr_t*)p, (msc_intptr_t)desired, (msc_intptr_t)(*expected)); + if (read == *expected) { + return true; + } + else { + *expected = read; + return false; + } +} +static inline bool mi_atomic_compare_exchange_weak_explicit(_Atomic(uintptr_t)*p, uintptr_t* expected, uintptr_t desired, mi_memory_order mo1, mi_memory_order mo2) { + return mi_atomic_compare_exchange_strong_explicit(p, expected, desired, mo1, mo2); +} +static inline uintptr_t mi_atomic_exchange_explicit(_Atomic(uintptr_t)*p, uintptr_t exchange, mi_memory_order mo) { + (void)(mo); + return (uintptr_t)MI_64(_InterlockedExchange)((volatile msc_intptr_t*)p, (msc_intptr_t)exchange); +} +static inline void mi_atomic_thread_fence(mi_memory_order mo) { + (void)(mo); + _Atomic(uintptr_t) x = 0; + mi_atomic_exchange_explicit(&x, 1, mo); +} +static inline uintptr_t mi_atomic_load_explicit(_Atomic(uintptr_t) const* p, mi_memory_order mo) { + (void)(mo); +#if defined(_M_IX86) || defined(_M_X64) + return *p; +#else + uintptr_t x = *p; + if (mo > mi_memory_order_relaxed) { + while (!mi_atomic_compare_exchange_weak_explicit((_Atomic(uintptr_t)*)p, &x, x, mo, mi_memory_order_relaxed)) { /* nothing */ }; + } + return x; +#endif +} +static inline void mi_atomic_store_explicit(_Atomic(uintptr_t)*p, uintptr_t x, mi_memory_order mo) { + (void)(mo); +#if defined(_M_IX86) || defined(_M_X64) + *p = x; +#else + mi_atomic_exchange_explicit(p, x, mo); +#endif +} +static inline int64_t mi_atomic_loadi64_explicit(_Atomic(int64_t)*p, mi_memory_order mo) { + (void)(mo); +#if defined(_M_X64) + return *p; +#else + int64_t old = *p; + int64_t x = old; + while ((old = InterlockedCompareExchange64(p, x, old)) != x) { + x = old; + } + return x; +#endif +} +static inline void mi_atomic_storei64_explicit(_Atomic(int64_t)*p, int64_t x, mi_memory_order mo) { + (void)(mo); +#if defined(x_M_IX86) || defined(_M_X64) + *p = x; +#else + InterlockedExchange64(p, x); +#endif +} + +// These are used by the statistics +static inline int64_t mi_atomic_addi64_relaxed(volatile _Atomic(int64_t)*p, int64_t add) { +#ifdef _WIN64 + return (int64_t)mi_atomic_addi((int64_t*)p, add); +#else + int64_t current; + int64_t sum; + do { + current = *p; + sum = current + add; + } while (_InterlockedCompareExchange64(p, sum, current) != current); + return current; +#endif +} +static inline void mi_atomic_maxi64_relaxed(volatile _Atomic(int64_t)*p, int64_t x) { + int64_t current; + do { + current = *p; + } while (current < x && _InterlockedCompareExchange64(p, x, current) != current); +} + +static inline void mi_atomic_addi64_acq_rel(volatile _Atomic(int64_t*)p, int64_t i) { + mi_atomic_addi64_relaxed(p, i); +} + +static inline bool mi_atomic_casi64_strong_acq_rel(volatile _Atomic(int64_t*)p, int64_t* exp, int64_t des) { + int64_t read = _InterlockedCompareExchange64(p, des, *exp); + if (read == *exp) { + return true; + } + else { + *exp = read; + return false; + } +} + +// The pointer macros cast to `uintptr_t`. +#define mi_atomic_load_ptr_acquire(tp,p) (tp*)mi_atomic_load_acquire((_Atomic(uintptr_t)*)(p)) +#define mi_atomic_load_ptr_relaxed(tp,p) (tp*)mi_atomic_load_relaxed((_Atomic(uintptr_t)*)(p)) +#define mi_atomic_store_ptr_release(tp,p,x) mi_atomic_store_release((_Atomic(uintptr_t)*)(p),(uintptr_t)(x)) +#define mi_atomic_store_ptr_relaxed(tp,p,x) mi_atomic_store_relaxed((_Atomic(uintptr_t)*)(p),(uintptr_t)(x)) +#define mi_atomic_cas_ptr_weak_release(tp,p,exp,des) mi_atomic_cas_weak_release((_Atomic(uintptr_t)*)(p),(uintptr_t*)exp,(uintptr_t)des) +#define mi_atomic_cas_ptr_weak_acq_rel(tp,p,exp,des) mi_atomic_cas_weak_acq_rel((_Atomic(uintptr_t)*)(p),(uintptr_t*)exp,(uintptr_t)des) +#define mi_atomic_cas_ptr_strong_release(tp,p,exp,des) mi_atomic_cas_strong_release((_Atomic(uintptr_t)*)(p),(uintptr_t*)exp,(uintptr_t)des) +#define mi_atomic_exchange_ptr_release(tp,p,x) (tp*)mi_atomic_exchange_release((_Atomic(uintptr_t)*)(p),(uintptr_t)x) +#define mi_atomic_exchange_ptr_acq_rel(tp,p,x) (tp*)mi_atomic_exchange_acq_rel((_Atomic(uintptr_t)*)(p),(uintptr_t)x) + +#define mi_atomic_loadi64_acquire(p) mi_atomic(loadi64_explicit)(p,mi_memory_order(acquire)) +#define mi_atomic_loadi64_relaxed(p) mi_atomic(loadi64_explicit)(p,mi_memory_order(relaxed)) +#define mi_atomic_storei64_release(p,x) mi_atomic(storei64_explicit)(p,x,mi_memory_order(release)) +#define mi_atomic_storei64_relaxed(p,x) mi_atomic(storei64_explicit)(p,x,mi_memory_order(relaxed)) + + +#endif + + +// Atomically add a signed value; returns the previous value. +static inline intptr_t mi_atomic_addi(_Atomic(intptr_t)*p, intptr_t add) { + return (intptr_t)mi_atomic_add_acq_rel((_Atomic(uintptr_t)*)p, (uintptr_t)add); +} + +// Atomically subtract a signed value; returns the previous value. +static inline intptr_t mi_atomic_subi(_Atomic(intptr_t)*p, intptr_t sub) { + return (intptr_t)mi_atomic_addi(p, -sub); +} + +typedef _Atomic(uintptr_t) mi_atomic_once_t; + +// Returns true only on the first invocation +static inline bool mi_atomic_once( mi_atomic_once_t* once ) { + if (mi_atomic_load_relaxed(once) != 0) return false; // quick test + uintptr_t expected = 0; + return mi_atomic_cas_strong_acq_rel(once, &expected, (uintptr_t)1); // try to set to 1 +} + +typedef _Atomic(uintptr_t) mi_atomic_guard_t; + +// Allows only one thread to execute at a time +#define mi_atomic_guard(guard) \ + uintptr_t _mi_guard_expected = 0; \ + for(bool _mi_guard_once = true; \ + _mi_guard_once && mi_atomic_cas_strong_acq_rel(guard,&_mi_guard_expected,(uintptr_t)1); \ + (mi_atomic_store_release(guard,(uintptr_t)0), _mi_guard_once = false) ) + + + +// Yield +#if defined(__cplusplus) +#include +static inline void mi_atomic_yield(void) { + std::this_thread::yield(); +} +#elif defined(_WIN32) +#define WIN32_LEAN_AND_MEAN +#include +static inline void mi_atomic_yield(void) { + YieldProcessor(); +} +#elif defined(__SSE2__) +#include +static inline void mi_atomic_yield(void) { + _mm_pause(); +} +#elif (defined(__GNUC__) || defined(__clang__)) && \ + (defined(__x86_64__) || defined(__i386__) || \ + defined(__aarch64__) || defined(__arm__) || \ + defined(__powerpc__) || defined(__ppc__) || defined(__PPC__) || defined(__POWERPC__)) +#if defined(__x86_64__) || defined(__i386__) +static inline void mi_atomic_yield(void) { + __asm__ volatile ("pause" ::: "memory"); +} +#elif defined(__aarch64__) +static inline void mi_atomic_yield(void) { + __asm__ volatile("wfe"); +} +#elif defined(__arm__) +#if __ARM_ARCH >= 7 +static inline void mi_atomic_yield(void) { + __asm__ volatile("yield" ::: "memory"); +} +#else +static inline void mi_atomic_yield(void) { + __asm__ volatile ("nop" ::: "memory"); +} +#endif +#elif defined(__powerpc__) || defined(__ppc__) || defined(__PPC__) || defined(__POWERPC__) +#ifdef __APPLE__ +static inline void mi_atomic_yield(void) { + __asm__ volatile ("or r27,r27,r27" ::: "memory"); +} +#else +static inline void mi_atomic_yield(void) { + __asm__ __volatile__ ("or 27,27,27" ::: "memory"); +} +#endif +#endif +#elif defined(__sun) +// Fallback for other archs +#include +static inline void mi_atomic_yield(void) { + smt_pause(); +} +#elif defined(__wasi__) +#include +static inline void mi_atomic_yield(void) { + sched_yield(); +} +#else +#include +static inline void mi_atomic_yield(void) { + sleep(0); +} +#endif + + +#endif // __MIMALLOC_ATOMIC_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/mimalloc/mimalloc/internal.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/mimalloc/mimalloc/internal.h new file mode 100644 index 0000000000000000000000000000000000000000..a7daa3a40a4c0bc303772ca2914f15287027f344 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/mimalloc/mimalloc/internal.h @@ -0,0 +1,969 @@ +/* ---------------------------------------------------------------------------- +Copyright (c) 2018-2023, Microsoft Research, Daan Leijen +This is free software; you can redistribute it and/or modify it under the +terms of the MIT license. A copy of the license can be found in the file +"LICENSE" at the root of this distribution. +-----------------------------------------------------------------------------*/ +#pragma once +#ifndef MIMALLOC_INTERNAL_H +#define MIMALLOC_INTERNAL_H + + +// -------------------------------------------------------------------------- +// This file contains the internal API's of mimalloc and various utility +// functions and macros. +// -------------------------------------------------------------------------- + +#include "types.h" +#include "track.h" + +#if (MI_DEBUG>0) +#define mi_trace_message(...) _mi_trace_message(__VA_ARGS__) +#else +#define mi_trace_message(...) +#endif + +#if defined(__EMSCRIPTEN__) && !defined(__wasi__) +#define __wasi__ +#endif + +#if defined(__cplusplus) +#define mi_decl_externc extern "C" +#else +#define mi_decl_externc +#endif + +// pthreads +#if !defined(_WIN32) && !defined(__wasi__) +#define MI_USE_PTHREADS +#include +#endif + +// "options.c" +void _mi_fputs(mi_output_fun* out, void* arg, const char* prefix, const char* message); +void _mi_fprintf(mi_output_fun* out, void* arg, const char* fmt, ...); +void _mi_warning_message(const char* fmt, ...); +void _mi_verbose_message(const char* fmt, ...); +void _mi_trace_message(const char* fmt, ...); +void _mi_options_init(void); +void _mi_error_message(int err, const char* fmt, ...); + +// random.c +void _mi_random_init(mi_random_ctx_t* ctx); +void _mi_random_init_weak(mi_random_ctx_t* ctx); +void _mi_random_reinit_if_weak(mi_random_ctx_t * ctx); +void _mi_random_split(mi_random_ctx_t* ctx, mi_random_ctx_t* new_ctx); +uintptr_t _mi_random_next(mi_random_ctx_t* ctx); +uintptr_t _mi_heap_random_next(mi_heap_t* heap); +uintptr_t _mi_os_random_weak(uintptr_t extra_seed); +static inline uintptr_t _mi_random_shuffle(uintptr_t x); + +// init.c +extern mi_decl_cache_align mi_stats_t _mi_stats_main; +extern mi_decl_cache_align const mi_page_t _mi_page_empty; +bool _mi_is_main_thread(void); +size_t _mi_current_thread_count(void); +bool _mi_preloading(void); // true while the C runtime is not initialized yet +mi_threadid_t _mi_thread_id(void) mi_attr_noexcept; +mi_heap_t* _mi_heap_main_get(void); // statically allocated main backing heap +void _mi_thread_done(mi_heap_t* heap); +void _mi_thread_data_collect(void); +void _mi_tld_init(mi_tld_t* tld, mi_heap_t* bheap); + +// os.c +void _mi_os_init(void); // called from process init +void* _mi_os_alloc(size_t size, mi_memid_t* memid, mi_stats_t* stats); +void _mi_os_free(void* p, size_t size, mi_memid_t memid, mi_stats_t* stats); +void _mi_os_free_ex(void* p, size_t size, bool still_committed, mi_memid_t memid, mi_stats_t* stats); + +size_t _mi_os_page_size(void); +size_t _mi_os_good_alloc_size(size_t size); +bool _mi_os_has_overcommit(void); +bool _mi_os_has_virtual_reserve(void); + +bool _mi_os_purge(void* p, size_t size, mi_stats_t* stats); +bool _mi_os_reset(void* addr, size_t size, mi_stats_t* tld_stats); +bool _mi_os_commit(void* p, size_t size, bool* is_zero, mi_stats_t* stats); +bool _mi_os_decommit(void* addr, size_t size, mi_stats_t* stats); +bool _mi_os_protect(void* addr, size_t size); +bool _mi_os_unprotect(void* addr, size_t size); +bool _mi_os_purge(void* p, size_t size, mi_stats_t* stats); +bool _mi_os_purge_ex(void* p, size_t size, bool allow_reset, mi_stats_t* stats); + +void* _mi_os_alloc_aligned(size_t size, size_t alignment, bool commit, bool allow_large, mi_memid_t* memid, mi_stats_t* stats); +void* _mi_os_alloc_aligned_at_offset(size_t size, size_t alignment, size_t align_offset, bool commit, bool allow_large, mi_memid_t* memid, mi_stats_t* tld_stats); + +void* _mi_os_get_aligned_hint(size_t try_alignment, size_t size); +bool _mi_os_use_large_page(size_t size, size_t alignment); +size_t _mi_os_large_page_size(void); + +void* _mi_os_alloc_huge_os_pages(size_t pages, int numa_node, mi_msecs_t max_secs, size_t* pages_reserved, size_t* psize, mi_memid_t* memid); + +// arena.c +mi_arena_id_t _mi_arena_id_none(void); +void _mi_arena_free(void* p, size_t size, size_t still_committed_size, mi_memid_t memid, mi_stats_t* stats); +void* _mi_arena_alloc(size_t size, bool commit, bool allow_large, mi_arena_id_t req_arena_id, mi_memid_t* memid, mi_os_tld_t* tld); +void* _mi_arena_alloc_aligned(size_t size, size_t alignment, size_t align_offset, bool commit, bool allow_large, mi_arena_id_t req_arena_id, mi_memid_t* memid, mi_os_tld_t* tld); +bool _mi_arena_memid_is_suitable(mi_memid_t memid, mi_arena_id_t request_arena_id); +bool _mi_arena_contains(const void* p); +void _mi_arena_collect(bool force_purge, mi_stats_t* stats); +void _mi_arena_unsafe_destroy_all(mi_stats_t* stats); + +// "segment-map.c" +void _mi_segment_map_allocated_at(const mi_segment_t* segment); +void _mi_segment_map_freed_at(const mi_segment_t* segment); + +// "segment.c" +extern mi_abandoned_pool_t _mi_abandoned_default; // global abandoned pool +mi_page_t* _mi_segment_page_alloc(mi_heap_t* heap, size_t block_size, size_t page_alignment, mi_segments_tld_t* tld, mi_os_tld_t* os_tld); +void _mi_segment_page_free(mi_page_t* page, bool force, mi_segments_tld_t* tld); +void _mi_segment_page_abandon(mi_page_t* page, mi_segments_tld_t* tld); +bool _mi_segment_try_reclaim_abandoned( mi_heap_t* heap, bool try_all, mi_segments_tld_t* tld); +void _mi_segment_thread_collect(mi_segments_tld_t* tld); +bool _mi_abandoned_pool_visit_blocks(mi_abandoned_pool_t* pool, uint8_t page_tag, bool visit_blocks, mi_block_visit_fun* visitor, void* arg); + + +#if MI_HUGE_PAGE_ABANDON +void _mi_segment_huge_page_free(mi_segment_t* segment, mi_page_t* page, mi_block_t* block); +#else +void _mi_segment_huge_page_reset(mi_segment_t* segment, mi_page_t* page, mi_block_t* block); +#endif + +uint8_t* _mi_segment_page_start(const mi_segment_t* segment, const mi_page_t* page, size_t* page_size); // page start for any page +void _mi_abandoned_reclaim_all(mi_heap_t* heap, mi_segments_tld_t* tld); +void _mi_abandoned_await_readers(mi_abandoned_pool_t *pool); +void _mi_abandoned_collect(mi_heap_t* heap, bool force, mi_segments_tld_t* tld); + +// "page.c" +void* _mi_malloc_generic(mi_heap_t* heap, size_t size, bool zero, size_t huge_alignment) mi_attr_noexcept mi_attr_malloc; + +void _mi_page_retire(mi_page_t* page) mi_attr_noexcept; // free the page if there are no other pages with many free blocks +void _mi_page_unfull(mi_page_t* page); +void _mi_page_free(mi_page_t* page, mi_page_queue_t* pq, bool force); // free the page +void _mi_page_abandon(mi_page_t* page, mi_page_queue_t* pq); // abandon the page, to be picked up by another thread... +void _mi_heap_delayed_free_all(mi_heap_t* heap); +bool _mi_heap_delayed_free_partial(mi_heap_t* heap); +void _mi_heap_collect_retired(mi_heap_t* heap, bool force); + +void _mi_page_use_delayed_free(mi_page_t* page, mi_delayed_t delay, bool override_never); +bool _mi_page_try_use_delayed_free(mi_page_t* page, mi_delayed_t delay, bool override_never); +size_t _mi_page_queue_append(mi_heap_t* heap, mi_page_queue_t* pq, mi_page_queue_t* append); +void _mi_deferred_free(mi_heap_t* heap, bool force); + +void _mi_page_free_collect(mi_page_t* page,bool force); +void _mi_page_reclaim(mi_heap_t* heap, mi_page_t* page); // callback from segments + +size_t _mi_bin_size(uint8_t bin); // for stats +uint8_t _mi_bin(size_t size); // for stats + +// "heap.c" +void _mi_heap_init_ex(mi_heap_t* heap, mi_tld_t* tld, mi_arena_id_t arena_id, bool no_reclaim, uint8_t tag); +void _mi_heap_destroy_pages(mi_heap_t* heap); +void _mi_heap_collect_abandon(mi_heap_t* heap); +void _mi_heap_set_default_direct(mi_heap_t* heap); +bool _mi_heap_memid_is_suitable(mi_heap_t* heap, mi_memid_t memid); +void _mi_heap_unsafe_destroy_all(void); +void _mi_heap_area_init(mi_heap_area_t* area, mi_page_t* page); +bool _mi_heap_area_visit_blocks(const mi_heap_area_t* area, mi_page_t *page, mi_block_visit_fun* visitor, void* arg); + +// "stats.c" +void _mi_stats_done(mi_stats_t* stats); +mi_msecs_t _mi_clock_now(void); +mi_msecs_t _mi_clock_end(mi_msecs_t start); +mi_msecs_t _mi_clock_start(void); + +// "alloc.c" +void* _mi_page_malloc(mi_heap_t* heap, mi_page_t* page, size_t size, bool zero) mi_attr_noexcept; // called from `_mi_malloc_generic` +void* _mi_heap_malloc_zero(mi_heap_t* heap, size_t size, bool zero) mi_attr_noexcept; +void* _mi_heap_malloc_zero_ex(mi_heap_t* heap, size_t size, bool zero, size_t huge_alignment) mi_attr_noexcept; // called from `_mi_heap_malloc_aligned` +void* _mi_heap_realloc_zero(mi_heap_t* heap, void* p, size_t newsize, bool zero) mi_attr_noexcept; +mi_block_t* _mi_page_ptr_unalign(const mi_segment_t* segment, const mi_page_t* page, const void* p); +bool _mi_free_delayed_block(mi_block_t* block); +void _mi_free_generic(const mi_segment_t* segment, mi_page_t* page, bool is_local, void* p) mi_attr_noexcept; // for runtime integration +void _mi_padding_shrink(const mi_page_t* page, const mi_block_t* block, const size_t min_size); + +// option.c, c primitives +char _mi_toupper(char c); +int _mi_strnicmp(const char* s, const char* t, size_t n); +void _mi_strlcpy(char* dest, const char* src, size_t dest_size); +void _mi_strlcat(char* dest, const char* src, size_t dest_size); +size_t _mi_strlen(const char* s); +size_t _mi_strnlen(const char* s, size_t max_len); + + +#if MI_DEBUG>1 +bool _mi_page_is_valid(mi_page_t* page); +#endif + + +// ------------------------------------------------------ +// Branches +// ------------------------------------------------------ + +#if defined(__GNUC__) || defined(__clang__) +#define mi_unlikely(x) (__builtin_expect(!!(x),false)) +#define mi_likely(x) (__builtin_expect(!!(x),true)) +#elif (defined(__cplusplus) && (__cplusplus >= 202002L)) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L) +#define mi_unlikely(x) (x) [[unlikely]] +#define mi_likely(x) (x) [[likely]] +#else +#define mi_unlikely(x) (x) +#define mi_likely(x) (x) +#endif + +#ifndef __has_builtin +#define __has_builtin(x) 0 +#endif + + +/* ----------------------------------------------------------- + Error codes passed to `_mi_fatal_error` + All are recoverable but EFAULT is a serious error and aborts by default in secure mode. + For portability define undefined error codes using common Unix codes: + +----------------------------------------------------------- */ +#include +#ifndef EAGAIN // double free +#define EAGAIN (11) +#endif +#ifndef ENOMEM // out of memory +#define ENOMEM (12) +#endif +#ifndef EFAULT // corrupted free-list or meta-data +#define EFAULT (14) +#endif +#ifndef EINVAL // trying to free an invalid pointer +#define EINVAL (22) +#endif +#ifndef EOVERFLOW // count*size overflow +#define EOVERFLOW (75) +#endif + + +/* ----------------------------------------------------------- + Inlined definitions +----------------------------------------------------------- */ +#define MI_UNUSED(x) (void)(x) +#if (MI_DEBUG>0) +#define MI_UNUSED_RELEASE(x) +#else +#define MI_UNUSED_RELEASE(x) MI_UNUSED(x) +#endif + +#define MI_INIT4(x) x(),x(),x(),x() +#define MI_INIT8(x) MI_INIT4(x),MI_INIT4(x) +#define MI_INIT16(x) MI_INIT8(x),MI_INIT8(x) +#define MI_INIT32(x) MI_INIT16(x),MI_INIT16(x) +#define MI_INIT64(x) MI_INIT32(x),MI_INIT32(x) +#define MI_INIT128(x) MI_INIT64(x),MI_INIT64(x) +#define MI_INIT256(x) MI_INIT128(x),MI_INIT128(x) + + +#include +// initialize a local variable to zero; use memset as compilers optimize constant sized memset's +#define _mi_memzero_var(x) memset(&x,0,sizeof(x)) + +// Is `x` a power of two? (0 is considered a power of two) +static inline bool _mi_is_power_of_two(uintptr_t x) { + return ((x & (x - 1)) == 0); +} + +// Is a pointer aligned? +static inline bool _mi_is_aligned(void* p, size_t alignment) { + mi_assert_internal(alignment != 0); + return (((uintptr_t)p % alignment) == 0); +} + +// Align upwards +static inline uintptr_t _mi_align_up(uintptr_t sz, size_t alignment) { + mi_assert_internal(alignment != 0); + uintptr_t mask = alignment - 1; + if ((alignment & mask) == 0) { // power of two? + return ((sz + mask) & ~mask); + } + else { + return (((sz + mask)/alignment)*alignment); + } +} + +// Align downwards +static inline uintptr_t _mi_align_down(uintptr_t sz, size_t alignment) { + mi_assert_internal(alignment != 0); + uintptr_t mask = alignment - 1; + if ((alignment & mask) == 0) { // power of two? + return (sz & ~mask); + } + else { + return ((sz / alignment) * alignment); + } +} + +// Divide upwards: `s <= _mi_divide_up(s,d)*d < s+d`. +static inline uintptr_t _mi_divide_up(uintptr_t size, size_t divider) { + mi_assert_internal(divider != 0); + return (divider == 0 ? size : ((size + divider - 1) / divider)); +} + +// Is memory zero initialized? +static inline bool mi_mem_is_zero(const void* p, size_t size) { + for (size_t i = 0; i < size; i++) { + if (((uint8_t*)p)[i] != 0) return false; + } + return true; +} + + +// Align a byte size to a size in _machine words_, +// i.e. byte size == `wsize*sizeof(void*)`. +static inline size_t _mi_wsize_from_size(size_t size) { + mi_assert_internal(size <= SIZE_MAX - sizeof(uintptr_t)); + return (size + sizeof(uintptr_t) - 1) / sizeof(uintptr_t); +} + +// Overflow detecting multiply +#if __has_builtin(__builtin_umul_overflow) || (defined(__GNUC__) && (__GNUC__ >= 5)) +#include // UINT_MAX, ULONG_MAX +#if defined(_CLOCK_T) // for Illumos +#undef _CLOCK_T +#endif +static inline bool mi_mul_overflow(size_t count, size_t size, size_t* total) { + #if (SIZE_MAX == ULONG_MAX) + return __builtin_umull_overflow(count, size, (unsigned long *)total); + #elif (SIZE_MAX == UINT_MAX) + return __builtin_umul_overflow(count, size, (unsigned int *)total); + #else + return __builtin_umulll_overflow(count, size, (unsigned long long *)total); + #endif +} +#else /* __builtin_umul_overflow is unavailable */ +static inline bool mi_mul_overflow(size_t count, size_t size, size_t* total) { + #define MI_MUL_NO_OVERFLOW ((size_t)1 << (4*sizeof(size_t))) // sqrt(SIZE_MAX) + *total = count * size; + // note: gcc/clang optimize this to directly check the overflow flag + return ((size >= MI_MUL_NO_OVERFLOW || count >= MI_MUL_NO_OVERFLOW) && size > 0 && (SIZE_MAX / size) < count); +} +#endif + +// Safe multiply `count*size` into `total`; return `true` on overflow. +static inline bool mi_count_size_overflow(size_t count, size_t size, size_t* total) { + if (count==1) { // quick check for the case where count is one (common for C++ allocators) + *total = size; + return false; + } + else if mi_unlikely(mi_mul_overflow(count, size, total)) { + #if MI_DEBUG > 0 + _mi_error_message(EOVERFLOW, "allocation request is too large (%zu * %zu bytes)\n", count, size); + #endif + *total = SIZE_MAX; + return true; + } + else return false; +} + + +/*---------------------------------------------------------------------------------------- + Heap functions +------------------------------------------------------------------------------------------- */ + +extern const mi_heap_t _mi_heap_empty; // read-only empty heap, initial value of the thread local default heap + +static inline bool mi_heap_is_backing(const mi_heap_t* heap) { + return (heap->tld->heap_backing == heap); +} + +static inline bool mi_heap_is_initialized(mi_heap_t* heap) { + mi_assert_internal(heap != NULL); + return (heap != &_mi_heap_empty); +} + +static inline uintptr_t _mi_ptr_cookie(const void* p) { + extern mi_heap_t _mi_heap_main; + mi_assert_internal(_mi_heap_main.cookie != 0); + return ((uintptr_t)p ^ _mi_heap_main.cookie); +} + +/* ----------------------------------------------------------- + Pages +----------------------------------------------------------- */ + +static inline mi_page_t* _mi_heap_get_free_small_page(mi_heap_t* heap, size_t size) { + mi_assert_internal(size <= (MI_SMALL_SIZE_MAX + MI_PADDING_SIZE)); + const size_t idx = _mi_wsize_from_size(size); + mi_assert_internal(idx < MI_PAGES_DIRECT); + return heap->pages_free_direct[idx]; +} + +// Segment that contains the pointer +// Large aligned blocks may be aligned at N*MI_SEGMENT_SIZE (inside a huge segment > MI_SEGMENT_SIZE), +// and we need align "down" to the segment info which is `MI_SEGMENT_SIZE` bytes before it; +// therefore we align one byte before `p`. +static inline mi_segment_t* _mi_ptr_segment(const void* p) { + mi_assert_internal(p != NULL); + return (mi_segment_t*)(((uintptr_t)p - 1) & ~MI_SEGMENT_MASK); +} + +static inline mi_page_t* mi_slice_to_page(mi_slice_t* s) { + mi_assert_internal(s->slice_offset== 0 && s->slice_count > 0); + return (mi_page_t*)(s); +} + +static inline mi_slice_t* mi_page_to_slice(mi_page_t* p) { + mi_assert_internal(p->slice_offset== 0 && p->slice_count > 0); + return (mi_slice_t*)(p); +} + +// Segment belonging to a page +static inline mi_segment_t* _mi_page_segment(const mi_page_t* page) { + mi_segment_t* segment = _mi_ptr_segment(page); + mi_assert_internal(segment == NULL || ((mi_slice_t*)page >= segment->slices && (mi_slice_t*)page < segment->slices + segment->slice_entries)); + return segment; +} + +static inline mi_slice_t* mi_slice_first(const mi_slice_t* slice) { + mi_slice_t* start = (mi_slice_t*)((uint8_t*)slice - slice->slice_offset); + mi_assert_internal(start >= _mi_ptr_segment(slice)->slices); + mi_assert_internal(start->slice_offset == 0); + mi_assert_internal(start + start->slice_count > slice); + return start; +} + +// Get the page containing the pointer (performance critical as it is called in mi_free) +static inline mi_page_t* _mi_segment_page_of(const mi_segment_t* segment, const void* p) { + mi_assert_internal(p > (void*)segment); + ptrdiff_t diff = (uint8_t*)p - (uint8_t*)segment; + mi_assert_internal(diff > 0 && diff <= (ptrdiff_t)MI_SEGMENT_SIZE); + size_t idx = (size_t)diff >> MI_SEGMENT_SLICE_SHIFT; + mi_assert_internal(idx <= segment->slice_entries); + mi_slice_t* slice0 = (mi_slice_t*)&segment->slices[idx]; + mi_slice_t* slice = mi_slice_first(slice0); // adjust to the block that holds the page data + mi_assert_internal(slice->slice_offset == 0); + mi_assert_internal(slice >= segment->slices && slice < segment->slices + segment->slice_entries); + return mi_slice_to_page(slice); +} + +// Quick page start for initialized pages +static inline uint8_t* _mi_page_start(const mi_segment_t* segment, const mi_page_t* page, size_t* page_size) { + return _mi_segment_page_start(segment, page, page_size); +} + +// Get the page containing the pointer +static inline mi_page_t* _mi_ptr_page(void* p) { + return _mi_segment_page_of(_mi_ptr_segment(p), p); +} + +// Get the block size of a page (special case for huge objects) +static inline size_t mi_page_block_size(const mi_page_t* page) { + const size_t bsize = page->xblock_size; + mi_assert_internal(bsize > 0); + if mi_likely(bsize < MI_HUGE_BLOCK_SIZE) { + return bsize; + } + else { + size_t psize; + _mi_segment_page_start(_mi_page_segment(page), page, &psize); + return psize; + } +} + +static inline bool mi_page_is_huge(const mi_page_t* page) { + return (_mi_page_segment(page)->kind == MI_SEGMENT_HUGE); +} + +// Get the usable block size of a page without fixed padding. +// This may still include internal padding due to alignment and rounding up size classes. +static inline size_t mi_page_usable_block_size(const mi_page_t* page) { + return mi_page_block_size(page) - MI_PADDING_SIZE; +} + +// size of a segment +static inline size_t mi_segment_size(mi_segment_t* segment) { + return segment->segment_slices * MI_SEGMENT_SLICE_SIZE; +} + +static inline uint8_t* mi_segment_end(mi_segment_t* segment) { + return (uint8_t*)segment + mi_segment_size(segment); +} + +// Thread free access +static inline mi_block_t* mi_page_thread_free(const mi_page_t* page) { + return (mi_block_t*)(mi_atomic_load_relaxed(&((mi_page_t*)page)->xthread_free) & ~3); +} + +static inline mi_delayed_t mi_page_thread_free_flag(const mi_page_t* page) { + return (mi_delayed_t)(mi_atomic_load_relaxed(&((mi_page_t*)page)->xthread_free) & 3); +} + +// Heap access +static inline mi_heap_t* mi_page_heap(const mi_page_t* page) { + return (mi_heap_t*)(mi_atomic_load_relaxed(&((mi_page_t*)page)->xheap)); +} + +static inline void mi_page_set_heap(mi_page_t* page, mi_heap_t* heap) { + mi_assert_internal(mi_page_thread_free_flag(page) != MI_DELAYED_FREEING); + mi_atomic_store_release(&page->xheap,(uintptr_t)heap); +} + +// Thread free flag helpers +static inline mi_block_t* mi_tf_block(mi_thread_free_t tf) { + return (mi_block_t*)(tf & ~0x03); +} +static inline mi_delayed_t mi_tf_delayed(mi_thread_free_t tf) { + return (mi_delayed_t)(tf & 0x03); +} +static inline mi_thread_free_t mi_tf_make(mi_block_t* block, mi_delayed_t delayed) { + return (mi_thread_free_t)((uintptr_t)block | (uintptr_t)delayed); +} +static inline mi_thread_free_t mi_tf_set_delayed(mi_thread_free_t tf, mi_delayed_t delayed) { + return mi_tf_make(mi_tf_block(tf),delayed); +} +static inline mi_thread_free_t mi_tf_set_block(mi_thread_free_t tf, mi_block_t* block) { + return mi_tf_make(block, mi_tf_delayed(tf)); +} + +// are all blocks in a page freed? +// note: needs up-to-date used count, (as the `xthread_free` list may not be empty). see `_mi_page_collect_free`. +static inline bool mi_page_all_free(const mi_page_t* page) { + mi_assert_internal(page != NULL); + return (page->used == 0); +} + +// are there any available blocks? +static inline bool mi_page_has_any_available(const mi_page_t* page) { + mi_assert_internal(page != NULL && page->reserved > 0); + return (page->used < page->reserved || (mi_page_thread_free(page) != NULL)); +} + +// are there immediately available blocks, i.e. blocks available on the free list. +static inline bool mi_page_immediate_available(const mi_page_t* page) { + mi_assert_internal(page != NULL); + return (page->free != NULL); +} + +// is more than 7/8th of a page in use? +static inline bool mi_page_mostly_used(const mi_page_t* page) { + if (page==NULL) return true; + uint16_t frac = page->reserved / 8U; + return (page->reserved - page->used <= frac); +} + +static inline mi_page_queue_t* mi_page_queue(const mi_heap_t* heap, size_t size) { + return &((mi_heap_t*)heap)->pages[_mi_bin(size)]; +} + + + +//----------------------------------------------------------- +// Page flags +//----------------------------------------------------------- +static inline bool mi_page_is_in_full(const mi_page_t* page) { + return page->flags.x.in_full; +} + +static inline void mi_page_set_in_full(mi_page_t* page, bool in_full) { + page->flags.x.in_full = in_full; +} + +static inline bool mi_page_has_aligned(const mi_page_t* page) { + return page->flags.x.has_aligned; +} + +static inline void mi_page_set_has_aligned(mi_page_t* page, bool has_aligned) { + page->flags.x.has_aligned = has_aligned; +} + + +/* ------------------------------------------------------------------- +Encoding/Decoding the free list next pointers + +This is to protect against buffer overflow exploits where the +free list is mutated. Many hardened allocators xor the next pointer `p` +with a secret key `k1`, as `p^k1`. This prevents overwriting with known +values but might be still too weak: if the attacker can guess +the pointer `p` this can reveal `k1` (since `p^k1^p == k1`). +Moreover, if multiple blocks can be read as well, the attacker can +xor both as `(p1^k1) ^ (p2^k1) == p1^p2` which may reveal a lot +about the pointers (and subsequently `k1`). + +Instead mimalloc uses an extra key `k2` and encodes as `((p^k2)<<> (MI_INTPTR_BITS - shift)))); +} +static inline uintptr_t mi_rotr(uintptr_t x, uintptr_t shift) { + shift %= MI_INTPTR_BITS; + return (shift==0 ? x : ((x >> shift) | (x << (MI_INTPTR_BITS - shift)))); +} + +static inline void* mi_ptr_decode(const void* null, const mi_encoded_t x, const uintptr_t* keys) { + void* p = (void*)(mi_rotr(x - keys[0], keys[0]) ^ keys[1]); + return (p==null ? NULL : p); +} + +static inline mi_encoded_t mi_ptr_encode(const void* null, const void* p, const uintptr_t* keys) { + uintptr_t x = (uintptr_t)(p==NULL ? null : p); + return mi_rotl(x ^ keys[1], keys[0]) + keys[0]; +} + +static inline mi_block_t* mi_block_nextx( const void* null, const mi_block_t* block, const uintptr_t* keys ) { + mi_track_mem_defined(block,sizeof(mi_block_t)); + mi_block_t* next; + #ifdef MI_ENCODE_FREELIST + next = (mi_block_t*)mi_ptr_decode(null, mi_atomic_load_relaxed((_Atomic(mi_encoded_t)*)&block->next), keys); + #else + MI_UNUSED(keys); MI_UNUSED(null); + next = (mi_block_t*)mi_atomic_load_relaxed((_Atomic(mi_encoded_t)*)&block->next); + #endif + mi_track_mem_noaccess(block,sizeof(mi_block_t)); + return next; +} + +static inline void mi_block_set_nextx(const void* null, mi_block_t* block, const mi_block_t* next, const uintptr_t* keys) { + mi_track_mem_undefined(block,sizeof(mi_block_t)); + #ifdef MI_ENCODE_FREELIST + mi_atomic_store_relaxed(&block->next, mi_ptr_encode(null, next, keys)); + #else + MI_UNUSED(keys); MI_UNUSED(null); + mi_atomic_store_relaxed(&block->next, (mi_encoded_t)next); + #endif + mi_track_mem_noaccess(block,sizeof(mi_block_t)); +} + +static inline mi_block_t* mi_block_next(const mi_page_t* page, const mi_block_t* block) { + #ifdef MI_ENCODE_FREELIST + mi_block_t* next = mi_block_nextx(page,block,page->keys); + // check for free list corruption: is `next` at least in the same page? + // TODO: check if `next` is `page->block_size` aligned? + if mi_unlikely(next!=NULL && !mi_is_in_same_page(block, next)) { + _mi_error_message(EFAULT, "corrupted free list entry of size %zub at %p: value 0x%zx\n", mi_page_block_size(page), block, (uintptr_t)next); + next = NULL; + } + return next; + #else + MI_UNUSED(page); + return mi_block_nextx(page,block,NULL); + #endif +} + +static inline void mi_block_set_next(const mi_page_t* page, mi_block_t* block, const mi_block_t* next) { + #ifdef MI_ENCODE_FREELIST + mi_block_set_nextx(page,block,next, page->keys); + #else + MI_UNUSED(page); + mi_block_set_nextx(page,block,next,NULL); + #endif +} + + +// ------------------------------------------------------------------- +// commit mask +// ------------------------------------------------------------------- + +static inline void mi_commit_mask_create_empty(mi_commit_mask_t* cm) { + for (size_t i = 0; i < MI_COMMIT_MASK_FIELD_COUNT; i++) { + cm->mask[i] = 0; + } +} + +static inline void mi_commit_mask_create_full(mi_commit_mask_t* cm) { + for (size_t i = 0; i < MI_COMMIT_MASK_FIELD_COUNT; i++) { + cm->mask[i] = ~((size_t)0); + } +} + +static inline bool mi_commit_mask_is_empty(const mi_commit_mask_t* cm) { + for (size_t i = 0; i < MI_COMMIT_MASK_FIELD_COUNT; i++) { + if (cm->mask[i] != 0) return false; + } + return true; +} + +static inline bool mi_commit_mask_is_full(const mi_commit_mask_t* cm) { + for (size_t i = 0; i < MI_COMMIT_MASK_FIELD_COUNT; i++) { + if (cm->mask[i] != ~((size_t)0)) return false; + } + return true; +} + +// defined in `segment.c`: +size_t _mi_commit_mask_committed_size(const mi_commit_mask_t* cm, size_t total); +size_t _mi_commit_mask_next_run(const mi_commit_mask_t* cm, size_t* idx); + +#define mi_commit_mask_foreach(cm,idx,count) \ + idx = 0; \ + while ((count = _mi_commit_mask_next_run(cm,&idx)) > 0) { + +#define mi_commit_mask_foreach_end() \ + idx += count; \ + } + + + +/* ----------------------------------------------------------- + memory id's +----------------------------------------------------------- */ + +static inline mi_memid_t _mi_memid_create(mi_memkind_t memkind) { + mi_memid_t memid; + _mi_memzero_var(memid); + memid.memkind = memkind; + return memid; +} + +static inline mi_memid_t _mi_memid_none(void) { + return _mi_memid_create(MI_MEM_NONE); +} + +static inline mi_memid_t _mi_memid_create_os(bool committed, bool is_zero, bool is_large) { + mi_memid_t memid = _mi_memid_create(MI_MEM_OS); + memid.initially_committed = committed; + memid.initially_zero = is_zero; + memid.is_pinned = is_large; + return memid; +} + + +// ------------------------------------------------------------------- +// Fast "random" shuffle +// ------------------------------------------------------------------- + +static inline uintptr_t _mi_random_shuffle(uintptr_t x) { + if (x==0) { x = 17; } // ensure we don't get stuck in generating zeros +#if (MI_INTPTR_SIZE==8) + // by Sebastiano Vigna, see: + x ^= x >> 30; + x *= 0xbf58476d1ce4e5b9UL; + x ^= x >> 27; + x *= 0x94d049bb133111ebUL; + x ^= x >> 31; +#elif (MI_INTPTR_SIZE==4) + // by Chris Wellons, see: + x ^= x >> 16; + x *= 0x7feb352dUL; + x ^= x >> 15; + x *= 0x846ca68bUL; + x ^= x >> 16; +#endif + return x; +} + +// ------------------------------------------------------------------- +// Optimize numa node access for the common case (= one node) +// ------------------------------------------------------------------- + +int _mi_os_numa_node_get(mi_os_tld_t* tld); +size_t _mi_os_numa_node_count_get(void); + +extern _Atomic(size_t) _mi_numa_node_count; +static inline int _mi_os_numa_node(mi_os_tld_t* tld) { + if mi_likely(mi_atomic_load_relaxed(&_mi_numa_node_count) == 1) { return 0; } + else return _mi_os_numa_node_get(tld); +} +static inline size_t _mi_os_numa_node_count(void) { + const size_t count = mi_atomic_load_relaxed(&_mi_numa_node_count); + if mi_likely(count > 0) { return count; } + else return _mi_os_numa_node_count_get(); +} + + + +// ----------------------------------------------------------------------- +// Count bits: trailing or leading zeros (with MI_INTPTR_BITS on all zero) +// ----------------------------------------------------------------------- + +#if defined(__GNUC__) + +#include // LONG_MAX +#define MI_HAVE_FAST_BITSCAN +static inline size_t mi_clz(uintptr_t x) { + if (x==0) return MI_INTPTR_BITS; +#if (INTPTR_MAX == LONG_MAX) + return __builtin_clzl(x); +#else + return __builtin_clzll(x); +#endif +} +static inline size_t mi_ctz(uintptr_t x) { + if (x==0) return MI_INTPTR_BITS; +#if (INTPTR_MAX == LONG_MAX) + return __builtin_ctzl(x); +#else + return __builtin_ctzll(x); +#endif +} + +#elif defined(_MSC_VER) + +#include // LONG_MAX +#include // BitScanReverse64 +#define MI_HAVE_FAST_BITSCAN +static inline size_t mi_clz(uintptr_t x) { + if (x==0) return MI_INTPTR_BITS; + unsigned long idx; +#if (INTPTR_MAX == LONG_MAX) + _BitScanReverse(&idx, x); +#else + _BitScanReverse64(&idx, x); +#endif + return ((MI_INTPTR_BITS - 1) - idx); +} +static inline size_t mi_ctz(uintptr_t x) { + if (x==0) return MI_INTPTR_BITS; + unsigned long idx; +#if (INTPTR_MAX == LONG_MAX) + _BitScanForward(&idx, x); +#else + _BitScanForward64(&idx, x); +#endif + return idx; +} + +#else +static inline size_t mi_ctz32(uint32_t x) { + // de Bruijn multiplication, see + static const unsigned char debruijn[32] = { + 0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8, + 31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9 + }; + if (x==0) return 32; + return debruijn[((x & -(int32_t)x) * 0x077CB531UL) >> 27]; +} +static inline size_t mi_clz32(uint32_t x) { + // de Bruijn multiplication, see + static const uint8_t debruijn[32] = { + 31, 22, 30, 21, 18, 10, 29, 2, 20, 17, 15, 13, 9, 6, 28, 1, + 23, 19, 11, 3, 16, 14, 7, 24, 12, 4, 8, 25, 5, 26, 27, 0 + }; + if (x==0) return 32; + x |= x >> 1; + x |= x >> 2; + x |= x >> 4; + x |= x >> 8; + x |= x >> 16; + return debruijn[(uint32_t)(x * 0x07C4ACDDUL) >> 27]; +} + +static inline size_t mi_clz(uintptr_t x) { + if (x==0) return MI_INTPTR_BITS; +#if (MI_INTPTR_BITS <= 32) + return mi_clz32((uint32_t)x); +#else + size_t count = mi_clz32((uint32_t)(x >> 32)); + if (count < 32) return count; + return (32 + mi_clz32((uint32_t)x)); +#endif +} +static inline size_t mi_ctz(uintptr_t x) { + if (x==0) return MI_INTPTR_BITS; +#if (MI_INTPTR_BITS <= 32) + return mi_ctz32((uint32_t)x); +#else + size_t count = mi_ctz32((uint32_t)x); + if (count < 32) return count; + return (32 + mi_ctz32((uint32_t)(x>>32))); +#endif +} + +#endif + +// "bit scan reverse": Return index of the highest bit (or MI_INTPTR_BITS if `x` is zero) +static inline size_t mi_bsr(uintptr_t x) { + return (x==0 ? MI_INTPTR_BITS : MI_INTPTR_BITS - 1 - mi_clz(x)); +} + + +// --------------------------------------------------------------------------------- +// Provide our own `_mi_memcpy` for potential performance optimizations. +// +// For now, only on Windows with msvc/clang-cl we optimize to `rep movsb` if +// we happen to run on x86/x64 cpu's that have "fast short rep movsb" (FSRM) support +// (AMD Zen3+ (~2020) or Intel Ice Lake+ (~2017). See also issue #201 and pr #253. +// --------------------------------------------------------------------------------- + +#if !MI_TRACK_ENABLED && defined(_WIN32) && (defined(_M_IX86) || defined(_M_X64)) +#include +extern bool _mi_cpu_has_fsrm; +static inline void _mi_memcpy(void* dst, const void* src, size_t n) { + if (_mi_cpu_has_fsrm) { + __movsb((unsigned char*)dst, (const unsigned char*)src, n); + } + else { + memcpy(dst, src, n); + } +} +static inline void _mi_memzero(void* dst, size_t n) { + if (_mi_cpu_has_fsrm) { + __stosb((unsigned char*)dst, 0, n); + } + else { + memset(dst, 0, n); + } +} +#else +static inline void _mi_memcpy(void* dst, const void* src, size_t n) { + memcpy(dst, src, n); +} +static inline void _mi_memzero(void* dst, size_t n) { + memset(dst, 0, n); +} +#endif + +// ------------------------------------------------------------------------------- +// The `_mi_memcpy_aligned` can be used if the pointers are machine-word aligned +// This is used for example in `mi_realloc`. +// ------------------------------------------------------------------------------- + +#if (defined(__GNUC__) && (__GNUC__ >= 4)) || defined(__clang__) +// On GCC/CLang we provide a hint that the pointers are word aligned. +static inline void _mi_memcpy_aligned(void* dst, const void* src, size_t n) { + mi_assert_internal(((uintptr_t)dst % MI_INTPTR_SIZE == 0) && ((uintptr_t)src % MI_INTPTR_SIZE == 0)); + void* adst = __builtin_assume_aligned(dst, MI_INTPTR_SIZE); + const void* asrc = __builtin_assume_aligned(src, MI_INTPTR_SIZE); + _mi_memcpy(adst, asrc, n); +} + +static inline void _mi_memzero_aligned(void* dst, size_t n) { + mi_assert_internal((uintptr_t)dst % MI_INTPTR_SIZE == 0); + void* adst = __builtin_assume_aligned(dst, MI_INTPTR_SIZE); + _mi_memzero(adst, n); +} +#else +// Default fallback on `_mi_memcpy` +static inline void _mi_memcpy_aligned(void* dst, const void* src, size_t n) { + mi_assert_internal(((uintptr_t)dst % MI_INTPTR_SIZE == 0) && ((uintptr_t)src % MI_INTPTR_SIZE == 0)); + _mi_memcpy(dst, src, n); +} + +static inline void _mi_memzero_aligned(void* dst, size_t n) { + mi_assert_internal((uintptr_t)dst % MI_INTPTR_SIZE == 0); + _mi_memzero(dst, n); +} +#endif + + +#endif diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/mimalloc/mimalloc/prim.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/mimalloc/mimalloc/prim.h new file mode 100644 index 0000000000000000000000000000000000000000..322ab29e6b41c24bfaaa94c6d5af103f71bfc285 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/mimalloc/mimalloc/prim.h @@ -0,0 +1,329 @@ +/* ---------------------------------------------------------------------------- +Copyright (c) 2018-2023, Microsoft Research, Daan Leijen +This is free software; you can redistribute it and/or modify it under the +terms of the MIT license. A copy of the license can be found in the file +"LICENSE" at the root of this distribution. +-----------------------------------------------------------------------------*/ +#pragma once +#ifndef MIMALLOC_PRIM_H +#define MIMALLOC_PRIM_H + + +// -------------------------------------------------------------------------- +// This file specifies the primitive portability API. +// Each OS/host needs to implement these primitives, see `src/prim` +// for implementations on Window, macOS, WASI, and Linux/Unix. +// +// note: on all primitive functions, we always have result parameters != NUL, and: +// addr != NULL and page aligned +// size > 0 and page aligned +// return value is an error code an int where 0 is success. +// -------------------------------------------------------------------------- + +// OS memory configuration +typedef struct mi_os_mem_config_s { + size_t page_size; // 4KiB + size_t large_page_size; // 2MiB + size_t alloc_granularity; // smallest allocation size (on Windows 64KiB) + bool has_overcommit; // can we reserve more memory than can be actually committed? + bool must_free_whole; // must allocated blocks be freed as a whole (false for mmap, true for VirtualAlloc) + bool has_virtual_reserve; // supports virtual address space reservation? (if true we can reserve virtual address space without using commit or physical memory) +} mi_os_mem_config_t; + +// Initialize +void _mi_prim_mem_init( mi_os_mem_config_t* config ); + +// Free OS memory +int _mi_prim_free(void* addr, size_t size ); + +// Allocate OS memory. Return NULL on error. +// The `try_alignment` is just a hint and the returned pointer does not have to be aligned. +// If `commit` is false, the virtual memory range only needs to be reserved (with no access) +// which will later be committed explicitly using `_mi_prim_commit`. +// `is_zero` is set to true if the memory was zero initialized (as on most OS's) +// pre: !commit => !allow_large +// try_alignment >= _mi_os_page_size() and a power of 2 +int _mi_prim_alloc(size_t size, size_t try_alignment, bool commit, bool allow_large, bool* is_large, bool* is_zero, void** addr); + +// Commit memory. Returns error code or 0 on success. +// For example, on Linux this would make the memory PROT_READ|PROT_WRITE. +// `is_zero` is set to true if the memory was zero initialized (e.g. on Windows) +int _mi_prim_commit(void* addr, size_t size, bool* is_zero); + +// Decommit memory. Returns error code or 0 on success. The `needs_recommit` result is true +// if the memory would need to be re-committed. For example, on Windows this is always true, +// but on Linux we could use MADV_DONTNEED to decommit which does not need a recommit. +// pre: needs_recommit != NULL +int _mi_prim_decommit(void* addr, size_t size, bool* needs_recommit); + +// Reset memory. The range keeps being accessible but the content might be reset. +// Returns error code or 0 on success. +int _mi_prim_reset(void* addr, size_t size); + +// Protect memory. Returns error code or 0 on success. +int _mi_prim_protect(void* addr, size_t size, bool protect); + +// Allocate huge (1GiB) pages possibly associated with a NUMA node. +// `is_zero` is set to true if the memory was zero initialized (as on most OS's) +// pre: size > 0 and a multiple of 1GiB. +// numa_node is either negative (don't care), or a numa node number. +int _mi_prim_alloc_huge_os_pages(void* hint_addr, size_t size, int numa_node, bool* is_zero, void** addr); + +// Return the current NUMA node +size_t _mi_prim_numa_node(void); + +// Return the number of logical NUMA nodes +size_t _mi_prim_numa_node_count(void); + +// Clock ticks +mi_msecs_t _mi_prim_clock_now(void); + +// Return process information (only for statistics) +typedef struct mi_process_info_s { + mi_msecs_t elapsed; + mi_msecs_t utime; + mi_msecs_t stime; + size_t current_rss; + size_t peak_rss; + size_t current_commit; + size_t peak_commit; + size_t page_faults; +} mi_process_info_t; + +void _mi_prim_process_info(mi_process_info_t* pinfo); + +// Default stderr output. (only for warnings etc. with verbose enabled) +// msg != NULL && _mi_strlen(msg) > 0 +void _mi_prim_out_stderr( const char* msg ); + +// Get an environment variable. (only for options) +// name != NULL, result != NULL, result_size >= 64 +bool _mi_prim_getenv(const char* name, char* result, size_t result_size); + + +// Fill a buffer with strong randomness; return `false` on error or if +// there is no strong randomization available. +bool _mi_prim_random_buf(void* buf, size_t buf_len); + +// Called on the first thread start, and should ensure `_mi_thread_done` is called on thread termination. +void _mi_prim_thread_init_auto_done(void); + +// Called on process exit and may take action to clean up resources associated with the thread auto done. +void _mi_prim_thread_done_auto_done(void); + +// Called when the default heap for a thread changes +void _mi_prim_thread_associate_default_heap(mi_heap_t* heap); + + +//------------------------------------------------------------------- +// Thread id: `_mi_prim_thread_id()` +// +// Getting the thread id should be performant as it is called in the +// fast path of `_mi_free` and we specialize for various platforms as +// inlined definitions. Regular code should call `init.c:_mi_thread_id()`. +// We only require _mi_prim_thread_id() to return a unique id +// for each thread (unequal to zero). +//------------------------------------------------------------------- + +// defined in `init.c`; do not use these directly +extern mi_decl_thread mi_heap_t* _mi_heap_default; // default heap to allocate from +extern bool _mi_process_is_initialized; // has mi_process_init been called? + +static inline mi_threadid_t _mi_prim_thread_id(void) mi_attr_noexcept; + +#ifdef MI_PRIM_THREAD_ID + +static inline mi_threadid_t _mi_prim_thread_id(void) mi_attr_noexcept { + return MI_PRIM_THREAD_ID(); +} + +#elif defined(_WIN32) + +#define WIN32_LEAN_AND_MEAN +#include +static inline mi_threadid_t _mi_prim_thread_id(void) mi_attr_noexcept { + // Windows: works on Intel and ARM in both 32- and 64-bit + return (uintptr_t)NtCurrentTeb(); +} + +// We use assembly for a fast thread id on the main platforms. The TLS layout depends on +// both the OS and libc implementation so we use specific tests for each main platform. +// If you test on another platform and it works please send a PR :-) +// see also https://akkadia.org/drepper/tls.pdf for more info on the TLS register. +#elif defined(__GNUC__) && ( \ + (defined(__GLIBC__) && (defined(__x86_64__) || defined(__i386__) || (defined(__arm__) && __ARM_ARCH >= 7) || defined(__aarch64__))) \ + || (defined(__APPLE__) && (defined(__x86_64__) || defined(__aarch64__))) \ + || (defined(__BIONIC__) && (defined(__x86_64__) || defined(__i386__) || (defined(__arm__) && __ARM_ARCH >= 7) || defined(__aarch64__))) \ + || (defined(__FreeBSD__) && (defined(__x86_64__) || defined(__i386__) || defined(__aarch64__))) \ + || (defined(__OpenBSD__) && (defined(__x86_64__) || defined(__i386__) || defined(__aarch64__))) \ + ) + +static inline void* mi_prim_tls_slot(size_t slot) mi_attr_noexcept { + void* res; + const size_t ofs = (slot*sizeof(void*)); + #if defined(__i386__) + __asm__("movl %%gs:%1, %0" : "=r" (res) : "m" (*((void**)ofs)) : ); // x86 32-bit always uses GS + #elif defined(__APPLE__) && defined(__x86_64__) + __asm__("movq %%gs:%1, %0" : "=r" (res) : "m" (*((void**)ofs)) : ); // x86_64 macOSX uses GS + #elif defined(__x86_64__) && (MI_INTPTR_SIZE==4) + __asm__("movl %%fs:%1, %0" : "=r" (res) : "m" (*((void**)ofs)) : ); // x32 ABI + #elif defined(__x86_64__) + __asm__("movq %%fs:%1, %0" : "=r" (res) : "m" (*((void**)ofs)) : ); // x86_64 Linux, BSD uses FS + #elif defined(__arm__) + void** tcb; MI_UNUSED(ofs); + __asm__ volatile ("mrc p15, 0, %0, c13, c0, 3\nbic %0, %0, #3" : "=r" (tcb)); + res = tcb[slot]; + #elif defined(__aarch64__) + void** tcb; MI_UNUSED(ofs); + #if defined(__APPLE__) // M1, issue #343 + __asm__ volatile ("mrs %0, tpidrro_el0\nbic %0, %0, #7" : "=r" (tcb)); + #else + __asm__ volatile ("mrs %0, tpidr_el0" : "=r" (tcb)); + #endif + res = tcb[slot]; + #endif + return res; +} + +// setting a tls slot is only used on macOS for now +static inline void mi_prim_tls_slot_set(size_t slot, void* value) mi_attr_noexcept { + const size_t ofs = (slot*sizeof(void*)); + #if defined(__i386__) + __asm__("movl %1,%%gs:%0" : "=m" (*((void**)ofs)) : "rn" (value) : ); // 32-bit always uses GS + #elif defined(__APPLE__) && defined(__x86_64__) + __asm__("movq %1,%%gs:%0" : "=m" (*((void**)ofs)) : "rn" (value) : ); // x86_64 macOS uses GS + #elif defined(__x86_64__) && (MI_INTPTR_SIZE==4) + __asm__("movl %1,%%fs:%0" : "=m" (*((void**)ofs)) : "rn" (value) : ); // x32 ABI + #elif defined(__x86_64__) + __asm__("movq %1,%%fs:%0" : "=m" (*((void**)ofs)) : "rn" (value) : ); // x86_64 Linux, BSD uses FS + #elif defined(__arm__) + void** tcb; MI_UNUSED(ofs); + __asm__ volatile ("mrc p15, 0, %0, c13, c0, 3\nbic %0, %0, #3" : "=r" (tcb)); + tcb[slot] = value; + #elif defined(__aarch64__) + void** tcb; MI_UNUSED(ofs); + #if defined(__APPLE__) // M1, issue #343 + __asm__ volatile ("mrs %0, tpidrro_el0\nbic %0, %0, #7" : "=r" (tcb)); + #else + __asm__ volatile ("mrs %0, tpidr_el0" : "=r" (tcb)); + #endif + tcb[slot] = value; + #endif +} + +static inline mi_threadid_t _mi_prim_thread_id(void) mi_attr_noexcept { + #if defined(__BIONIC__) + // issue #384, #495: on the Bionic libc (Android), slot 1 is the thread id + // see: https://github.com/aosp-mirror/platform_bionic/blob/c44b1d0676ded732df4b3b21c5f798eacae93228/libc/platform/bionic/tls_defines.h#L86 + return (uintptr_t)mi_prim_tls_slot(1); + #else + // in all our other targets, slot 0 is the thread id + // glibc: https://sourceware.org/git/?p=glibc.git;a=blob_plain;f=sysdeps/x86_64/nptl/tls.h + // apple: https://github.com/apple/darwin-xnu/blob/main/libsyscall/os/tsd.h#L36 + return (uintptr_t)mi_prim_tls_slot(0); + #endif +} + +#else + +// otherwise use portable C, taking the address of a thread local variable (this is still very fast on most platforms). +static inline mi_threadid_t _mi_prim_thread_id(void) mi_attr_noexcept { + return (uintptr_t)&_mi_heap_default; +} + +#endif + + + +/* ---------------------------------------------------------------------------------------- +The thread local default heap: `_mi_prim_get_default_heap()` +This is inlined here as it is on the fast path for allocation functions. + +On most platforms (Windows, Linux, FreeBSD, NetBSD, etc), this just returns a +__thread local variable (`_mi_heap_default`). With the initial-exec TLS model this ensures +that the storage will always be available (allocated on the thread stacks). + +On some platforms though we cannot use that when overriding `malloc` since the underlying +TLS implementation (or the loader) will call itself `malloc` on a first access and recurse. +We try to circumvent this in an efficient way: +- macOSX : we use an unused TLS slot from the OS allocated slots (MI_TLS_SLOT). On OSX, the + loader itself calls `malloc` even before the modules are initialized. +- OpenBSD: we use an unused slot from the pthread block (MI_TLS_PTHREAD_SLOT_OFS). +- DragonFly: defaults are working but seem slow compared to freeBSD (see PR #323) +------------------------------------------------------------------------------------------- */ + +static inline mi_heap_t* mi_prim_get_default_heap(void); + +#if defined(MI_MALLOC_OVERRIDE) +#if defined(__APPLE__) // macOS + #define MI_TLS_SLOT 89 // seems unused? + // #define MI_TLS_RECURSE_GUARD 1 + // other possible unused ones are 9, 29, __PTK_FRAMEWORK_JAVASCRIPTCORE_KEY4 (94), __PTK_FRAMEWORK_GC_KEY9 (112) and __PTK_FRAMEWORK_OLDGC_KEY9 (89) + // see +#elif defined(__OpenBSD__) + // use end bytes of a name; goes wrong if anyone uses names > 23 characters (ptrhread specifies 16) + // see + #define MI_TLS_PTHREAD_SLOT_OFS (6*sizeof(int) + 4*sizeof(void*) + 24) + // #elif defined(__DragonFly__) + // #warning "mimalloc is not working correctly on DragonFly yet." + // #define MI_TLS_PTHREAD_SLOT_OFS (4 + 1*sizeof(void*)) // offset `uniqueid` (also used by gdb?) +#elif defined(__ANDROID__) + // See issue #381 + #define MI_TLS_PTHREAD +#endif +#endif + + +#if defined(MI_TLS_SLOT) + +static inline mi_heap_t* mi_prim_get_default_heap(void) { + mi_heap_t* heap = (mi_heap_t*)mi_prim_tls_slot(MI_TLS_SLOT); + if mi_unlikely(heap == NULL) { + #ifdef __GNUC__ + __asm(""); // prevent conditional load of the address of _mi_heap_empty + #endif + heap = (mi_heap_t*)&_mi_heap_empty; + } + return heap; +} + +#elif defined(MI_TLS_PTHREAD_SLOT_OFS) + +static inline mi_heap_t** mi_prim_tls_pthread_heap_slot(void) { + pthread_t self = pthread_self(); + #if defined(__DragonFly__) + if (self==NULL) return NULL; + #endif + return (mi_heap_t**)((uint8_t*)self + MI_TLS_PTHREAD_SLOT_OFS); +} + +static inline mi_heap_t* mi_prim_get_default_heap(void) { + mi_heap_t** pheap = mi_prim_tls_pthread_heap_slot(); + if mi_unlikely(pheap == NULL) return _mi_heap_main_get(); + mi_heap_t* heap = *pheap; + if mi_unlikely(heap == NULL) return (mi_heap_t*)&_mi_heap_empty; + return heap; +} + +#elif defined(MI_TLS_PTHREAD) + +extern pthread_key_t _mi_heap_default_key; +static inline mi_heap_t* mi_prim_get_default_heap(void) { + mi_heap_t* heap = (mi_unlikely(_mi_heap_default_key == (pthread_key_t)(-1)) ? _mi_heap_main_get() : (mi_heap_t*)pthread_getspecific(_mi_heap_default_key)); + return (mi_unlikely(heap == NULL) ? (mi_heap_t*)&_mi_heap_empty : heap); +} + +#else // default using a thread local variable; used on most platforms. + +static inline mi_heap_t* mi_prim_get_default_heap(void) { + #if defined(MI_TLS_RECURSE_GUARD) + if (mi_unlikely(!_mi_process_is_initialized)) return _mi_heap_main_get(); + #endif + return _mi_heap_default; +} + +#endif // mi_prim_get_default_heap() + + + +#endif // MIMALLOC_PRIM_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/mimalloc/mimalloc/track.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/mimalloc/mimalloc/track.h new file mode 100644 index 0000000000000000000000000000000000000000..fa1a048d846a9cfcb42bea37813be445847bf344 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/mimalloc/mimalloc/track.h @@ -0,0 +1,147 @@ +/* ---------------------------------------------------------------------------- +Copyright (c) 2018-2023, Microsoft Research, Daan Leijen +This is free software; you can redistribute it and/or modify it under the +terms of the MIT license. A copy of the license can be found in the file +"LICENSE" at the root of this distribution. +-----------------------------------------------------------------------------*/ +#pragma once +#ifndef MIMALLOC_TRACK_H +#define MIMALLOC_TRACK_H + +/* ------------------------------------------------------------------------------------------------------ +Track memory ranges with macros for tools like Valgrind address sanitizer, or other memory checkers. +These can be defined for tracking allocation: + + #define mi_track_malloc_size(p,reqsize,size,zero) + #define mi_track_free_size(p,_size) + +The macros are set up such that the size passed to `mi_track_free_size` +always matches the size of `mi_track_malloc_size`. (currently, `size == mi_usable_size(p)`). +The `reqsize` is what the user requested, and `size >= reqsize`. +The `size` is either byte precise (and `size==reqsize`) if `MI_PADDING` is enabled, +or otherwise it is the usable block size which may be larger than the original request. +Use `_mi_block_size_of(void* p)` to get the full block size that was allocated (including padding etc). +The `zero` parameter is `true` if the allocated block is zero initialized. + +Optional: + + #define mi_track_align(p,alignedp,offset,size) + #define mi_track_resize(p,oldsize,newsize) + #define mi_track_init() + +The `mi_track_align` is called right after a `mi_track_malloc` for aligned pointers in a block. +The corresponding `mi_track_free` still uses the block start pointer and original size (corresponding to the `mi_track_malloc`). +The `mi_track_resize` is currently unused but could be called on reallocations within a block. +`mi_track_init` is called at program start. + +The following macros are for tools like asan and valgrind to track whether memory is +defined, undefined, or not accessible at all: + + #define mi_track_mem_defined(p,size) + #define mi_track_mem_undefined(p,size) + #define mi_track_mem_noaccess(p,size) + +-------------------------------------------------------------------------------------------------------*/ + +#if MI_TRACK_VALGRIND +// valgrind tool + +#define MI_TRACK_ENABLED 1 +#define MI_TRACK_HEAP_DESTROY 1 // track free of individual blocks on heap_destroy +#define MI_TRACK_TOOL "valgrind" + +#include +#include + +#define mi_track_malloc_size(p,reqsize,size,zero) VALGRIND_MALLOCLIKE_BLOCK(p,size,MI_PADDING_SIZE /*red zone*/,zero) +#define mi_track_free_size(p,_size) VALGRIND_FREELIKE_BLOCK(p,MI_PADDING_SIZE /*red zone*/) +#define mi_track_resize(p,oldsize,newsize) VALGRIND_RESIZEINPLACE_BLOCK(p,oldsize,newsize,MI_PADDING_SIZE /*red zone*/) +#define mi_track_mem_defined(p,size) VALGRIND_MAKE_MEM_DEFINED(p,size) +#define mi_track_mem_undefined(p,size) VALGRIND_MAKE_MEM_UNDEFINED(p,size) +#define mi_track_mem_noaccess(p,size) VALGRIND_MAKE_MEM_NOACCESS(p,size) + +#elif MI_TRACK_ASAN +// address sanitizer + +#define MI_TRACK_ENABLED 1 +#define MI_TRACK_HEAP_DESTROY 0 +#define MI_TRACK_TOOL "asan" + +#include + +#define mi_track_malloc_size(p,reqsize,size,zero) ASAN_UNPOISON_MEMORY_REGION(p,size) +#define mi_track_free_size(p,size) ASAN_POISON_MEMORY_REGION(p,size) +#define mi_track_mem_defined(p,size) ASAN_UNPOISON_MEMORY_REGION(p,size) +#define mi_track_mem_undefined(p,size) ASAN_UNPOISON_MEMORY_REGION(p,size) +#define mi_track_mem_noaccess(p,size) ASAN_POISON_MEMORY_REGION(p,size) + +#elif MI_TRACK_ETW +// windows event tracing + +#define MI_TRACK_ENABLED 1 +#define MI_TRACK_HEAP_DESTROY 1 +#define MI_TRACK_TOOL "ETW" + +#define WIN32_LEAN_AND_MEAN +#include +#include "../src/prim/windows/etw.h" + +#define mi_track_init() EventRegistermicrosoft_windows_mimalloc(); +#define mi_track_malloc_size(p,reqsize,size,zero) EventWriteETW_MI_ALLOC((UINT64)(p), size) +#define mi_track_free_size(p,size) EventWriteETW_MI_FREE((UINT64)(p), size) + +#else +// no tracking + +#define MI_TRACK_ENABLED 0 +#define MI_TRACK_HEAP_DESTROY 0 +#define MI_TRACK_TOOL "none" + +#define mi_track_malloc_size(p,reqsize,size,zero) +#define mi_track_free_size(p,_size) + +#endif + +// ------------------- +// Utility definitions + +#ifndef mi_track_resize +#define mi_track_resize(p,oldsize,newsize) mi_track_free_size(p,oldsize); mi_track_malloc(p,newsize,false) +#endif + +#ifndef mi_track_align +#define mi_track_align(p,alignedp,offset,size) mi_track_mem_noaccess(p,offset) +#endif + +#ifndef mi_track_init +#define mi_track_init() +#endif + +#ifndef mi_track_mem_defined +#define mi_track_mem_defined(p,size) +#endif + +#ifndef mi_track_mem_undefined +#define mi_track_mem_undefined(p,size) +#endif + +#ifndef mi_track_mem_noaccess +#define mi_track_mem_noaccess(p,size) +#endif + + +#if MI_PADDING +#define mi_track_malloc(p,reqsize,zero) \ + if ((p)!=NULL) { \ + mi_assert_internal(mi_usable_size(p)==(reqsize)); \ + mi_track_malloc_size(p,reqsize,reqsize,zero); \ + } +#else +#define mi_track_malloc(p,reqsize,zero) \ + if ((p)!=NULL) { \ + mi_assert_internal(mi_usable_size(p)>=(reqsize)); \ + mi_track_malloc_size(p,reqsize,mi_usable_size(p),zero); \ + } +#endif + +#endif diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/mimalloc/mimalloc/types.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/mimalloc/mimalloc/types.h new file mode 100644 index 0000000000000000000000000000000000000000..70c600e920bad198bcf8810ea068c59471433b9f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/mimalloc/mimalloc/types.h @@ -0,0 +1,721 @@ +/* ---------------------------------------------------------------------------- +Copyright (c) 2018-2023, Microsoft Research, Daan Leijen +This is free software; you can redistribute it and/or modify it under the +terms of the MIT license. A copy of the license can be found in the file +"LICENSE" at the root of this distribution. +-----------------------------------------------------------------------------*/ +#pragma once +#ifndef MIMALLOC_TYPES_H +#define MIMALLOC_TYPES_H + +// -------------------------------------------------------------------------- +// This file contains the main type definitions for mimalloc: +// mi_heap_t : all data for a thread-local heap, contains +// lists of all managed heap pages. +// mi_segment_t : a larger chunk of memory (32GiB) from where pages +// are allocated. +// mi_page_t : a mimalloc page (usually 64KiB or 512KiB) from +// where objects are allocated. +// -------------------------------------------------------------------------- + + +#include // ptrdiff_t +#include // uintptr_t, uint16_t, etc +#include "atomic.h" // _Atomic + +#ifdef _MSC_VER +#pragma warning(disable:4214) // bitfield is not int +#endif + +// Minimal alignment necessary. On most platforms 16 bytes are needed +// due to SSE registers for example. This must be at least `sizeof(void*)` +#ifndef MI_MAX_ALIGN_SIZE +#define MI_MAX_ALIGN_SIZE 16 // sizeof(max_align_t) +#endif + +#define MI_CACHE_LINE 64 +#if defined(_MSC_VER) +#pragma warning(disable:4127) // suppress constant conditional warning (due to MI_SECURE paths) +#pragma warning(disable:26812) // unscoped enum warning +#define mi_decl_noinline __declspec(noinline) +#define mi_decl_thread __declspec(thread) +#define mi_decl_cache_align __declspec(align(MI_CACHE_LINE)) +#elif (defined(__GNUC__) && (__GNUC__ >= 3)) || defined(__clang__) // includes clang and icc +#define mi_decl_noinline __attribute__((noinline)) +#define mi_decl_thread __thread +#define mi_decl_cache_align __attribute__((aligned(MI_CACHE_LINE))) +#else +#define mi_decl_noinline +#define mi_decl_thread __thread // hope for the best :-) +#define mi_decl_cache_align +#endif + +// ------------------------------------------------------ +// Variants +// ------------------------------------------------------ + +// Define NDEBUG in the release version to disable assertions. +// #define NDEBUG + +// Define MI_TRACK_ to enable tracking support +// #define MI_TRACK_VALGRIND 1 +// #define MI_TRACK_ASAN 1 +// #define MI_TRACK_ETW 1 + +// Define MI_STAT as 1 to maintain statistics; set it to 2 to have detailed statistics (but costs some performance). +// #define MI_STAT 1 + +// Define MI_SECURE to enable security mitigations +// #define MI_SECURE 1 // guard page around metadata +// #define MI_SECURE 2 // guard page around each mimalloc page +// #define MI_SECURE 3 // encode free lists (detect corrupted free list (buffer overflow), and invalid pointer free) +// #define MI_SECURE 4 // checks for double free. (may be more expensive) + +#if !defined(MI_SECURE) +#define MI_SECURE 0 +#endif + +// Define MI_DEBUG for debug mode +// #define MI_DEBUG 1 // basic assertion checks and statistics, check double free, corrupted free list, and invalid pointer free. +// #define MI_DEBUG 2 // + internal assertion checks +// #define MI_DEBUG 3 // + extensive internal invariant checking (cmake -DMI_DEBUG_FULL=ON) +#if !defined(MI_DEBUG) +#if !defined(NDEBUG) || defined(_DEBUG) +#define MI_DEBUG 2 +#else +#define MI_DEBUG 0 +#endif +#endif + +// Reserve extra padding at the end of each block to be more resilient against heap block overflows. +// The padding can detect buffer overflow on free. +#if !defined(MI_PADDING) && (MI_SECURE>=3 || MI_DEBUG>=1 || (MI_TRACK_VALGRIND || MI_TRACK_ASAN || MI_TRACK_ETW)) +#define MI_PADDING 1 +#endif + +// Check padding bytes; allows byte-precise buffer overflow detection +#if !defined(MI_PADDING_CHECK) && MI_PADDING && (MI_SECURE>=3 || MI_DEBUG>=1) +#define MI_PADDING_CHECK 1 +#endif + + +// Encoded free lists allow detection of corrupted free lists +// and can detect buffer overflows, modify after free, and double `free`s. +#if (MI_SECURE>=3 || MI_DEBUG>=1) +#define MI_ENCODE_FREELIST 1 +#endif + + +// We used to abandon huge pages but to eagerly deallocate if freed from another thread, +// but that makes it not possible to visit them during a heap walk or include them in a +// `mi_heap_destroy`. We therefore instead reset/decommit the huge blocks if freed from +// another thread so most memory is available until it gets properly freed by the owning thread. +// #define MI_HUGE_PAGE_ABANDON 1 + + +// ------------------------------------------------------ +// Platform specific values +// ------------------------------------------------------ + +// ------------------------------------------------------ +// Size of a pointer. +// We assume that `sizeof(void*)==sizeof(intptr_t)` +// and it holds for all platforms we know of. +// +// However, the C standard only requires that: +// p == (void*)((intptr_t)p)) +// but we also need: +// i == (intptr_t)((void*)i) +// or otherwise one might define an intptr_t type that is larger than a pointer... +// ------------------------------------------------------ + +#if INTPTR_MAX > INT64_MAX +# define MI_INTPTR_SHIFT (4) // assume 128-bit (as on arm CHERI for example) +#elif INTPTR_MAX == INT64_MAX +# define MI_INTPTR_SHIFT (3) +#elif INTPTR_MAX == INT32_MAX +# define MI_INTPTR_SHIFT (2) +#else +#error platform pointers must be 32, 64, or 128 bits +#endif + +#if SIZE_MAX == UINT64_MAX +# define MI_SIZE_SHIFT (3) +typedef int64_t mi_ssize_t; +#elif SIZE_MAX == UINT32_MAX +# define MI_SIZE_SHIFT (2) +typedef int32_t mi_ssize_t; +#else +#error platform objects must be 32 or 64 bits +#endif + +#if (SIZE_MAX/2) > LONG_MAX +# define MI_ZU(x) x##ULL +# define MI_ZI(x) x##LL +#else +# define MI_ZU(x) x##UL +# define MI_ZI(x) x##L +#endif + +#define MI_INTPTR_SIZE (1< 4 +#define MI_SEGMENT_SHIFT ( 9 + MI_SEGMENT_SLICE_SHIFT) // 32MiB +#else +#define MI_SEGMENT_SHIFT ( 7 + MI_SEGMENT_SLICE_SHIFT) // 4MiB on 32-bit +#endif + +#define MI_SMALL_PAGE_SHIFT (MI_SEGMENT_SLICE_SHIFT) // 64KiB +#define MI_MEDIUM_PAGE_SHIFT ( 3 + MI_SMALL_PAGE_SHIFT) // 512KiB + + +// Derived constants +#define MI_SEGMENT_SIZE (MI_ZU(1)<= 655360) +#error "mimalloc internal: define more bins" +#endif + +// Maximum slice offset (15) +#define MI_MAX_SLICE_OFFSET ((MI_ALIGNMENT_MAX / MI_SEGMENT_SLICE_SIZE) - 1) + +// Used as a special value to encode block sizes in 32 bits. +#define MI_HUGE_BLOCK_SIZE ((uint32_t)(2*MI_GiB)) + +// blocks up to this size are always allocated aligned +#define MI_MAX_ALIGN_GUARANTEE (8*MI_MAX_ALIGN_SIZE) + +// Alignments over MI_ALIGNMENT_MAX are allocated in dedicated huge page segments +#define MI_ALIGNMENT_MAX (MI_SEGMENT_SIZE >> 1) + + +// ------------------------------------------------------ +// Mimalloc pages contain allocated blocks +// ------------------------------------------------------ + +// The free lists use encoded next fields +// (Only actually encodes when MI_ENCODED_FREELIST is defined.) +typedef uintptr_t mi_encoded_t; + +// thread id's +typedef size_t mi_threadid_t; + +// free lists contain blocks +typedef struct mi_block_s { + _Atomic(mi_encoded_t) next; +} mi_block_t; + + +// The delayed flags are used for efficient multi-threaded free-ing +typedef enum mi_delayed_e { + MI_USE_DELAYED_FREE = 0, // push on the owning heap thread delayed list + MI_DELAYED_FREEING = 1, // temporary: another thread is accessing the owning heap + MI_NO_DELAYED_FREE = 2, // optimize: push on page local thread free queue if another block is already in the heap thread delayed free list + MI_NEVER_DELAYED_FREE = 3 // sticky, only resets on page reclaim +} mi_delayed_t; + + +// The `in_full` and `has_aligned` page flags are put in a union to efficiently +// test if both are false (`full_aligned == 0`) in the `mi_free` routine. +#if !MI_TSAN +typedef union mi_page_flags_s { + uint8_t full_aligned; + struct { + uint8_t in_full : 1; + uint8_t has_aligned : 1; + } x; +} mi_page_flags_t; +#else +// under thread sanitizer, use a byte for each flag to suppress warning, issue #130 +typedef union mi_page_flags_s { + uint16_t full_aligned; + struct { + uint8_t in_full; + uint8_t has_aligned; + } x; +} mi_page_flags_t; +#endif + +// Thread free list. +// We use the bottom 2 bits of the pointer for mi_delayed_t flags +typedef uintptr_t mi_thread_free_t; + +// A page contains blocks of one specific size (`block_size`). +// Each page has three list of free blocks: +// `free` for blocks that can be allocated, +// `local_free` for freed blocks that are not yet available to `mi_malloc` +// `thread_free` for freed blocks by other threads +// The `local_free` and `thread_free` lists are migrated to the `free` list +// when it is exhausted. The separate `local_free` list is necessary to +// implement a monotonic heartbeat. The `thread_free` list is needed for +// avoiding atomic operations in the common case. +// +// +// `used - |thread_free|` == actual blocks that are in use (alive) +// `used - |thread_free| + |free| + |local_free| == capacity` +// +// We don't count `freed` (as |free|) but use `used` to reduce +// the number of memory accesses in the `mi_page_all_free` function(s). +// +// Notes: +// - Access is optimized for `mi_free` and `mi_page_alloc` (in `alloc.c`) +// - Using `uint16_t` does not seem to slow things down +// - The size is 8 words on 64-bit which helps the page index calculations +// (and 10 words on 32-bit, and encoded free lists add 2 words. Sizes 10 +// and 12 are still good for address calculation) +// - To limit the structure size, the `xblock_size` is 32-bits only; for +// blocks > MI_HUGE_BLOCK_SIZE the size is determined from the segment page size +// - `thread_free` uses the bottom bits as a delayed-free flags to optimize +// concurrent frees where only the first concurrent free adds to the owning +// heap `thread_delayed_free` list (see `alloc.c:mi_free_block_mt`). +// The invariant is that no-delayed-free is only set if there is +// at least one block that will be added, or as already been added, to +// the owning heap `thread_delayed_free` list. This guarantees that pages +// will be freed correctly even if only other threads free blocks. +typedef struct mi_page_s { + // "owned" by the segment + uint32_t slice_count; // slices in this page (0 if not a page) + uint32_t slice_offset; // distance from the actual page data slice (0 if a page) + uint8_t is_committed : 1; // `true` if the page virtual memory is committed + uint8_t is_zero_init : 1; // `true` if the page was initially zero initialized + uint8_t use_qsbr : 1; // delay page freeing using qsbr + uint8_t tag : 4; // tag from the owning heap + uint8_t debug_offset; // number of bytes to preserve when filling freed or uninitialized memory + + // layout like this to optimize access in `mi_malloc` and `mi_free` + uint16_t capacity; // number of blocks committed, must be the first field, see `segment.c:page_clear` + uint16_t reserved; // number of blocks reserved in memory + mi_page_flags_t flags; // `in_full` and `has_aligned` flags (8 bits) + uint8_t free_is_zero : 1; // `true` if the blocks in the free list are zero initialized + uint8_t retire_expire : 7; // expiration count for retired blocks + + mi_block_t* free; // list of available free blocks (`malloc` allocates from this list) + uint32_t used; // number of blocks in use (including blocks in `local_free` and `thread_free`) + uint32_t xblock_size; // size available in each block (always `>0`) + mi_block_t* local_free; // list of deferred free blocks by this thread (migrates to `free`) + + #if (MI_ENCODE_FREELIST || MI_PADDING) + uintptr_t keys[2]; // two random keys to encode the free lists (see `_mi_block_next`) or padding canary + #endif + + _Atomic(mi_thread_free_t) xthread_free; // list of deferred free blocks freed by other threads + _Atomic(uintptr_t) xheap; + + struct mi_page_s* next; // next page owned by this thread with the same `block_size` + struct mi_page_s* prev; // previous page owned by this thread with the same `block_size` + +#ifdef Py_GIL_DISABLED + struct llist_node qsbr_node; + uint64_t qsbr_goal; +#endif + + // 64-bit 9 words, 32-bit 12 words, (+2 for secure) + #if MI_INTPTR_SIZE==8 && !defined(Py_GIL_DISABLED) + uintptr_t padding[1]; + #endif +} mi_page_t; + + + +// ------------------------------------------------------ +// Mimalloc segments contain mimalloc pages +// ------------------------------------------------------ + +typedef enum mi_page_kind_e { + MI_PAGE_SMALL, // small blocks go into 64KiB pages inside a segment + MI_PAGE_MEDIUM, // medium blocks go into medium pages inside a segment + MI_PAGE_LARGE, // larger blocks go into a page of just one block + MI_PAGE_HUGE, // huge blocks (> 16 MiB) are put into a single page in a single segment. +} mi_page_kind_t; + +typedef enum mi_segment_kind_e { + MI_SEGMENT_NORMAL, // MI_SEGMENT_SIZE size with pages inside. + MI_SEGMENT_HUGE, // > MI_LARGE_SIZE_MAX segment with just one huge page inside. +} mi_segment_kind_t; + +// ------------------------------------------------------ +// A segment holds a commit mask where a bit is set if +// the corresponding MI_COMMIT_SIZE area is committed. +// The MI_COMMIT_SIZE must be a multiple of the slice +// size. If it is equal we have the most fine grained +// decommit (but setting it higher can be more efficient). +// The MI_MINIMAL_COMMIT_SIZE is the minimal amount that will +// be committed in one go which can be set higher than +// MI_COMMIT_SIZE for efficiency (while the decommit mask +// is still tracked in fine-grained MI_COMMIT_SIZE chunks) +// ------------------------------------------------------ + +#define MI_MINIMAL_COMMIT_SIZE (1*MI_SEGMENT_SLICE_SIZE) +#define MI_COMMIT_SIZE (MI_SEGMENT_SLICE_SIZE) // 64KiB +#define MI_COMMIT_MASK_BITS (MI_SEGMENT_SIZE / MI_COMMIT_SIZE) +#define MI_COMMIT_MASK_FIELD_BITS MI_SIZE_BITS +#define MI_COMMIT_MASK_FIELD_COUNT (MI_COMMIT_MASK_BITS / MI_COMMIT_MASK_FIELD_BITS) + +#if (MI_COMMIT_MASK_BITS != (MI_COMMIT_MASK_FIELD_COUNT * MI_COMMIT_MASK_FIELD_BITS)) +#error "the segment size must be exactly divisible by the (commit size * size_t bits)" +#endif + +typedef struct mi_commit_mask_s { + size_t mask[MI_COMMIT_MASK_FIELD_COUNT]; +} mi_commit_mask_t; + +typedef mi_page_t mi_slice_t; +typedef int64_t mi_msecs_t; + + +// Memory can reside in arena's, direct OS allocated, or statically allocated. The memid keeps track of this. +typedef enum mi_memkind_e { + MI_MEM_NONE, // not allocated + MI_MEM_EXTERNAL, // not owned by mimalloc but provided externally (via `mi_manage_os_memory` for example) + MI_MEM_STATIC, // allocated in a static area and should not be freed (for arena meta data for example) + MI_MEM_OS, // allocated from the OS + MI_MEM_OS_HUGE, // allocated as huge os pages + MI_MEM_OS_REMAP, // allocated in a remapable area (i.e. using `mremap`) + MI_MEM_ARENA // allocated from an arena (the usual case) +} mi_memkind_t; + +static inline bool mi_memkind_is_os(mi_memkind_t memkind) { + return (memkind >= MI_MEM_OS && memkind <= MI_MEM_OS_REMAP); +} + +typedef struct mi_memid_os_info { + void* base; // actual base address of the block (used for offset aligned allocations) + size_t alignment; // alignment at allocation +} mi_memid_os_info_t; + +typedef struct mi_memid_arena_info { + size_t block_index; // index in the arena + mi_arena_id_t id; // arena id (>= 1) + bool is_exclusive; // the arena can only be used for specific arena allocations +} mi_memid_arena_info_t; + +typedef struct mi_memid_s { + union { + mi_memid_os_info_t os; // only used for MI_MEM_OS + mi_memid_arena_info_t arena; // only used for MI_MEM_ARENA + } mem; + bool is_pinned; // `true` if we cannot decommit/reset/protect in this memory (e.g. when allocated using large OS pages) + bool initially_committed;// `true` if the memory was originally allocated as committed + bool initially_zero; // `true` if the memory was originally zero initialized + mi_memkind_t memkind; +} mi_memid_t; + + +// Segments are large allocated memory blocks (8mb on 64 bit) from +// the OS. Inside segments we allocated fixed size _pages_ that +// contain blocks. +typedef struct mi_segment_s { + // constant fields + mi_memid_t memid; // memory id for arena allocation + bool allow_decommit; + bool allow_purge; + size_t segment_size; + + // segment fields + mi_msecs_t purge_expire; + mi_commit_mask_t purge_mask; + mi_commit_mask_t commit_mask; + + _Atomic(struct mi_segment_s*) abandoned_next; + + // from here is zero initialized + struct mi_segment_s* next; // the list of freed segments in the cache (must be first field, see `segment.c:mi_segment_init`) + + size_t abandoned; // abandoned pages (i.e. the original owning thread stopped) (`abandoned <= used`) + size_t abandoned_visits; // count how often this segment is visited in the abandoned list (to force reclaim it it is too long) + size_t used; // count of pages in use + uintptr_t cookie; // verify addresses in debug mode: `mi_ptr_cookie(segment) == segment->cookie` + + size_t segment_slices; // for huge segments this may be different from `MI_SLICES_PER_SEGMENT` + size_t segment_info_slices; // initial slices we are using segment info and possible guard pages. + + // layout like this to optimize access in `mi_free` + mi_segment_kind_t kind; + size_t slice_entries; // entries in the `slices` array, at most `MI_SLICES_PER_SEGMENT` + _Atomic(mi_threadid_t) thread_id; // unique id of the thread owning this segment + + mi_slice_t slices[MI_SLICES_PER_SEGMENT+1]; // one more for huge blocks with large alignment +} mi_segment_t; + +typedef uintptr_t mi_tagged_segment_t; + +// Segments unowned by any thread are put in a shared pool +typedef struct mi_abandoned_pool_s { + // This is a list of visited abandoned pages that were full at the time. + // this list migrates to `abandoned` when that becomes NULL. The use of + // this list reduces contention and the rate at which segments are visited. + mi_decl_cache_align _Atomic(mi_segment_t*) abandoned_visited; // = NULL + + // The abandoned page list (tagged as it supports pop) + mi_decl_cache_align _Atomic(mi_tagged_segment_t) abandoned; // = NULL + + // Maintain these for debug purposes (these counts may be a bit off) + mi_decl_cache_align _Atomic(size_t) abandoned_count; + mi_decl_cache_align _Atomic(size_t) abandoned_visited_count; + + // We also maintain a count of current readers of the abandoned list + // in order to prevent resetting/decommitting segment memory if it might + // still be read. + mi_decl_cache_align _Atomic(size_t) abandoned_readers; // = 0 +} mi_abandoned_pool_t; + + +// ------------------------------------------------------ +// Heaps +// Provide first-class heaps to allocate from. +// A heap just owns a set of pages for allocation and +// can only be allocate/reallocate from the thread that created it. +// Freeing blocks can be done from any thread though. +// Per thread, the segments are shared among its heaps. +// Per thread, there is always a default heap that is +// used for allocation; it is initialized to statically +// point to an empty heap to avoid initialization checks +// in the fast path. +// ------------------------------------------------------ + +// Thread local data +typedef struct mi_tld_s mi_tld_t; + +// Pages of a certain block size are held in a queue. +typedef struct mi_page_queue_s { + mi_page_t* first; + mi_page_t* last; + size_t block_size; +} mi_page_queue_t; + +#define MI_BIN_FULL (MI_BIN_HUGE+1) + +// Random context +typedef struct mi_random_cxt_s { + uint32_t input[16]; + uint32_t output[16]; + int output_available; + bool weak; +} mi_random_ctx_t; + + +// In debug mode there is a padding structure at the end of the blocks to check for buffer overflows +#if (MI_PADDING) +typedef struct mi_padding_s { + uint32_t canary; // encoded block value to check validity of the padding (in case of overflow) + uint32_t delta; // padding bytes before the block. (mi_usable_size(p) - delta == exact allocated bytes) +} mi_padding_t; +#define MI_PADDING_SIZE (sizeof(mi_padding_t)) +#define MI_PADDING_WSIZE ((MI_PADDING_SIZE + MI_INTPTR_SIZE - 1) / MI_INTPTR_SIZE) +#else +#define MI_PADDING_SIZE 0 +#define MI_PADDING_WSIZE 0 +#endif + +#define MI_PAGES_DIRECT (MI_SMALL_WSIZE_MAX + MI_PADDING_WSIZE + 1) + + +// A heap owns a set of pages. +struct mi_heap_s { + mi_tld_t* tld; + mi_page_t* pages_free_direct[MI_PAGES_DIRECT]; // optimize: array where every entry points a page with possibly free blocks in the corresponding queue for that size. + mi_page_queue_t pages[MI_BIN_FULL + 1]; // queue of pages for each size class (or "bin") + _Atomic(mi_block_t*) thread_delayed_free; + mi_threadid_t thread_id; // thread this heap belongs too + mi_arena_id_t arena_id; // arena id if the heap belongs to a specific arena (or 0) + uintptr_t cookie; // random cookie to verify pointers (see `_mi_ptr_cookie`) + uintptr_t keys[2]; // two random keys used to encode the `thread_delayed_free` list + mi_random_ctx_t random; // random number context used for secure allocation + size_t page_count; // total number of pages in the `pages` queues. + size_t page_retired_min; // smallest retired index (retired pages are fully free, but still in the page queues) + size_t page_retired_max; // largest retired index into the `pages` array. + mi_heap_t* next; // list of heaps per thread + bool no_reclaim; // `true` if this heap should not reclaim abandoned pages + uint8_t tag; // custom identifier for this heap + uint8_t debug_offset; // number of bytes to preserve when filling freed or uninitialized memory + bool page_use_qsbr; // should freeing pages be delayed using QSBR +}; + + + +// ------------------------------------------------------ +// Debug +// ------------------------------------------------------ + +#if !defined(MI_DEBUG_UNINIT) +#define MI_DEBUG_UNINIT (0xD0) +#endif +#if !defined(MI_DEBUG_FREED) +#define MI_DEBUG_FREED (0xDF) +#endif +#if !defined(MI_DEBUG_PADDING) +#define MI_DEBUG_PADDING (0xDE) +#endif + +#if (MI_DEBUG) +// use our own assertion to print without memory allocation +void _mi_assert_fail(const char* assertion, const char* fname, unsigned int line, const char* func ); +#define mi_assert(expr) ((expr) ? (void)0 : _mi_assert_fail(#expr,__FILE__,__LINE__,__func__)) +#else +#define mi_assert(x) +#endif + +#if (MI_DEBUG>1) +#define mi_assert_internal mi_assert +#else +#define mi_assert_internal(x) +#endif + +#if (MI_DEBUG>2) +#define mi_assert_expensive mi_assert +#else +#define mi_assert_expensive(x) +#endif + +// ------------------------------------------------------ +// Statistics +// ------------------------------------------------------ + +#ifndef MI_STAT +#if (MI_DEBUG>0) +#define MI_STAT 2 +#else +#define MI_STAT 0 +#endif +#endif + +typedef struct mi_stat_count_s { + int64_t allocated; + int64_t freed; + int64_t peak; + int64_t current; +} mi_stat_count_t; + +typedef struct mi_stat_counter_s { + int64_t total; + int64_t count; +} mi_stat_counter_t; + +typedef struct mi_stats_s { + mi_stat_count_t segments; + mi_stat_count_t pages; + mi_stat_count_t reserved; + mi_stat_count_t committed; + mi_stat_count_t reset; + mi_stat_count_t purged; + mi_stat_count_t page_committed; + mi_stat_count_t segments_abandoned; + mi_stat_count_t pages_abandoned; + mi_stat_count_t threads; + mi_stat_count_t normal; + mi_stat_count_t huge; + mi_stat_count_t large; + mi_stat_count_t malloc; + mi_stat_count_t segments_cache; + mi_stat_counter_t pages_extended; + mi_stat_counter_t mmap_calls; + mi_stat_counter_t commit_calls; + mi_stat_counter_t reset_calls; + mi_stat_counter_t purge_calls; + mi_stat_counter_t page_no_retire; + mi_stat_counter_t searches; + mi_stat_counter_t normal_count; + mi_stat_counter_t huge_count; + mi_stat_counter_t large_count; +#if MI_STAT>1 + mi_stat_count_t normal_bins[MI_BIN_HUGE+1]; +#endif +} mi_stats_t; + + +void _mi_stat_increase(mi_stat_count_t* stat, size_t amount); +void _mi_stat_decrease(mi_stat_count_t* stat, size_t amount); +void _mi_stat_counter_increase(mi_stat_counter_t* stat, size_t amount); + +#if (MI_STAT) +#define mi_stat_increase(stat,amount) _mi_stat_increase( &(stat), amount) +#define mi_stat_decrease(stat,amount) _mi_stat_decrease( &(stat), amount) +#define mi_stat_counter_increase(stat,amount) _mi_stat_counter_increase( &(stat), amount) +#else +#define mi_stat_increase(stat,amount) (void)0 +#define mi_stat_decrease(stat,amount) (void)0 +#define mi_stat_counter_increase(stat,amount) (void)0 +#endif + +#define mi_heap_stat_counter_increase(heap,stat,amount) mi_stat_counter_increase( (heap)->tld->stats.stat, amount) +#define mi_heap_stat_increase(heap,stat,amount) mi_stat_increase( (heap)->tld->stats.stat, amount) +#define mi_heap_stat_decrease(heap,stat,amount) mi_stat_decrease( (heap)->tld->stats.stat, amount) + +// ------------------------------------------------------ +// Thread Local data +// ------------------------------------------------------ + +// A "span" is an available range of slices. The span queues keep +// track of slice spans of at most the given `slice_count` (but more than the previous size class). +typedef struct mi_span_queue_s { + mi_slice_t* first; + mi_slice_t* last; + size_t slice_count; +} mi_span_queue_t; + +#define MI_SEGMENT_BIN_MAX (35) // 35 == mi_segment_bin(MI_SLICES_PER_SEGMENT) + +// OS thread local data +typedef struct mi_os_tld_s { + size_t region_idx; // start point for next allocation + mi_stats_t* stats; // points to tld stats +} mi_os_tld_t; + + +// Segments thread local data +typedef struct mi_segments_tld_s { + mi_span_queue_t spans[MI_SEGMENT_BIN_MAX+1]; // free slice spans inside segments + size_t count; // current number of segments; + size_t peak_count; // peak number of segments + size_t current_size; // current size of all segments + size_t peak_size; // peak size of all segments + mi_stats_t* stats; // points to tld stats + mi_os_tld_t* os; // points to os stats + mi_abandoned_pool_t* abandoned; // pool of abandoned segments +} mi_segments_tld_t; + +// Thread local data +struct mi_tld_s { + unsigned long long heartbeat; // monotonic heartbeat count + bool recurse; // true if deferred was called; used to prevent infinite recursion. + mi_heap_t* heap_backing; // backing heap of this thread (cannot be deleted) + mi_heap_t* heaps; // list of heaps in this thread (so we can abandon all when the thread terminates) + mi_segments_tld_t segments; // segment tld + mi_os_tld_t os; // os tld + mi_stats_t stats; // statistics +}; + +#endif diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_abstract.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_abstract.h new file mode 100644 index 0000000000000000000000000000000000000000..3cc0afac4bd5b45490d3edd8e92062bec837da8a --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_abstract.h @@ -0,0 +1,61 @@ +#ifndef Py_INTERNAL_ABSTRACT_H +#define Py_INTERNAL_ABSTRACT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +// Fast inlined version of PyIndex_Check() +static inline int +_PyIndex_Check(PyObject *obj) +{ + PyNumberMethods *tp_as_number = Py_TYPE(obj)->tp_as_number; + return (tp_as_number != NULL && tp_as_number->nb_index != NULL); +} + +PyObject *_PyNumber_PowerNoMod(PyObject *lhs, PyObject *rhs); +PyObject *_PyNumber_InPlacePowerNoMod(PyObject *lhs, PyObject *rhs); + +extern int _PyObject_HasLen(PyObject *o); + +/* === Sequence protocol ================================================ */ + +#define PY_ITERSEARCH_COUNT 1 +#define PY_ITERSEARCH_INDEX 2 +#define PY_ITERSEARCH_CONTAINS 3 + +/* Iterate over seq. + + Result depends on the operation: + + PY_ITERSEARCH_COUNT: return # of times obj appears in seq; -1 if + error. + PY_ITERSEARCH_INDEX: return 0-based index of first occurrence of + obj in seq; set ValueError and return -1 if none found; + also return -1 on error. + PY_ITERSEARCH_CONTAINS: return 1 if obj in seq, else 0; -1 on + error. */ +extern Py_ssize_t _PySequence_IterSearch(PyObject *seq, + PyObject *obj, int operation); + +/* === Mapping protocol ================================================= */ + +extern int _PyObject_RealIsInstance(PyObject *inst, PyObject *cls); + +extern int _PyObject_RealIsSubclass(PyObject *derived, PyObject *cls); + +// Convert Python int to Py_ssize_t. Do nothing if the argument is None. +// Export for '_bisect' shared extension. +PyAPI_FUNC(int) _Py_convert_optional_to_ssize_t(PyObject *, void *); + +// Same as PyNumber_Index() but can return an instance of a subclass of int. +// Export for 'math' shared extension. +PyAPI_FUNC(PyObject*) _PyNumber_Index(PyObject *o); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_ABSTRACT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_asdl.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_asdl.h new file mode 100644 index 0000000000000000000000000000000000000000..afeada88d13e24ceb69ebc07456964b26ba8e3c1 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_asdl.h @@ -0,0 +1,112 @@ +#ifndef Py_INTERNAL_ASDL_H +#define Py_INTERNAL_ASDL_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_pyarena.h" // _PyArena_Malloc() + +typedef PyObject * identifier; +typedef PyObject * string; +typedef PyObject * object; +typedef PyObject * constant; + +/* It would be nice if the code generated by asdl_c.py was completely + independent of Python, but it is a goal the requires too much work + at this stage. So, for example, I'll represent identifiers as + interned Python strings. +*/ + +#define _ASDL_SEQ_HEAD \ + Py_ssize_t size; \ + void **elements; + +typedef struct { + _ASDL_SEQ_HEAD +} asdl_seq; + +typedef struct { + _ASDL_SEQ_HEAD + void *typed_elements[1]; +} asdl_generic_seq; + +typedef struct { + _ASDL_SEQ_HEAD + PyObject *typed_elements[1]; +} asdl_identifier_seq; + +typedef struct { + _ASDL_SEQ_HEAD + int typed_elements[1]; +} asdl_int_seq; + +asdl_generic_seq *_Py_asdl_generic_seq_new(Py_ssize_t size, PyArena *arena); +asdl_identifier_seq *_Py_asdl_identifier_seq_new(Py_ssize_t size, PyArena *arena); +asdl_int_seq *_Py_asdl_int_seq_new(Py_ssize_t size, PyArena *arena); + + +#define GENERATE_ASDL_SEQ_CONSTRUCTOR(NAME, TYPE) \ +asdl_ ## NAME ## _seq *_Py_asdl_ ## NAME ## _seq_new(Py_ssize_t size, PyArena *arena) \ +{ \ + asdl_ ## NAME ## _seq *seq = NULL; \ + size_t n; \ + /* check size is sane */ \ + if (size < 0 || \ + (size && (((size_t)size - 1) > (SIZE_MAX / sizeof(void *))))) { \ + PyErr_NoMemory(); \ + return NULL; \ + } \ + n = (size ? (sizeof(TYPE *) * (size - 1)) : 0); \ + /* check if size can be added safely */ \ + if (n > SIZE_MAX - sizeof(asdl_ ## NAME ## _seq)) { \ + PyErr_NoMemory(); \ + return NULL; \ + } \ + n += sizeof(asdl_ ## NAME ## _seq); \ + seq = (asdl_ ## NAME ## _seq *)_PyArena_Malloc(arena, n); \ + if (!seq) { \ + PyErr_NoMemory(); \ + return NULL; \ + } \ + memset(seq, 0, n); \ + seq->size = size; \ + seq->elements = (void**)seq->typed_elements; \ + return seq; \ +} + +#define asdl_seq_GET_UNTYPED(S, I) _Py_RVALUE((S)->elements[(I)]) +#define asdl_seq_GET(S, I) _Py_RVALUE((S)->typed_elements[(I)]) +#define asdl_seq_LEN(S) _Py_RVALUE(((S) == NULL ? 0 : (S)->size)) + +#ifdef Py_DEBUG +# define asdl_seq_SET(S, I, V) \ + do { \ + Py_ssize_t _asdl_i = (I); \ + assert((S) != NULL); \ + assert(0 <= _asdl_i && _asdl_i < (S)->size); \ + (S)->typed_elements[_asdl_i] = (V); \ + } while (0) +#else +# define asdl_seq_SET(S, I, V) _Py_RVALUE((S)->typed_elements[(I)] = (V)) +#endif + +#ifdef Py_DEBUG +# define asdl_seq_SET_UNTYPED(S, I, V) \ + do { \ + Py_ssize_t _asdl_i = (I); \ + assert((S) != NULL); \ + assert(0 <= _asdl_i && _asdl_i < (S)->size); \ + (S)->elements[_asdl_i] = (V); \ + } while (0) +#else +# define asdl_seq_SET_UNTYPED(S, I, V) _Py_RVALUE((S)->elements[(I)] = (V)) +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_ASDL_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_ast.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_ast.h new file mode 100644 index 0000000000000000000000000000000000000000..60367202bab6370a027998275208863939fad654 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_ast.h @@ -0,0 +1,945 @@ +// File automatically generated by Parser/asdl_c.py. + +#ifndef Py_INTERNAL_AST_H +#define Py_INTERNAL_AST_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_asdl.h" // _ASDL_SEQ_HEAD + +typedef struct _mod *mod_ty; + +typedef struct _stmt *stmt_ty; + +typedef struct _expr *expr_ty; + +typedef enum _expr_context { Load=1, Store=2, Del=3 } expr_context_ty; + +typedef enum _boolop { And=1, Or=2 } boolop_ty; + +typedef enum _operator { Add=1, Sub=2, Mult=3, MatMult=4, Div=5, Mod=6, Pow=7, + LShift=8, RShift=9, BitOr=10, BitXor=11, BitAnd=12, + FloorDiv=13 } operator_ty; + +typedef enum _unaryop { Invert=1, Not=2, UAdd=3, USub=4 } unaryop_ty; + +typedef enum _cmpop { Eq=1, NotEq=2, Lt=3, LtE=4, Gt=5, GtE=6, Is=7, IsNot=8, + In=9, NotIn=10 } cmpop_ty; + +typedef struct _comprehension *comprehension_ty; + +typedef struct _excepthandler *excepthandler_ty; + +typedef struct _arguments *arguments_ty; + +typedef struct _arg *arg_ty; + +typedef struct _keyword *keyword_ty; + +typedef struct _alias *alias_ty; + +typedef struct _withitem *withitem_ty; + +typedef struct _match_case *match_case_ty; + +typedef struct _pattern *pattern_ty; + +typedef struct _type_ignore *type_ignore_ty; + +typedef struct _type_param *type_param_ty; + + +typedef struct { + _ASDL_SEQ_HEAD + mod_ty typed_elements[1]; +} asdl_mod_seq; + +asdl_mod_seq *_Py_asdl_mod_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + stmt_ty typed_elements[1]; +} asdl_stmt_seq; + +asdl_stmt_seq *_Py_asdl_stmt_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + expr_ty typed_elements[1]; +} asdl_expr_seq; + +asdl_expr_seq *_Py_asdl_expr_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + comprehension_ty typed_elements[1]; +} asdl_comprehension_seq; + +asdl_comprehension_seq *_Py_asdl_comprehension_seq_new(Py_ssize_t size, PyArena + *arena); + +typedef struct { + _ASDL_SEQ_HEAD + excepthandler_ty typed_elements[1]; +} asdl_excepthandler_seq; + +asdl_excepthandler_seq *_Py_asdl_excepthandler_seq_new(Py_ssize_t size, PyArena + *arena); + +typedef struct { + _ASDL_SEQ_HEAD + arguments_ty typed_elements[1]; +} asdl_arguments_seq; + +asdl_arguments_seq *_Py_asdl_arguments_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + arg_ty typed_elements[1]; +} asdl_arg_seq; + +asdl_arg_seq *_Py_asdl_arg_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + keyword_ty typed_elements[1]; +} asdl_keyword_seq; + +asdl_keyword_seq *_Py_asdl_keyword_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + alias_ty typed_elements[1]; +} asdl_alias_seq; + +asdl_alias_seq *_Py_asdl_alias_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + withitem_ty typed_elements[1]; +} asdl_withitem_seq; + +asdl_withitem_seq *_Py_asdl_withitem_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + match_case_ty typed_elements[1]; +} asdl_match_case_seq; + +asdl_match_case_seq *_Py_asdl_match_case_seq_new(Py_ssize_t size, PyArena + *arena); + +typedef struct { + _ASDL_SEQ_HEAD + pattern_ty typed_elements[1]; +} asdl_pattern_seq; + +asdl_pattern_seq *_Py_asdl_pattern_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + type_ignore_ty typed_elements[1]; +} asdl_type_ignore_seq; + +asdl_type_ignore_seq *_Py_asdl_type_ignore_seq_new(Py_ssize_t size, PyArena + *arena); + +typedef struct { + _ASDL_SEQ_HEAD + type_param_ty typed_elements[1]; +} asdl_type_param_seq; + +asdl_type_param_seq *_Py_asdl_type_param_seq_new(Py_ssize_t size, PyArena + *arena); + + +enum _mod_kind {Module_kind=1, Interactive_kind=2, Expression_kind=3, + FunctionType_kind=4}; +struct _mod { + enum _mod_kind kind; + union { + struct { + asdl_stmt_seq *body; + asdl_type_ignore_seq *type_ignores; + } Module; + + struct { + asdl_stmt_seq *body; + } Interactive; + + struct { + expr_ty body; + } Expression; + + struct { + asdl_expr_seq *argtypes; + expr_ty returns; + } FunctionType; + + } v; +}; + +enum _stmt_kind {FunctionDef_kind=1, AsyncFunctionDef_kind=2, ClassDef_kind=3, + Return_kind=4, Delete_kind=5, Assign_kind=6, + TypeAlias_kind=7, AugAssign_kind=8, AnnAssign_kind=9, + For_kind=10, AsyncFor_kind=11, While_kind=12, If_kind=13, + With_kind=14, AsyncWith_kind=15, Match_kind=16, + Raise_kind=17, Try_kind=18, TryStar_kind=19, Assert_kind=20, + Import_kind=21, ImportFrom_kind=22, Global_kind=23, + Nonlocal_kind=24, Expr_kind=25, Pass_kind=26, Break_kind=27, + Continue_kind=28}; +struct _stmt { + enum _stmt_kind kind; + union { + struct { + identifier name; + arguments_ty args; + asdl_stmt_seq *body; + asdl_expr_seq *decorator_list; + expr_ty returns; + string type_comment; + asdl_type_param_seq *type_params; + } FunctionDef; + + struct { + identifier name; + arguments_ty args; + asdl_stmt_seq *body; + asdl_expr_seq *decorator_list; + expr_ty returns; + string type_comment; + asdl_type_param_seq *type_params; + } AsyncFunctionDef; + + struct { + identifier name; + asdl_expr_seq *bases; + asdl_keyword_seq *keywords; + asdl_stmt_seq *body; + asdl_expr_seq *decorator_list; + asdl_type_param_seq *type_params; + } ClassDef; + + struct { + expr_ty value; + } Return; + + struct { + asdl_expr_seq *targets; + } Delete; + + struct { + asdl_expr_seq *targets; + expr_ty value; + string type_comment; + } Assign; + + struct { + expr_ty name; + asdl_type_param_seq *type_params; + expr_ty value; + } TypeAlias; + + struct { + expr_ty target; + operator_ty op; + expr_ty value; + } AugAssign; + + struct { + expr_ty target; + expr_ty annotation; + expr_ty value; + int simple; + } AnnAssign; + + struct { + expr_ty target; + expr_ty iter; + asdl_stmt_seq *body; + asdl_stmt_seq *orelse; + string type_comment; + } For; + + struct { + expr_ty target; + expr_ty iter; + asdl_stmt_seq *body; + asdl_stmt_seq *orelse; + string type_comment; + } AsyncFor; + + struct { + expr_ty test; + asdl_stmt_seq *body; + asdl_stmt_seq *orelse; + } While; + + struct { + expr_ty test; + asdl_stmt_seq *body; + asdl_stmt_seq *orelse; + } If; + + struct { + asdl_withitem_seq *items; + asdl_stmt_seq *body; + string type_comment; + } With; + + struct { + asdl_withitem_seq *items; + asdl_stmt_seq *body; + string type_comment; + } AsyncWith; + + struct { + expr_ty subject; + asdl_match_case_seq *cases; + } Match; + + struct { + expr_ty exc; + expr_ty cause; + } Raise; + + struct { + asdl_stmt_seq *body; + asdl_excepthandler_seq *handlers; + asdl_stmt_seq *orelse; + asdl_stmt_seq *finalbody; + } Try; + + struct { + asdl_stmt_seq *body; + asdl_excepthandler_seq *handlers; + asdl_stmt_seq *orelse; + asdl_stmt_seq *finalbody; + } TryStar; + + struct { + expr_ty test; + expr_ty msg; + } Assert; + + struct { + asdl_alias_seq *names; + } Import; + + struct { + identifier module; + asdl_alias_seq *names; + int level; + } ImportFrom; + + struct { + asdl_identifier_seq *names; + } Global; + + struct { + asdl_identifier_seq *names; + } Nonlocal; + + struct { + expr_ty value; + } Expr; + + } v; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + +enum _expr_kind {BoolOp_kind=1, NamedExpr_kind=2, BinOp_kind=3, UnaryOp_kind=4, + Lambda_kind=5, IfExp_kind=6, Dict_kind=7, Set_kind=8, + ListComp_kind=9, SetComp_kind=10, DictComp_kind=11, + GeneratorExp_kind=12, Await_kind=13, Yield_kind=14, + YieldFrom_kind=15, Compare_kind=16, Call_kind=17, + FormattedValue_kind=18, Interpolation_kind=19, + JoinedStr_kind=20, TemplateStr_kind=21, Constant_kind=22, + Attribute_kind=23, Subscript_kind=24, Starred_kind=25, + Name_kind=26, List_kind=27, Tuple_kind=28, Slice_kind=29}; +struct _expr { + enum _expr_kind kind; + union { + struct { + boolop_ty op; + asdl_expr_seq *values; + } BoolOp; + + struct { + expr_ty target; + expr_ty value; + } NamedExpr; + + struct { + expr_ty left; + operator_ty op; + expr_ty right; + } BinOp; + + struct { + unaryop_ty op; + expr_ty operand; + } UnaryOp; + + struct { + arguments_ty args; + expr_ty body; + } Lambda; + + struct { + expr_ty test; + expr_ty body; + expr_ty orelse; + } IfExp; + + struct { + asdl_expr_seq *keys; + asdl_expr_seq *values; + } Dict; + + struct { + asdl_expr_seq *elts; + } Set; + + struct { + expr_ty elt; + asdl_comprehension_seq *generators; + } ListComp; + + struct { + expr_ty elt; + asdl_comprehension_seq *generators; + } SetComp; + + struct { + expr_ty key; + expr_ty value; + asdl_comprehension_seq *generators; + } DictComp; + + struct { + expr_ty elt; + asdl_comprehension_seq *generators; + } GeneratorExp; + + struct { + expr_ty value; + } Await; + + struct { + expr_ty value; + } Yield; + + struct { + expr_ty value; + } YieldFrom; + + struct { + expr_ty left; + asdl_int_seq *ops; + asdl_expr_seq *comparators; + } Compare; + + struct { + expr_ty func; + asdl_expr_seq *args; + asdl_keyword_seq *keywords; + } Call; + + struct { + expr_ty value; + int conversion; + expr_ty format_spec; + } FormattedValue; + + struct { + expr_ty value; + constant str; + int conversion; + expr_ty format_spec; + } Interpolation; + + struct { + asdl_expr_seq *values; + } JoinedStr; + + struct { + asdl_expr_seq *values; + } TemplateStr; + + struct { + constant value; + string kind; + } Constant; + + struct { + expr_ty value; + identifier attr; + expr_context_ty ctx; + } Attribute; + + struct { + expr_ty value; + expr_ty slice; + expr_context_ty ctx; + } Subscript; + + struct { + expr_ty value; + expr_context_ty ctx; + } Starred; + + struct { + identifier id; + expr_context_ty ctx; + } Name; + + struct { + asdl_expr_seq *elts; + expr_context_ty ctx; + } List; + + struct { + asdl_expr_seq *elts; + expr_context_ty ctx; + } Tuple; + + struct { + expr_ty lower; + expr_ty upper; + expr_ty step; + } Slice; + + } v; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + +struct _comprehension { + expr_ty target; + expr_ty iter; + asdl_expr_seq *ifs; + int is_async; +}; + +enum _excepthandler_kind {ExceptHandler_kind=1}; +struct _excepthandler { + enum _excepthandler_kind kind; + union { + struct { + expr_ty type; + identifier name; + asdl_stmt_seq *body; + } ExceptHandler; + + } v; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + +struct _arguments { + asdl_arg_seq *posonlyargs; + asdl_arg_seq *args; + arg_ty vararg; + asdl_arg_seq *kwonlyargs; + asdl_expr_seq *kw_defaults; + arg_ty kwarg; + asdl_expr_seq *defaults; +}; + +struct _arg { + identifier arg; + expr_ty annotation; + string type_comment; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + +struct _keyword { + identifier arg; + expr_ty value; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + +struct _alias { + identifier name; + identifier asname; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + +struct _withitem { + expr_ty context_expr; + expr_ty optional_vars; +}; + +struct _match_case { + pattern_ty pattern; + expr_ty guard; + asdl_stmt_seq *body; +}; + +enum _pattern_kind {MatchValue_kind=1, MatchSingleton_kind=2, + MatchSequence_kind=3, MatchMapping_kind=4, + MatchClass_kind=5, MatchStar_kind=6, MatchAs_kind=7, + MatchOr_kind=8}; +struct _pattern { + enum _pattern_kind kind; + union { + struct { + expr_ty value; + } MatchValue; + + struct { + constant value; + } MatchSingleton; + + struct { + asdl_pattern_seq *patterns; + } MatchSequence; + + struct { + asdl_expr_seq *keys; + asdl_pattern_seq *patterns; + identifier rest; + } MatchMapping; + + struct { + expr_ty cls; + asdl_pattern_seq *patterns; + asdl_identifier_seq *kwd_attrs; + asdl_pattern_seq *kwd_patterns; + } MatchClass; + + struct { + identifier name; + } MatchStar; + + struct { + pattern_ty pattern; + identifier name; + } MatchAs; + + struct { + asdl_pattern_seq *patterns; + } MatchOr; + + } v; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + +enum _type_ignore_kind {TypeIgnore_kind=1}; +struct _type_ignore { + enum _type_ignore_kind kind; + union { + struct { + int lineno; + string tag; + } TypeIgnore; + + } v; +}; + +enum _type_param_kind {TypeVar_kind=1, ParamSpec_kind=2, TypeVarTuple_kind=3}; +struct _type_param { + enum _type_param_kind kind; + union { + struct { + identifier name; + expr_ty bound; + expr_ty default_value; + } TypeVar; + + struct { + identifier name; + expr_ty default_value; + } ParamSpec; + + struct { + identifier name; + expr_ty default_value; + } TypeVarTuple; + + } v; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + + +// Note: these macros affect function definitions, not only call sites. +mod_ty _PyAST_Module(asdl_stmt_seq * body, asdl_type_ignore_seq * type_ignores, + PyArena *arena); +mod_ty _PyAST_Interactive(asdl_stmt_seq * body, PyArena *arena); +mod_ty _PyAST_Expression(expr_ty body, PyArena *arena); +mod_ty _PyAST_FunctionType(asdl_expr_seq * argtypes, expr_ty returns, PyArena + *arena); +stmt_ty _PyAST_FunctionDef(identifier name, arguments_ty args, asdl_stmt_seq * + body, asdl_expr_seq * decorator_list, expr_ty + returns, string type_comment, asdl_type_param_seq * + type_params, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_AsyncFunctionDef(identifier name, arguments_ty args, + asdl_stmt_seq * body, asdl_expr_seq * + decorator_list, expr_ty returns, string + type_comment, asdl_type_param_seq * + type_params, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_ClassDef(identifier name, asdl_expr_seq * bases, + asdl_keyword_seq * keywords, asdl_stmt_seq * body, + asdl_expr_seq * decorator_list, asdl_type_param_seq * + type_params, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Return(expr_ty value, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Delete(asdl_expr_seq * targets, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Assign(asdl_expr_seq * targets, expr_ty value, string + type_comment, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +stmt_ty _PyAST_TypeAlias(expr_ty name, asdl_type_param_seq * type_params, + expr_ty value, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_AugAssign(expr_ty target, operator_ty op, expr_ty value, int + lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_AnnAssign(expr_ty target, expr_ty annotation, expr_ty value, int + simple, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +stmt_ty _PyAST_For(expr_ty target, expr_ty iter, asdl_stmt_seq * body, + asdl_stmt_seq * orelse, string type_comment, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +stmt_ty _PyAST_AsyncFor(expr_ty target, expr_ty iter, asdl_stmt_seq * body, + asdl_stmt_seq * orelse, string type_comment, int + lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_While(expr_ty test, asdl_stmt_seq * body, asdl_stmt_seq * + orelse, int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_If(expr_ty test, asdl_stmt_seq * body, asdl_stmt_seq * orelse, + int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_With(asdl_withitem_seq * items, asdl_stmt_seq * body, string + type_comment, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +stmt_ty _PyAST_AsyncWith(asdl_withitem_seq * items, asdl_stmt_seq * body, + string type_comment, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Match(expr_ty subject, asdl_match_case_seq * cases, int lineno, + int col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +stmt_ty _PyAST_Raise(expr_ty exc, expr_ty cause, int lineno, int col_offset, + int end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Try(asdl_stmt_seq * body, asdl_excepthandler_seq * handlers, + asdl_stmt_seq * orelse, asdl_stmt_seq * finalbody, int + lineno, int col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +stmt_ty _PyAST_TryStar(asdl_stmt_seq * body, asdl_excepthandler_seq * handlers, + asdl_stmt_seq * orelse, asdl_stmt_seq * finalbody, int + lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_Assert(expr_ty test, expr_ty msg, int lineno, int col_offset, + int end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Import(asdl_alias_seq * names, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_ImportFrom(identifier module, asdl_alias_seq * names, int level, + int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_Global(asdl_identifier_seq * names, int lineno, int col_offset, + int end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Nonlocal(asdl_identifier_seq * names, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +stmt_ty _PyAST_Expr(expr_ty value, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Pass(int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_Break(int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_Continue(int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_BoolOp(boolop_ty op, asdl_expr_seq * values, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_NamedExpr(expr_ty target, expr_ty value, int lineno, int + col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +expr_ty _PyAST_BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, + int col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +expr_ty _PyAST_UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_Lambda(arguments_ty args, expr_ty body, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, + int col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +expr_ty _PyAST_Dict(asdl_expr_seq * keys, asdl_expr_seq * values, int lineno, + int col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_Set(asdl_expr_seq * elts, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +expr_ty _PyAST_ListComp(expr_ty elt, asdl_comprehension_seq * generators, int + lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_SetComp(expr_ty elt, asdl_comprehension_seq * generators, int + lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_DictComp(expr_ty key, expr_ty value, asdl_comprehension_seq * + generators, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +expr_ty _PyAST_GeneratorExp(expr_ty elt, asdl_comprehension_seq * generators, + int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_Await(expr_ty value, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +expr_ty _PyAST_Yield(expr_ty value, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +expr_ty _PyAST_YieldFrom(expr_ty value, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +expr_ty _PyAST_Compare(expr_ty left, asdl_int_seq * ops, asdl_expr_seq * + comparators, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +expr_ty _PyAST_Call(expr_ty func, asdl_expr_seq * args, asdl_keyword_seq * + keywords, int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_FormattedValue(expr_ty value, int conversion, expr_ty + format_spec, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +expr_ty _PyAST_Interpolation(expr_ty value, constant str, int conversion, + expr_ty format_spec, int lineno, int col_offset, + int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_JoinedStr(asdl_expr_seq * values, int lineno, int col_offset, + int end_lineno, int end_col_offset, PyArena *arena); +expr_ty _PyAST_TemplateStr(asdl_expr_seq * values, int lineno, int col_offset, + int end_lineno, int end_col_offset, PyArena *arena); +expr_ty _PyAST_Constant(constant value, string kind, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_Attribute(expr_ty value, identifier attr, expr_context_ty ctx, + int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_Subscript(expr_ty value, expr_ty slice, expr_context_ty ctx, int + lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_Starred(expr_ty value, expr_context_ty ctx, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_Name(identifier id, expr_context_ty ctx, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_List(asdl_expr_seq * elts, expr_context_ty ctx, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_Tuple(asdl_expr_seq * elts, expr_context_ty ctx, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_Slice(expr_ty lower, expr_ty upper, expr_ty step, int lineno, + int col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +comprehension_ty _PyAST_comprehension(expr_ty target, expr_ty iter, + asdl_expr_seq * ifs, int is_async, + PyArena *arena); +excepthandler_ty _PyAST_ExceptHandler(expr_ty type, identifier name, + asdl_stmt_seq * body, int lineno, int + col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +arguments_ty _PyAST_arguments(asdl_arg_seq * posonlyargs, asdl_arg_seq * args, + arg_ty vararg, asdl_arg_seq * kwonlyargs, + asdl_expr_seq * kw_defaults, arg_ty kwarg, + asdl_expr_seq * defaults, PyArena *arena); +arg_ty _PyAST_arg(identifier arg, expr_ty annotation, string type_comment, int + lineno, int col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +keyword_ty _PyAST_keyword(identifier arg, expr_ty value, int lineno, int + col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +alias_ty _PyAST_alias(identifier name, identifier asname, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +withitem_ty _PyAST_withitem(expr_ty context_expr, expr_ty optional_vars, + PyArena *arena); +match_case_ty _PyAST_match_case(pattern_ty pattern, expr_ty guard, + asdl_stmt_seq * body, PyArena *arena); +pattern_ty _PyAST_MatchValue(expr_ty value, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +pattern_ty _PyAST_MatchSingleton(constant value, int lineno, int col_offset, + int end_lineno, int end_col_offset, PyArena + *arena); +pattern_ty _PyAST_MatchSequence(asdl_pattern_seq * patterns, int lineno, int + col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +pattern_ty _PyAST_MatchMapping(asdl_expr_seq * keys, asdl_pattern_seq * + patterns, identifier rest, int lineno, int + col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +pattern_ty _PyAST_MatchClass(expr_ty cls, asdl_pattern_seq * patterns, + asdl_identifier_seq * kwd_attrs, asdl_pattern_seq + * kwd_patterns, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +pattern_ty _PyAST_MatchStar(identifier name, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +pattern_ty _PyAST_MatchAs(pattern_ty pattern, identifier name, int lineno, int + col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +pattern_ty _PyAST_MatchOr(asdl_pattern_seq * patterns, int lineno, int + col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +type_ignore_ty _PyAST_TypeIgnore(int lineno, string tag, PyArena *arena); +type_param_ty _PyAST_TypeVar(identifier name, expr_ty bound, expr_ty + default_value, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +type_param_ty _PyAST_ParamSpec(identifier name, expr_ty default_value, int + lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +type_param_ty _PyAST_TypeVarTuple(identifier name, expr_ty default_value, int + lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); + + +PyObject* PyAST_mod2obj(mod_ty t); +int PyAst_CheckMode(PyObject *ast, int mode); +mod_ty PyAST_obj2mod(PyObject* ast, PyArena* arena, int mode); +int PyAST_Check(PyObject* obj); + +extern int _PyAST_Validate(mod_ty); + +/* _PyAST_ExprAsUnicode is defined in ast_unparse.c */ +extern PyObject* _PyAST_ExprAsUnicode(expr_ty); + +/* Return the borrowed reference to the first literal string in the + sequence of statements or NULL if it doesn't start from a literal string. + Doesn't set exception. */ +extern PyObject* _PyAST_GetDocString(asdl_stmt_seq *); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_AST_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_ast_state.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_ast_state.h new file mode 100644 index 0000000000000000000000000000000000000000..d4ac419f51d6b2d2c46de6f7b6aa89a8027a9f09 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_ast_state.h @@ -0,0 +1,271 @@ +// File automatically generated by Parser/asdl_c.py. + +#ifndef Py_INTERNAL_AST_STATE_H +#define Py_INTERNAL_AST_STATE_H + +#include "pycore_lock.h" // _PyOnceFlag + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +struct ast_state { + _PyOnceFlag once; + int finalized; + PyObject *AST_type; + PyObject *Add_singleton; + PyObject *Add_type; + PyObject *And_singleton; + PyObject *And_type; + PyObject *AnnAssign_type; + PyObject *Assert_type; + PyObject *Assign_type; + PyObject *AsyncFor_type; + PyObject *AsyncFunctionDef_type; + PyObject *AsyncWith_type; + PyObject *Attribute_type; + PyObject *AugAssign_type; + PyObject *Await_type; + PyObject *BinOp_type; + PyObject *BitAnd_singleton; + PyObject *BitAnd_type; + PyObject *BitOr_singleton; + PyObject *BitOr_type; + PyObject *BitXor_singleton; + PyObject *BitXor_type; + PyObject *BoolOp_type; + PyObject *Break_type; + PyObject *Call_type; + PyObject *ClassDef_type; + PyObject *Compare_type; + PyObject *Constant_type; + PyObject *Continue_type; + PyObject *Del_singleton; + PyObject *Del_type; + PyObject *Delete_type; + PyObject *DictComp_type; + PyObject *Dict_type; + PyObject *Div_singleton; + PyObject *Div_type; + PyObject *Eq_singleton; + PyObject *Eq_type; + PyObject *ExceptHandler_type; + PyObject *Expr_type; + PyObject *Expression_type; + PyObject *FloorDiv_singleton; + PyObject *FloorDiv_type; + PyObject *For_type; + PyObject *FormattedValue_type; + PyObject *FunctionDef_type; + PyObject *FunctionType_type; + PyObject *GeneratorExp_type; + PyObject *Global_type; + PyObject *GtE_singleton; + PyObject *GtE_type; + PyObject *Gt_singleton; + PyObject *Gt_type; + PyObject *IfExp_type; + PyObject *If_type; + PyObject *ImportFrom_type; + PyObject *Import_type; + PyObject *In_singleton; + PyObject *In_type; + PyObject *Interactive_type; + PyObject *Interpolation_type; + PyObject *Invert_singleton; + PyObject *Invert_type; + PyObject *IsNot_singleton; + PyObject *IsNot_type; + PyObject *Is_singleton; + PyObject *Is_type; + PyObject *JoinedStr_type; + PyObject *LShift_singleton; + PyObject *LShift_type; + PyObject *Lambda_type; + PyObject *ListComp_type; + PyObject *List_type; + PyObject *Load_singleton; + PyObject *Load_type; + PyObject *LtE_singleton; + PyObject *LtE_type; + PyObject *Lt_singleton; + PyObject *Lt_type; + PyObject *MatMult_singleton; + PyObject *MatMult_type; + PyObject *MatchAs_type; + PyObject *MatchClass_type; + PyObject *MatchMapping_type; + PyObject *MatchOr_type; + PyObject *MatchSequence_type; + PyObject *MatchSingleton_type; + PyObject *MatchStar_type; + PyObject *MatchValue_type; + PyObject *Match_type; + PyObject *Mod_singleton; + PyObject *Mod_type; + PyObject *Module_type; + PyObject *Mult_singleton; + PyObject *Mult_type; + PyObject *Name_type; + PyObject *NamedExpr_type; + PyObject *Nonlocal_type; + PyObject *NotEq_singleton; + PyObject *NotEq_type; + PyObject *NotIn_singleton; + PyObject *NotIn_type; + PyObject *Not_singleton; + PyObject *Not_type; + PyObject *Or_singleton; + PyObject *Or_type; + PyObject *ParamSpec_type; + PyObject *Pass_type; + PyObject *Pow_singleton; + PyObject *Pow_type; + PyObject *RShift_singleton; + PyObject *RShift_type; + PyObject *Raise_type; + PyObject *Return_type; + PyObject *SetComp_type; + PyObject *Set_type; + PyObject *Slice_type; + PyObject *Starred_type; + PyObject *Store_singleton; + PyObject *Store_type; + PyObject *Sub_singleton; + PyObject *Sub_type; + PyObject *Subscript_type; + PyObject *TemplateStr_type; + PyObject *TryStar_type; + PyObject *Try_type; + PyObject *Tuple_type; + PyObject *TypeAlias_type; + PyObject *TypeIgnore_type; + PyObject *TypeVarTuple_type; + PyObject *TypeVar_type; + PyObject *UAdd_singleton; + PyObject *UAdd_type; + PyObject *USub_singleton; + PyObject *USub_type; + PyObject *UnaryOp_type; + PyObject *While_type; + PyObject *With_type; + PyObject *YieldFrom_type; + PyObject *Yield_type; + PyObject *__dict__; + PyObject *__doc__; + PyObject *__match_args__; + PyObject *__module__; + PyObject *_attributes; + PyObject *_fields; + PyObject *alias_type; + PyObject *annotation; + PyObject *arg; + PyObject *arg_type; + PyObject *args; + PyObject *argtypes; + PyObject *arguments_type; + PyObject *asname; + PyObject *ast; + PyObject *attr; + PyObject *bases; + PyObject *body; + PyObject *boolop_type; + PyObject *bound; + PyObject *cases; + PyObject *cause; + PyObject *cls; + PyObject *cmpop_type; + PyObject *col_offset; + PyObject *comparators; + PyObject *comprehension_type; + PyObject *context_expr; + PyObject *conversion; + PyObject *ctx; + PyObject *decorator_list; + PyObject *default_value; + PyObject *defaults; + PyObject *elt; + PyObject *elts; + PyObject *end_col_offset; + PyObject *end_lineno; + PyObject *exc; + PyObject *excepthandler_type; + PyObject *expr_context_type; + PyObject *expr_type; + PyObject *finalbody; + PyObject *format_spec; + PyObject *func; + PyObject *generators; + PyObject *guard; + PyObject *handlers; + PyObject *id; + PyObject *ifs; + PyObject *is_async; + PyObject *items; + PyObject *iter; + PyObject *key; + PyObject *keys; + PyObject *keyword_type; + PyObject *keywords; + PyObject *kind; + PyObject *kw_defaults; + PyObject *kwarg; + PyObject *kwd_attrs; + PyObject *kwd_patterns; + PyObject *kwonlyargs; + PyObject *left; + PyObject *level; + PyObject *lineno; + PyObject *lower; + PyObject *match_case_type; + PyObject *mod_type; + PyObject *module; + PyObject *msg; + PyObject *name; + PyObject *names; + PyObject *op; + PyObject *operand; + PyObject *operator_type; + PyObject *ops; + PyObject *optional_vars; + PyObject *orelse; + PyObject *pattern; + PyObject *pattern_type; + PyObject *patterns; + PyObject *posonlyargs; + PyObject *rest; + PyObject *returns; + PyObject *right; + PyObject *simple; + PyObject *slice; + PyObject *step; + PyObject *stmt_type; + PyObject *str; + PyObject *subject; + PyObject *tag; + PyObject *target; + PyObject *targets; + PyObject *test; + PyObject *type; + PyObject *type_comment; + PyObject *type_ignore_type; + PyObject *type_ignores; + PyObject *type_param_type; + PyObject *type_params; + PyObject *unaryop_type; + PyObject *upper; + PyObject *value; + PyObject *values; + PyObject *vararg; + PyObject *withitem_type; +}; + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_AST_STATE_H */ + diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_atexit.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_atexit.h new file mode 100644 index 0000000000000000000000000000000000000000..1199b00ead3769c43457ff2e0adc2c8ec0b75103 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_atexit.h @@ -0,0 +1,31 @@ +#ifndef Py_INTERNAL_ATEXIT_H +#define Py_INTERNAL_ATEXIT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + + + +#ifdef Py_GIL_DISABLED +# define _PyAtExit_LockCallbacks(state) PyMutex_Lock(&state->ll_callbacks_lock); +# define _PyAtExit_UnlockCallbacks(state) PyMutex_Unlock(&state->ll_callbacks_lock); +#else +# define _PyAtExit_LockCallbacks(state) +# define _PyAtExit_UnlockCallbacks(state) +#endif + +// Export for '_interpchannels' shared extension +PyAPI_FUNC(int) _Py_AtExit( + PyInterpreterState *interp, + atexit_datacallbackfunc func, + void *data); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_ATEXIT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_audit.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_audit.h new file mode 100644 index 0000000000000000000000000000000000000000..2811aaa6236123c0812ae065829c5e4bfa59c9a9 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_audit.h @@ -0,0 +1,35 @@ +#ifndef Py_INTERNAL_AUDIT_H +#define Py_INTERNAL_AUDIT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + + +/* Runtime audit hook state */ + +typedef struct _Py_AuditHookEntry { + struct _Py_AuditHookEntry *next; + Py_AuditHookFunction hookCFunction; + void *userData; +} _Py_AuditHookEntry; + + +extern int _PySys_Audit( + PyThreadState *tstate, + const char *event, + const char *argFormat, + ...); + +// _PySys_ClearAuditHooks() must not be exported: use extern rather than +// PyAPI_FUNC(). We want minimal exposure of this function. +extern void _PySys_ClearAuditHooks(PyThreadState *tstate); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_AUDIT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_backoff.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_backoff.h new file mode 100644 index 0000000000000000000000000000000000000000..942d8b107a7dafb37c3483f4877e9e61d42cf629 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_backoff.h @@ -0,0 +1,133 @@ + +#ifndef Py_INTERNAL_BACKOFF_H +#define Py_INTERNAL_BACKOFF_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include +#include +#include "pycore_structs.h" // _Py_BackoffCounter + +/* 16-bit countdown counters using exponential backoff. + + These are used by the adaptive specializer to count down until + it is time to specialize an instruction. If specialization fails + the counter is reset using exponential backoff. + + Another use is for the Tier 2 optimizer to decide when to create + a new Tier 2 trace (executor). Again, exponential backoff is used. + + The 16-bit counter is structured as a 12-bit unsigned 'value' + and a 4-bit 'backoff' field. When resetting the counter, the + backoff field is incremented (until it reaches a limit) and the + value is set to a bit mask representing the value 2**backoff - 1. + The maximum backoff is 12 (the number of bits in the value). + + There is an exceptional value which must not be updated, 0xFFFF. +*/ + +#define BACKOFF_BITS 4 +#define MAX_BACKOFF 12 +#define UNREACHABLE_BACKOFF 15 + +static inline bool +is_unreachable_backoff_counter(_Py_BackoffCounter counter) +{ + return counter.value_and_backoff == UNREACHABLE_BACKOFF; +} + +static inline _Py_BackoffCounter +make_backoff_counter(uint16_t value, uint16_t backoff) +{ + assert(backoff <= 15); + assert(value <= 0xFFF); + _Py_BackoffCounter result; + result.value_and_backoff = (value << BACKOFF_BITS) | backoff; + return result; +} + +static inline _Py_BackoffCounter +forge_backoff_counter(uint16_t counter) +{ + _Py_BackoffCounter result; + result.value_and_backoff = counter; + return result; +} + +static inline _Py_BackoffCounter +restart_backoff_counter(_Py_BackoffCounter counter) +{ + assert(!is_unreachable_backoff_counter(counter)); + int backoff = counter.value_and_backoff & 15; + if (backoff < MAX_BACKOFF) { + return make_backoff_counter((1 << (backoff + 1)) - 1, backoff + 1); + } + else { + return make_backoff_counter((1 << MAX_BACKOFF) - 1, MAX_BACKOFF); + } +} + +static inline _Py_BackoffCounter +pause_backoff_counter(_Py_BackoffCounter counter) +{ + _Py_BackoffCounter result; + result.value_and_backoff = counter.value_and_backoff | (1 << BACKOFF_BITS); + return result; +} + +static inline _Py_BackoffCounter +advance_backoff_counter(_Py_BackoffCounter counter) +{ + _Py_BackoffCounter result; + result.value_and_backoff = counter.value_and_backoff - (1 << BACKOFF_BITS); + return result; +} + +static inline bool +backoff_counter_triggers(_Py_BackoffCounter counter) +{ + /* Test whether the value is zero and the backoff is not UNREACHABLE_BACKOFF */ + return counter.value_and_backoff < UNREACHABLE_BACKOFF; +} + +/* Initial JUMP_BACKWARD counter. + * This determines when we create a trace for a loop. */ +#define JUMP_BACKWARD_INITIAL_VALUE 4095 +#define JUMP_BACKWARD_INITIAL_BACKOFF 12 +static inline _Py_BackoffCounter +initial_jump_backoff_counter(void) +{ + return make_backoff_counter(JUMP_BACKWARD_INITIAL_VALUE, + JUMP_BACKWARD_INITIAL_BACKOFF); +} + +/* Initial exit temperature. + * Must be larger than ADAPTIVE_COOLDOWN_VALUE, + * otherwise when a side exit warms up we may construct + * a new trace before the Tier 1 code has properly re-specialized. */ +#define SIDE_EXIT_INITIAL_VALUE 4095 +#define SIDE_EXIT_INITIAL_BACKOFF 12 + +static inline _Py_BackoffCounter +initial_temperature_backoff_counter(void) +{ + return make_backoff_counter(SIDE_EXIT_INITIAL_VALUE, + SIDE_EXIT_INITIAL_BACKOFF); +} + +/* Unreachable backoff counter. */ +static inline _Py_BackoffCounter +initial_unreachable_backoff_counter(void) +{ + return make_backoff_counter(0, UNREACHABLE_BACKOFF); +} + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_BACKOFF_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_bitutils.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_bitutils.h new file mode 100644 index 0000000000000000000000000000000000000000..50f69377523818ff1177b648a6efb6427b51ff98 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_bitutils.h @@ -0,0 +1,186 @@ +/* Bit and bytes utilities. + + Bytes swap functions, reverse order of bytes: + + - _Py_bswap16(uint16_t) + - _Py_bswap32(uint32_t) + - _Py_bswap64(uint64_t) +*/ + +#ifndef Py_INTERNAL_BITUTILS_H +#define Py_INTERNAL_BITUTILS_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#if defined(__GNUC__) \ + && ((__GNUC__ >= 5) || (__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) + /* __builtin_bswap16() is available since GCC 4.8, + __builtin_bswap32() is available since GCC 4.3, + __builtin_bswap64() is available since GCC 4.3. */ +# define _PY_HAVE_BUILTIN_BSWAP +#endif + +#ifdef _MSC_VER +# include // _byteswap_uint64() +#endif + + +static inline uint16_t +_Py_bswap16(uint16_t word) +{ +#if defined(_PY_HAVE_BUILTIN_BSWAP) || _Py__has_builtin(__builtin_bswap16) + return __builtin_bswap16(word); +#elif defined(_MSC_VER) + Py_BUILD_ASSERT(sizeof(word) == sizeof(unsigned short)); + return _byteswap_ushort(word); +#else + // Portable implementation which doesn't rely on circular bit shift + return ( ((word & UINT16_C(0x00FF)) << 8) + | ((word & UINT16_C(0xFF00)) >> 8)); +#endif +} + +static inline uint32_t +_Py_bswap32(uint32_t word) +{ +#if defined(_PY_HAVE_BUILTIN_BSWAP) || _Py__has_builtin(__builtin_bswap32) + return __builtin_bswap32(word); +#elif defined(_MSC_VER) + Py_BUILD_ASSERT(sizeof(word) == sizeof(unsigned long)); + return _byteswap_ulong(word); +#else + // Portable implementation which doesn't rely on circular bit shift + return ( ((word & UINT32_C(0x000000FF)) << 24) + | ((word & UINT32_C(0x0000FF00)) << 8) + | ((word & UINT32_C(0x00FF0000)) >> 8) + | ((word & UINT32_C(0xFF000000)) >> 24)); +#endif +} + +static inline uint64_t +_Py_bswap64(uint64_t word) +{ +#if defined(_PY_HAVE_BUILTIN_BSWAP) || _Py__has_builtin(__builtin_bswap64) + return __builtin_bswap64(word); +#elif defined(_MSC_VER) + return _byteswap_uint64(word); +#else + // Portable implementation which doesn't rely on circular bit shift + return ( ((word & UINT64_C(0x00000000000000FF)) << 56) + | ((word & UINT64_C(0x000000000000FF00)) << 40) + | ((word & UINT64_C(0x0000000000FF0000)) << 24) + | ((word & UINT64_C(0x00000000FF000000)) << 8) + | ((word & UINT64_C(0x000000FF00000000)) >> 8) + | ((word & UINT64_C(0x0000FF0000000000)) >> 24) + | ((word & UINT64_C(0x00FF000000000000)) >> 40) + | ((word & UINT64_C(0xFF00000000000000)) >> 56)); +#endif +} + + +// Population count: count the number of 1's in 'x' +// (number of bits set to 1), also known as the hamming weight. +// +// Implementation note. CPUID is not used, to test if x86 POPCNT instruction +// can be used, to keep the implementation simple. For example, Visual Studio +// __popcnt() is not used this reason. The clang and GCC builtin function can +// use the x86 POPCNT instruction if the target architecture has SSE4a or +// newer. +static inline int +_Py_popcount32(uint32_t x) +{ +#if (defined(__clang__) || defined(__GNUC__)) + +#if SIZEOF_INT >= 4 + Py_BUILD_ASSERT(sizeof(x) <= sizeof(unsigned int)); + return __builtin_popcount(x); +#else + // The C standard guarantees that unsigned long will always be big enough + // to hold a uint32_t value without losing information. + Py_BUILD_ASSERT(sizeof(x) <= sizeof(unsigned long)); + return __builtin_popcountl(x); +#endif + +#else + // 32-bit SWAR (SIMD Within A Register) popcount + + // Binary: 0 1 0 1 ... + const uint32_t M1 = 0x55555555; + // Binary: 00 11 00 11. .. + const uint32_t M2 = 0x33333333; + // Binary: 0000 1111 0000 1111 ... + const uint32_t M4 = 0x0F0F0F0F; + + // Put count of each 2 bits into those 2 bits + x = x - ((x >> 1) & M1); + // Put count of each 4 bits into those 4 bits + x = (x & M2) + ((x >> 2) & M2); + // Put count of each 8 bits into those 8 bits + x = (x + (x >> 4)) & M4; + // Sum of the 4 byte counts. + // Take care when considering changes to the next line. Portability and + // correctness are delicate here, thanks to C's "integer promotions" (C99 + // §6.3.1.1p2). On machines where the `int` type has width greater than 32 + // bits, `x` will be promoted to an `int`, and following C's "usual + // arithmetic conversions" (C99 §6.3.1.8), the multiplication will be + // performed as a multiplication of two `unsigned int` operands. In this + // case it's critical that we cast back to `uint32_t` in order to keep only + // the least significant 32 bits. On machines where the `int` type has + // width no greater than 32, the multiplication is of two 32-bit unsigned + // integer types, and the (uint32_t) cast is a no-op. In both cases, we + // avoid the risk of undefined behaviour due to overflow of a + // multiplication of signed integer types. + return (uint32_t)(x * 0x01010101U) >> 24; +#endif +} + + +// Return the index of the most significant 1 bit in 'x'. This is the smallest +// integer k such that x < 2**k. Equivalent to floor(log2(x)) + 1 for x != 0. +static inline int +_Py_bit_length(unsigned long x) +{ +#if (defined(__clang__) || defined(__GNUC__)) + if (x != 0) { + // __builtin_clzl() is available since GCC 3.4. + // Undefined behavior for x == 0. + return (int)sizeof(unsigned long) * 8 - __builtin_clzl(x); + } + else { + return 0; + } +#elif defined(_MSC_VER) + // _BitScanReverse() is documented to search 32 bits. + Py_BUILD_ASSERT(sizeof(unsigned long) <= 4); + unsigned long msb; + if (_BitScanReverse(&msb, x)) { + return (int)msb + 1; + } + else { + return 0; + } +#else + const int BIT_LENGTH_TABLE[32] = { + 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 + }; + int msb = 0; + while (x >= 32) { + msb += 6; + x >>= 6; + } + msb += BIT_LENGTH_TABLE[x]; + return msb; +#endif +} + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_BITUTILS_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_blocks_output_buffer.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_blocks_output_buffer.h new file mode 100644 index 0000000000000000000000000000000000000000..573e10359b7bd271c2da4c9674a643b8e738ae41 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_blocks_output_buffer.h @@ -0,0 +1,321 @@ +/* + _BlocksOutputBuffer is used to maintain an output buffer + that has unpredictable size. Suitable for compression/decompression + API (bz2/lzma/zlib) that has stream->next_out and stream->avail_out: + + stream->next_out: point to the next output position. + stream->avail_out: the number of available bytes left in the buffer. + + It maintains a list of bytes object, so there is no overhead of resizing + the buffer. + + Usage: + + 1, Initialize the struct instance like this: + _BlocksOutputBuffer buffer = {.list = NULL}; + Set .list to NULL for _BlocksOutputBuffer_OnError() + + 2, Initialize the buffer use one of these functions: + _BlocksOutputBuffer_InitAndGrow() + _BlocksOutputBuffer_InitWithSize() + + 3, If (avail_out == 0), grow the buffer: + _BlocksOutputBuffer_Grow() + + 4, Get the current outputted data size: + _BlocksOutputBuffer_GetDataSize() + + 5, Finish the buffer, and return a bytes object: + _BlocksOutputBuffer_Finish() + + 6, Clean up the buffer when an error occurred: + _BlocksOutputBuffer_OnError() +*/ + +#ifndef Py_INTERNAL_BLOCKS_OUTPUT_BUFFER_H +#define Py_INTERNAL_BLOCKS_OUTPUT_BUFFER_H +#ifdef __cplusplus +extern "C" { +#endif + +#include "Python.h" + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +typedef struct { + // List of bytes objects + PyObject *list; + // Number of whole allocated size + Py_ssize_t allocated; + // Max length of the buffer, negative number means unlimited length. + Py_ssize_t max_length; +} _BlocksOutputBuffer; + +static const char unable_allocate_msg[] = "Unable to allocate output buffer."; + +/* In 32-bit build, the max block size should <= INT32_MAX. */ +#define OUTPUT_BUFFER_MAX_BLOCK_SIZE (256*1024*1024) + +/* Block size sequence */ +#define KB (1024) +#define MB (1024*1024) +static const Py_ssize_t BUFFER_BLOCK_SIZE[] = + { 32*KB, 64*KB, 256*KB, 1*MB, 4*MB, 8*MB, 16*MB, 16*MB, + 32*MB, 32*MB, 32*MB, 32*MB, 64*MB, 64*MB, 128*MB, 128*MB, + OUTPUT_BUFFER_MAX_BLOCK_SIZE }; +#undef KB +#undef MB + +/* According to the block sizes defined by BUFFER_BLOCK_SIZE, the whole + allocated size growth step is: + 1 32 KB +32 KB + 2 96 KB +64 KB + 3 352 KB +256 KB + 4 1.34 MB +1 MB + 5 5.34 MB +4 MB + 6 13.34 MB +8 MB + 7 29.34 MB +16 MB + 8 45.34 MB +16 MB + 9 77.34 MB +32 MB + 10 109.34 MB +32 MB + 11 141.34 MB +32 MB + 12 173.34 MB +32 MB + 13 237.34 MB +64 MB + 14 301.34 MB +64 MB + 15 429.34 MB +128 MB + 16 557.34 MB +128 MB + 17 813.34 MB +256 MB + 18 1069.34 MB +256 MB + 19 1325.34 MB +256 MB + 20 1581.34 MB +256 MB + 21 1837.34 MB +256 MB + 22 2093.34 MB +256 MB + ... +*/ + +/* Initialize the buffer, and grow the buffer. + + max_length: Max length of the buffer, -1 for unlimited length. + + On success, return allocated size (>=0) + On failure, return -1 +*/ +static inline Py_ssize_t +_BlocksOutputBuffer_InitAndGrow(_BlocksOutputBuffer *buffer, + const Py_ssize_t max_length, + void **next_out) +{ + PyObject *b; + Py_ssize_t block_size; + + // ensure .list was set to NULL + assert(buffer->list == NULL); + + // get block size + if (0 <= max_length && max_length < BUFFER_BLOCK_SIZE[0]) { + block_size = max_length; + } else { + block_size = BUFFER_BLOCK_SIZE[0]; + } + + // the first block + b = PyBytes_FromStringAndSize(NULL, block_size); + if (b == NULL) { + return -1; + } + + // create the list + buffer->list = PyList_New(1); + if (buffer->list == NULL) { + Py_DECREF(b); + return -1; + } + PyList_SET_ITEM(buffer->list, 0, b); + + // set variables + buffer->allocated = block_size; + buffer->max_length = max_length; + + *next_out = PyBytes_AS_STRING(b); + return block_size; +} + +/* Initialize the buffer, with an initial size. + + Check block size limit in the outer wrapper function. For example, some libs + accept UINT32_MAX as the maximum block size, then init_size should <= it. + + On success, return allocated size (>=0) + On failure, return -1 +*/ +static inline Py_ssize_t +_BlocksOutputBuffer_InitWithSize(_BlocksOutputBuffer *buffer, + const Py_ssize_t init_size, + void **next_out) +{ + PyObject *b; + + // ensure .list was set to NULL + assert(buffer->list == NULL); + + // the first block + b = PyBytes_FromStringAndSize(NULL, init_size); + if (b == NULL) { + PyErr_SetString(PyExc_MemoryError, unable_allocate_msg); + return -1; + } + + // create the list + buffer->list = PyList_New(1); + if (buffer->list == NULL) { + Py_DECREF(b); + return -1; + } + PyList_SET_ITEM(buffer->list, 0, b); + + // set variables + buffer->allocated = init_size; + buffer->max_length = -1; + + *next_out = PyBytes_AS_STRING(b); + return init_size; +} + +/* Grow the buffer. The avail_out must be 0, please check it before calling. + + On success, return allocated size (>=0) + On failure, return -1 +*/ +static inline Py_ssize_t +_BlocksOutputBuffer_Grow(_BlocksOutputBuffer *buffer, + void **next_out, + const Py_ssize_t avail_out) +{ + PyObject *b; + const Py_ssize_t list_len = Py_SIZE(buffer->list); + Py_ssize_t block_size; + + // ensure no gaps in the data + if (avail_out != 0) { + PyErr_SetString(PyExc_SystemError, + "avail_out is non-zero in _BlocksOutputBuffer_Grow()."); + return -1; + } + + // get block size + if (list_len < (Py_ssize_t) Py_ARRAY_LENGTH(BUFFER_BLOCK_SIZE)) { + block_size = BUFFER_BLOCK_SIZE[list_len]; + } else { + block_size = BUFFER_BLOCK_SIZE[Py_ARRAY_LENGTH(BUFFER_BLOCK_SIZE) - 1]; + } + + // check max_length + if (buffer->max_length >= 0) { + // if (rest == 0), should not grow the buffer. + Py_ssize_t rest = buffer->max_length - buffer->allocated; + assert(rest > 0); + + // block_size of the last block + if (block_size > rest) { + block_size = rest; + } + } + + // check buffer->allocated overflow + if (block_size > PY_SSIZE_T_MAX - buffer->allocated) { + PyErr_SetString(PyExc_MemoryError, unable_allocate_msg); + return -1; + } + + // create the block + b = PyBytes_FromStringAndSize(NULL, block_size); + if (b == NULL) { + PyErr_SetString(PyExc_MemoryError, unable_allocate_msg); + return -1; + } + if (PyList_Append(buffer->list, b) < 0) { + Py_DECREF(b); + return -1; + } + Py_DECREF(b); + + // set variables + buffer->allocated += block_size; + + *next_out = PyBytes_AS_STRING(b); + return block_size; +} + +/* Return the current outputted data size. */ +static inline Py_ssize_t +_BlocksOutputBuffer_GetDataSize(_BlocksOutputBuffer *buffer, + const Py_ssize_t avail_out) +{ + return buffer->allocated - avail_out; +} + +/* Finish the buffer. + + Return a bytes object on success + Return NULL on failure +*/ +static inline PyObject * +_BlocksOutputBuffer_Finish(_BlocksOutputBuffer *buffer, + const Py_ssize_t avail_out) +{ + PyObject *result, *block; + const Py_ssize_t list_len = Py_SIZE(buffer->list); + + // fast path for single block + if ((list_len == 1 && avail_out == 0) || + (list_len == 2 && Py_SIZE(PyList_GET_ITEM(buffer->list, 1)) == avail_out)) + { + block = PyList_GET_ITEM(buffer->list, 0); + Py_INCREF(block); + + Py_CLEAR(buffer->list); + return block; + } + + // final bytes object + result = PyBytes_FromStringAndSize(NULL, buffer->allocated - avail_out); + if (result == NULL) { + PyErr_SetString(PyExc_MemoryError, unable_allocate_msg); + return NULL; + } + + // memory copy + if (list_len > 0) { + char *posi = PyBytes_AS_STRING(result); + + // blocks except the last one + Py_ssize_t i = 0; + for (; i < list_len-1; i++) { + block = PyList_GET_ITEM(buffer->list, i); + memcpy(posi, PyBytes_AS_STRING(block), Py_SIZE(block)); + posi += Py_SIZE(block); + } + // the last block + block = PyList_GET_ITEM(buffer->list, i); + memcpy(posi, PyBytes_AS_STRING(block), Py_SIZE(block) - avail_out); + } else { + assert(Py_SIZE(result) == 0); + } + + Py_CLEAR(buffer->list); + return result; +} + +/* Clean up the buffer when an error occurred. */ +static inline void +_BlocksOutputBuffer_OnError(_BlocksOutputBuffer *buffer) +{ + Py_CLEAR(buffer->list); +} + +#ifdef __cplusplus +} +#endif +#endif /* Py_INTERNAL_BLOCKS_OUTPUT_BUFFER_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_brc.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_brc.h new file mode 100644 index 0000000000000000000000000000000000000000..cd3c9ac26b5a66d92a46d00df5bfd195e123a803 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_brc.h @@ -0,0 +1,73 @@ +#ifndef Py_INTERNAL_BRC_H +#define Py_INTERNAL_BRC_H + +#include +#include "pycore_llist.h" // struct llist_node +#include "pycore_object_stack.h" // _PyObjectStack + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#ifdef Py_GIL_DISABLED + +// Prime number to avoid correlations with memory addresses. +#define _Py_BRC_NUM_BUCKETS 257 + +// Hash table bucket +struct _brc_bucket { + // Mutex protects both the bucket and thread state queues in this bucket. + PyMutex mutex; + + // Linked list of _PyThreadStateImpl objects hashed to this bucket. + struct llist_node root; +}; + +// Per-interpreter biased reference counting state +struct _brc_state { + // Hash table of thread states by thread-id. Thread states within a bucket + // are chained using a doubly-linked list. + struct _brc_bucket table[_Py_BRC_NUM_BUCKETS]; +}; + +// Per-thread biased reference counting state +struct _brc_thread_state { + // Linked-list of thread states per hash bucket + struct llist_node bucket_node; + + // Thread-id as determined by _PyThread_Id() + uintptr_t tid; + + // Objects with refcounts to be merged (protected by bucket mutex) + _PyObjectStack objects_to_merge; + + // Local stack of objects to be merged (not accessed by other threads) + _PyObjectStack local_objects_to_merge; +}; + +// Initialize/finalize the per-thread biased reference counting state +void _Py_brc_init_thread(PyThreadState *tstate); +void _Py_brc_remove_thread(PyThreadState *tstate); + +// Initialize per-interpreter state +void _Py_brc_init_state(PyInterpreterState *interp); + +void _Py_brc_after_fork(PyInterpreterState *interp); + +// Enqueues an object to be merged by it's owning thread (tid). This +// steals a reference to the object. +void _Py_brc_queue_object(PyObject *ob); + +// Merge the refcounts of queued objects for the current thread. +void _Py_brc_merge_refcounts(PyThreadState *tstate); + +#endif /* Py_GIL_DISABLED */ + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_BRC_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_bytes_methods.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_bytes_methods.h new file mode 100644 index 0000000000000000000000000000000000000000..059dc2599bbd77e861dbf0649372281e306de75e --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_bytes_methods.h @@ -0,0 +1,82 @@ +#ifndef Py_LIMITED_API +#ifndef Py_BYTES_CTYPE_H +#define Py_BYTES_CTYPE_H + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* + * The internal implementation behind PyBytes (bytes) and PyByteArray (bytearray) + * methods of the given names, they operate on ASCII byte strings. + */ +extern PyObject* _Py_bytes_isspace(const char *cptr, Py_ssize_t len); +extern PyObject* _Py_bytes_isalpha(const char *cptr, Py_ssize_t len); +extern PyObject* _Py_bytes_isalnum(const char *cptr, Py_ssize_t len); +extern PyObject* _Py_bytes_isascii(const char *cptr, Py_ssize_t len); +extern PyObject* _Py_bytes_isdigit(const char *cptr, Py_ssize_t len); +extern PyObject* _Py_bytes_islower(const char *cptr, Py_ssize_t len); +extern PyObject* _Py_bytes_isupper(const char *cptr, Py_ssize_t len); +extern PyObject* _Py_bytes_istitle(const char *cptr, Py_ssize_t len); + +/* These store their len sized answer in the given preallocated *result arg. */ +extern void _Py_bytes_lower(char *result, const char *cptr, Py_ssize_t len); +extern void _Py_bytes_upper(char *result, const char *cptr, Py_ssize_t len); +extern void _Py_bytes_title(char *result, const char *s, Py_ssize_t len); +extern void _Py_bytes_capitalize(char *result, const char *s, Py_ssize_t len); +extern void _Py_bytes_swapcase(char *result, const char *s, Py_ssize_t len); + +extern PyObject *_Py_bytes_find(const char *str, Py_ssize_t len, PyObject *sub, + Py_ssize_t start, Py_ssize_t end); +extern PyObject *_Py_bytes_index(const char *str, Py_ssize_t len, PyObject *sub, + Py_ssize_t start, Py_ssize_t end); +extern PyObject *_Py_bytes_rfind(const char *str, Py_ssize_t len, PyObject *sub, + Py_ssize_t start, Py_ssize_t end); +extern PyObject *_Py_bytes_rindex(const char *str, Py_ssize_t len, PyObject *sub, + Py_ssize_t start, Py_ssize_t end); +extern PyObject *_Py_bytes_count(const char *str, Py_ssize_t len, PyObject *sub, + Py_ssize_t start, Py_ssize_t end); +extern int _Py_bytes_contains(const char *str, Py_ssize_t len, PyObject *arg); +extern PyObject *_Py_bytes_startswith(const char *str, Py_ssize_t len, + PyObject *subobj, Py_ssize_t start, + Py_ssize_t end); +extern PyObject *_Py_bytes_endswith(const char *str, Py_ssize_t len, + PyObject *subobj, Py_ssize_t start, + Py_ssize_t end); + +/* The maketrans() static method. */ +extern PyObject* _Py_bytes_maketrans(Py_buffer *frm, Py_buffer *to); + +/* Shared __doc__ strings. */ +extern const char _Py_isspace__doc__[]; +extern const char _Py_isalpha__doc__[]; +extern const char _Py_isalnum__doc__[]; +extern const char _Py_isascii__doc__[]; +extern const char _Py_isdigit__doc__[]; +extern const char _Py_islower__doc__[]; +extern const char _Py_isupper__doc__[]; +extern const char _Py_istitle__doc__[]; +extern const char _Py_lower__doc__[]; +extern const char _Py_upper__doc__[]; +extern const char _Py_title__doc__[]; +extern const char _Py_capitalize__doc__[]; +extern const char _Py_swapcase__doc__[]; +extern const char _Py_count__doc__[]; +extern const char _Py_find__doc__[]; +extern const char _Py_index__doc__[]; +extern const char _Py_rfind__doc__[]; +extern const char _Py_rindex__doc__[]; +extern const char _Py_startswith__doc__[]; +extern const char _Py_endswith__doc__[]; +extern const char _Py_maketrans__doc__[]; +extern const char _Py_expandtabs__doc__[]; +extern const char _Py_ljust__doc__[]; +extern const char _Py_rjust__doc__[]; +extern const char _Py_center__doc__[]; +extern const char _Py_zfill__doc__[]; + +/* this is needed because some docs are shared from the .o, not static */ +#define PyDoc_STRVAR_shared(name,str) const char name[] = PyDoc_STR(str) + +#endif /* !Py_BYTES_CTYPE_H */ +#endif /* !Py_LIMITED_API */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_bytesobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_bytesobject.h new file mode 100644 index 0000000000000000000000000000000000000000..8ea9b3ebb8845413d82b568abbea3a0acc4d56f8 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_bytesobject.h @@ -0,0 +1,149 @@ +#ifndef Py_INTERNAL_BYTESOBJECT_H +#define Py_INTERNAL_BYTESOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +extern PyObject* _PyBytes_FormatEx( + const char *format, + Py_ssize_t format_len, + PyObject *args, + int use_bytearray); + +extern PyObject* _PyBytes_FromHex( + PyObject *string, + int use_bytearray); + +// Helper for PyBytes_DecodeEscape that detects invalid escape chars. +// Export for test_peg_generator. +PyAPI_FUNC(PyObject*) _PyBytes_DecodeEscape2(const char *, Py_ssize_t, + const char *, + int *, const char **); + + +// Substring Search. +// +// Returns the index of the first occurrence of +// a substring ("needle") in a larger text ("haystack"). +// If the needle is not found, return -1. +// If the needle is found, add offset to the index. +// +// Export for 'mmap' shared extension. +PyAPI_FUNC(Py_ssize_t) +_PyBytes_Find(const char *haystack, Py_ssize_t len_haystack, + const char *needle, Py_ssize_t len_needle, + Py_ssize_t offset); + +// Same as above, but search right-to-left. +// Export for 'mmap' shared extension. +PyAPI_FUNC(Py_ssize_t) +_PyBytes_ReverseFind(const char *haystack, Py_ssize_t len_haystack, + const char *needle, Py_ssize_t len_needle, + Py_ssize_t offset); + + +// Helper function to implement the repeat and inplace repeat methods on a +// buffer. +// +// len_dest is assumed to be an integer multiple of len_src. +// If src equals dest, then assume the operation is inplace. +// +// This method repeately doubles the number of bytes copied to reduce +// the number of invocations of memcpy. +// +// Export for 'array' shared extension. +PyAPI_FUNC(void) +_PyBytes_Repeat(char* dest, Py_ssize_t len_dest, + const char* src, Py_ssize_t len_src); + +/* --- _PyBytesWriter ----------------------------------------------------- */ + +/* The _PyBytesWriter structure is big: it contains an embedded "stack buffer". + A _PyBytesWriter variable must be declared at the end of variables in a + function to optimize the memory allocation on the stack. */ +typedef struct { + /* bytes, bytearray or NULL (when the small buffer is used) */ + PyObject *buffer; + + /* Number of allocated size. */ + Py_ssize_t allocated; + + /* Minimum number of allocated bytes, + incremented by _PyBytesWriter_Prepare() */ + Py_ssize_t min_size; + + /* If non-zero, use a bytearray instead of a bytes object for buffer. */ + int use_bytearray; + + /* If non-zero, overallocate the buffer (default: 0). + This flag must be zero if use_bytearray is non-zero. */ + int overallocate; + + /* Stack buffer */ + int use_small_buffer; + char small_buffer[512]; +} _PyBytesWriter; + +/* Initialize a bytes writer + + By default, the overallocation is disabled. Set the overallocate attribute + to control the allocation of the buffer. + + Export _PyBytesWriter API for '_pickle' shared extension. */ +PyAPI_FUNC(void) _PyBytesWriter_Init(_PyBytesWriter *writer); + +/* Get the buffer content and reset the writer. + Return a bytes object, or a bytearray object if use_bytearray is non-zero. + Raise an exception and return NULL on error. */ +PyAPI_FUNC(PyObject *) _PyBytesWriter_Finish(_PyBytesWriter *writer, + void *str); + +/* Deallocate memory of a writer (clear its internal buffer). */ +PyAPI_FUNC(void) _PyBytesWriter_Dealloc(_PyBytesWriter *writer); + +/* Allocate the buffer to write size bytes. + Return the pointer to the beginning of buffer data. + Raise an exception and return NULL on error. */ +PyAPI_FUNC(void*) _PyBytesWriter_Alloc(_PyBytesWriter *writer, + Py_ssize_t size); + +/* Ensure that the buffer is large enough to write *size* bytes. + Add size to the writer minimum size (min_size attribute). + + str is the current pointer inside the buffer. + Return the updated current pointer inside the buffer. + Raise an exception and return NULL on error. */ +PyAPI_FUNC(void*) _PyBytesWriter_Prepare(_PyBytesWriter *writer, + void *str, + Py_ssize_t size); + +/* Resize the buffer to make it larger. + The new buffer may be larger than size bytes because of overallocation. + Return the updated current pointer inside the buffer. + Raise an exception and return NULL on error. + + Note: size must be greater than the number of allocated bytes in the writer. + + This function doesn't use the writer minimum size (min_size attribute). + + See also _PyBytesWriter_Prepare(). + */ +PyAPI_FUNC(void*) _PyBytesWriter_Resize(_PyBytesWriter *writer, + void *str, + Py_ssize_t size); + +/* Write bytes. + Raise an exception and return NULL on error. */ +PyAPI_FUNC(void*) _PyBytesWriter_WriteBytes(_PyBytesWriter *writer, + void *str, + const void *bytes, + Py_ssize_t size); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_BYTESOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_c_array.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_c_array.h new file mode 100644 index 0000000000000000000000000000000000000000..7a10fc866c88f185e3afe71832b8d82ed70b2afa --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_c_array.h @@ -0,0 +1,39 @@ +#ifndef Py_INTERNAL_C_ARRAY_H +#define Py_INTERNAL_C_ARRAY_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + + +/* Utility for a number of growing arrays */ + +typedef struct { + void *array; /* pointer to the array */ + int allocated_entries; /* pointer to the capacity of the array */ + size_t item_size; /* size of each element */ + int initial_num_entries; /* initial allocation size */ +} _Py_c_array_t; + + +int _Py_CArray_Init(_Py_c_array_t* array, int item_size, int initial_num_entries); +void _Py_CArray_Fini(_Py_c_array_t* array); + +/* If idx is out of bounds: + * If arr->array is NULL, allocate arr->initial_num_entries slots. + * Otherwise, double its size. + * + * Return 0 if successful and -1 (with exception set) otherwise. + */ +int _Py_CArray_EnsureCapacity(_Py_c_array_t *c_array, int idx); + + +#ifdef __cplusplus +} +#endif + +#endif /* !Py_INTERNAL_C_ARRAY_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_call.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_call.h new file mode 100644 index 0000000000000000000000000000000000000000..05b58b2ba54a104509ec2e2a8d5eb38534fa2f2f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_call.h @@ -0,0 +1,214 @@ +#ifndef Py_INTERNAL_CALL_H +#define Py_INTERNAL_CALL_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_code.h" // EVAL_CALL_STAT_INC_IF_FUNCTION() +#include "pycore_pystate.h" // _PyThreadState_GET() +#include "pycore_stats.h" + +/* Suggested size (number of positional arguments) for arrays of PyObject* + allocated on a C stack to avoid allocating memory on the heap memory. Such + array is used to pass positional arguments to call functions of the + PyObject_Vectorcall() family. + + The size is chosen to not abuse the C stack and so limit the risk of stack + overflow. The size is also chosen to allow using the small stack for most + function calls of the Python standard library. On 64-bit CPU, it allocates + 40 bytes on the stack. */ +#define _PY_FASTCALL_SMALL_STACK 5 + + +// Export for 'math' shared extension, used via _PyObject_VectorcallTstate() +// static inline function. +PyAPI_FUNC(PyObject*) _Py_CheckFunctionResult( + PyThreadState *tstate, + PyObject *callable, + PyObject *result, + const char *where); + +extern PyObject* _PyObject_Call_Prepend( + PyThreadState *tstate, + PyObject *callable, + PyObject *obj, + PyObject *args, + PyObject *kwargs); + +extern PyObject* _PyObject_VectorcallDictTstate( + PyThreadState *tstate, + PyObject *callable, + PyObject *const *args, + size_t nargsf, + PyObject *kwargs); + +extern PyObject* _PyObject_Call( + PyThreadState *tstate, + PyObject *callable, + PyObject *args, + PyObject *kwargs); + +extern PyObject * _PyObject_CallMethodFormat( + PyThreadState *tstate, + PyObject *callable, + const char *format, + ...); + +// Export for 'array' shared extension +PyAPI_FUNC(PyObject*) _PyObject_CallMethod( + PyObject *obj, + PyObject *name, + const char *format, ...); + +extern PyObject* _PyObject_CallMethodIdObjArgs( + PyObject *obj, + _Py_Identifier *name, + ...); + +static inline PyObject * +_PyObject_VectorcallMethodId( + _Py_Identifier *name, PyObject *const *args, + size_t nargsf, PyObject *kwnames) +{ + PyObject *oname = _PyUnicode_FromId(name); /* borrowed */ + if (!oname) { + return _Py_NULL; + } + return PyObject_VectorcallMethod(oname, args, nargsf, kwnames); +} + +static inline PyObject * +_PyObject_CallMethodIdNoArgs(PyObject *self, _Py_Identifier *name) +{ + size_t nargsf = 1 | PY_VECTORCALL_ARGUMENTS_OFFSET; + return _PyObject_VectorcallMethodId(name, &self, nargsf, _Py_NULL); +} + +static inline PyObject * +_PyObject_CallMethodIdOneArg(PyObject *self, _Py_Identifier *name, PyObject *arg) +{ + PyObject *args[2] = {self, arg}; + size_t nargsf = 2 | PY_VECTORCALL_ARGUMENTS_OFFSET; + assert(arg != NULL); + return _PyObject_VectorcallMethodId(name, args, nargsf, _Py_NULL); +} + + +extern PyObject *_PyObject_VectorcallPrepend( + PyThreadState *tstate, + PyObject *callable, + PyObject *arg, + PyObject *const *args, + size_t nargsf, + PyObject *kwnames); + +/* === Vectorcall protocol (PEP 590) ============================= */ + +// Call callable using tp_call. Arguments are like PyObject_Vectorcall(), +// except that nargs is plainly the number of arguments without flags. +// +// Export for 'math' shared extension, used via _PyObject_VectorcallTstate() +// static inline function. +PyAPI_FUNC(PyObject*) _PyObject_MakeTpCall( + PyThreadState *tstate, + PyObject *callable, + PyObject *const *args, Py_ssize_t nargs, + PyObject *keywords); + +// Static inline variant of public PyVectorcall_Function(). +static inline vectorcallfunc +_PyVectorcall_FunctionInline(PyObject *callable) +{ + assert(callable != NULL); + + PyTypeObject *tp = Py_TYPE(callable); + if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) { + return NULL; + } + assert(PyCallable_Check(callable)); + + Py_ssize_t offset = tp->tp_vectorcall_offset; + assert(offset > 0); + + vectorcallfunc ptr; + memcpy(&ptr, (char *) callable + offset, sizeof(ptr)); + return ptr; +} + + +/* Call the callable object 'callable' with the "vectorcall" calling + convention. + + args is a C array for positional arguments. + + nargsf is the number of positional arguments plus optionally the flag + PY_VECTORCALL_ARGUMENTS_OFFSET which means that the caller is allowed to + modify args[-1]. + + kwnames is a tuple of keyword names. The values of the keyword arguments + are stored in "args" after the positional arguments (note that the number + of keyword arguments does not change nargsf). kwnames can also be NULL if + there are no keyword arguments. + + keywords must only contain strings and all keys must be unique. + + Return the result on success. Raise an exception and return NULL on + error. */ +static inline PyObject * +_PyObject_VectorcallTstate(PyThreadState *tstate, PyObject *callable, + PyObject *const *args, size_t nargsf, + PyObject *kwnames) +{ + vectorcallfunc func; + PyObject *res; + + assert(kwnames == NULL || PyTuple_Check(kwnames)); + assert(args != NULL || PyVectorcall_NARGS(nargsf) == 0); + + func = _PyVectorcall_FunctionInline(callable); + if (func == NULL) { + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + return _PyObject_MakeTpCall(tstate, callable, args, nargs, kwnames); + } + res = func(callable, args, nargsf, kwnames); + return _Py_CheckFunctionResult(tstate, callable, res, NULL); +} + + +static inline PyObject * +_PyObject_CallNoArgsTstate(PyThreadState *tstate, PyObject *func) { + return _PyObject_VectorcallTstate(tstate, func, NULL, 0, NULL); +} + + +// Private static inline function variant of public PyObject_CallNoArgs() +static inline PyObject * +_PyObject_CallNoArgs(PyObject *func) { + EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_API, func); + PyThreadState *tstate = _PyThreadState_GET(); + return _PyObject_VectorcallTstate(tstate, func, NULL, 0, NULL); +} + + +extern PyObject *const * +_PyStack_UnpackDict(PyThreadState *tstate, + PyObject *const *args, Py_ssize_t nargs, + PyObject *kwargs, PyObject **p_kwnames); + +extern void _PyStack_UnpackDict_Free( + PyObject *const *stack, + Py_ssize_t nargs, + PyObject *kwnames); + +extern void _PyStack_UnpackDict_FreeNoDecRef( + PyObject *const *stack, + PyObject *kwnames); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_CALL_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_capsule.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_capsule.h new file mode 100644 index 0000000000000000000000000000000000000000..aa2c67f3a8f002ccef0e9b32fe4ac0cf8271164a --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_capsule.h @@ -0,0 +1,17 @@ +#ifndef Py_INTERNAL_PYCAPSULE_H +#define Py_INTERNAL_PYCAPSULE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +// Export for '_socket' shared extension +PyAPI_FUNC(int) _PyCapsule_SetTraverse(PyObject *op, traverseproc traverse_func, inquiry clear_func); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_PYCAPSULE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_cell.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_cell.h new file mode 100644 index 0000000000000000000000000000000000000000..d0d45a2343654fa93fc764168c7a82cc981baaeb --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_cell.h @@ -0,0 +1,75 @@ +#ifndef Py_INTERNAL_CELL_H +#define Py_INTERNAL_CELL_H + +#include "pycore_critical_section.h" +#include "pycore_object.h" +#include "pycore_stackref.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +// Sets the cell contents to `value` and return previous contents. Steals a +// reference to `value`. +static inline PyObject * +PyCell_SwapTakeRef(PyCellObject *cell, PyObject *value) +{ + PyObject *old_value; + Py_BEGIN_CRITICAL_SECTION(cell); + old_value = cell->ob_ref; + FT_ATOMIC_STORE_PTR_RELEASE(cell->ob_ref, value); + Py_END_CRITICAL_SECTION(); + return old_value; +} + +static inline void +PyCell_SetTakeRef(PyCellObject *cell, PyObject *value) +{ + PyObject *old_value = PyCell_SwapTakeRef(cell, value); + Py_XDECREF(old_value); +} + +// Gets the cell contents. Returns a new reference. +static inline PyObject * +PyCell_GetRef(PyCellObject *cell) +{ + PyObject *res; + Py_BEGIN_CRITICAL_SECTION(cell); +#ifdef Py_GIL_DISABLED + res = _Py_XNewRefWithLock(cell->ob_ref); +#else + res = Py_XNewRef(cell->ob_ref); +#endif + Py_END_CRITICAL_SECTION(); + return res; +} + +static inline _PyStackRef +_PyCell_GetStackRef(PyCellObject *cell) +{ + PyObject *value; +#ifdef Py_GIL_DISABLED + value = _PyObject_CAST(_Py_atomic_load_ptr(&cell->ob_ref)); + if (value == NULL) { + return PyStackRef_NULL; + } + _PyStackRef ref; + if (_Py_TryIncrefCompareStackRef(&cell->ob_ref, value, &ref)) { + return ref; + } +#endif + value = PyCell_GetRef(cell); + if (value == NULL) { + return PyStackRef_NULL; + } + return PyStackRef_FromPyObjectSteal(value); +} + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_CELL_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_ceval.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_ceval.h new file mode 100644 index 0000000000000000000000000000000000000000..e3fa8e10eb447ee9aa518534e2b26619ec485417 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_ceval.h @@ -0,0 +1,394 @@ +#ifndef Py_INTERNAL_CEVAL_H +#define Py_INTERNAL_CEVAL_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "dynamic_annotations.h" // _Py_ANNOTATE_RWLOCK_CREATE + +#include "pycore_code.h" // _PyCode_GetTLBCFast() +#include "pycore_interp.h" // PyInterpreterState.eval_frame +#include "pycore_pystate.h" // _PyThreadState_GET() +#include "pycore_stats.h" // EVAL_CALL_STAT_INC() +#include "pycore_typedefs.h" // _PyInterpreterFrame + + +/* Forward declarations */ +struct _ceval_runtime_state; + +// Export for '_lsprof' shared extension +PyAPI_FUNC(int) _PyEval_SetProfile(PyThreadState *tstate, Py_tracefunc func, PyObject *arg); +extern int _PyEval_SetProfileAllThreads(PyInterpreterState *interp, Py_tracefunc func, PyObject *arg); + +extern int _PyEval_SetTrace(PyThreadState *tstate, Py_tracefunc func, PyObject *arg); +extern int _PyEval_SetTraceAllThreads(PyInterpreterState *interp, Py_tracefunc func, PyObject *arg); + +extern int _PyEval_SetOpcodeTrace(PyFrameObject *f, bool enable); + +// Helper to look up a builtin object +// Export for 'array' shared extension +PyAPI_FUNC(PyObject*) _PyEval_GetBuiltin(PyObject *); + +extern PyObject* _PyEval_GetBuiltinId(_Py_Identifier *); + +extern void _PyEval_SetSwitchInterval(unsigned long microseconds); +extern unsigned long _PyEval_GetSwitchInterval(void); + +// Export for '_queue' shared extension +PyAPI_FUNC(int) _PyEval_MakePendingCalls(PyThreadState *); + +#ifndef Py_DEFAULT_RECURSION_LIMIT +# define Py_DEFAULT_RECURSION_LIMIT 1000 +#endif + +extern void _Py_FinishPendingCalls(PyThreadState *tstate); +extern void _PyEval_InitState(PyInterpreterState *); +extern void _PyEval_SignalReceived(void); + +// bitwise flags: +#define _Py_PENDING_MAINTHREADONLY 1 +#define _Py_PENDING_RAWFREE 2 + +typedef int _Py_add_pending_call_result; +#define _Py_ADD_PENDING_SUCCESS 0 +#define _Py_ADD_PENDING_FULL -1 + +// Export for '_testinternalcapi' shared extension +PyAPI_FUNC(_Py_add_pending_call_result) _PyEval_AddPendingCall( + PyInterpreterState *interp, + _Py_pending_call_func func, + void *arg, + int flags); + +#ifdef HAVE_FORK +extern PyStatus _PyEval_ReInitThreads(PyThreadState *tstate); +#endif + +// Used by sys.call_tracing() +extern PyObject* _PyEval_CallTracing(PyObject *func, PyObject *args); + +// Used by sys.get_asyncgen_hooks() +extern PyObject* _PyEval_GetAsyncGenFirstiter(void); +extern PyObject* _PyEval_GetAsyncGenFinalizer(void); + +// Used by sys.set_asyncgen_hooks() +extern int _PyEval_SetAsyncGenFirstiter(PyObject *); +extern int _PyEval_SetAsyncGenFinalizer(PyObject *); + +// Used by sys.get_coroutine_origin_tracking_depth() +// and sys.set_coroutine_origin_tracking_depth() +extern int _PyEval_GetCoroutineOriginTrackingDepth(void); +extern int _PyEval_SetCoroutineOriginTrackingDepth(int depth); + +extern void _PyEval_Fini(void); + + +extern PyObject* _PyEval_GetBuiltins(PyThreadState *tstate); + +// Trampoline API + +typedef struct { + // Callback to initialize the trampoline state + void* (*init_state)(void); + // Callback to register every trampoline being created + void (*write_state)(void* state, const void *code_addr, + unsigned int code_size, PyCodeObject* code); + // Callback to free the trampoline state + int (*free_state)(void* state); +} _PyPerf_Callbacks; + +extern int _PyPerfTrampoline_SetCallbacks(_PyPerf_Callbacks *); +extern void _PyPerfTrampoline_GetCallbacks(_PyPerf_Callbacks *); +extern int _PyPerfTrampoline_Init(int activate); +extern int _PyPerfTrampoline_Fini(void); +extern int _PyIsPerfTrampolineActive(void); +extern PyStatus _PyPerfTrampoline_AfterFork_Child(void); +#ifdef PY_HAVE_PERF_TRAMPOLINE +extern _PyPerf_Callbacks _Py_perfmap_callbacks; +extern _PyPerf_Callbacks _Py_perfmap_jit_callbacks; +#endif + +static inline PyObject* +_PyEval_EvalFrame(PyThreadState *tstate, _PyInterpreterFrame *frame, int throwflag) +{ + EVAL_CALL_STAT_INC(EVAL_CALL_TOTAL); + if (tstate->interp->eval_frame == NULL) { + return _PyEval_EvalFrameDefault(tstate, frame, throwflag); + } + return tstate->interp->eval_frame(tstate, frame, throwflag); +} + +extern PyObject* +_PyEval_Vector(PyThreadState *tstate, + PyFunctionObject *func, PyObject *locals, + PyObject* const* args, size_t argcount, + PyObject *kwnames); + +extern int _PyEval_ThreadsInitialized(void); +extern void _PyEval_InitGIL(PyThreadState *tstate, int own_gil); +extern void _PyEval_FiniGIL(PyInterpreterState *interp); + +extern void _PyEval_AcquireLock(PyThreadState *tstate); + +extern void _PyEval_ReleaseLock(PyInterpreterState *, PyThreadState *, + int final_release); + +#ifdef Py_GIL_DISABLED +// Returns 0 or 1 if the GIL for the given thread's interpreter is disabled or +// enabled, respectively. +// +// The enabled state of the GIL will not change while one or more threads are +// attached. +static inline int +_PyEval_IsGILEnabled(PyThreadState *tstate) +{ + struct _gil_runtime_state *gil = tstate->interp->ceval.gil; + return _Py_atomic_load_int_relaxed(&gil->enabled) != 0; +} + +// Enable or disable the GIL used by the interpreter that owns tstate, which +// must be the current thread. This may affect other interpreters, if the GIL +// is shared. All three functions will be no-ops (and return 0) if the +// interpreter's `enable_gil' config is not _PyConfig_GIL_DEFAULT. +// +// Every call to _PyEval_EnableGILTransient() must be paired with exactly one +// call to either _PyEval_EnableGILPermanent() or +// _PyEval_DisableGIL(). _PyEval_EnableGILPermanent() and _PyEval_DisableGIL() +// must only be called while the GIL is enabled from a call to +// _PyEval_EnableGILTransient(). +// +// _PyEval_EnableGILTransient() returns 1 if it enabled the GIL, or 0 if the +// GIL was already enabled, whether transiently or permanently. The caller will +// hold the GIL upon return. +// +// _PyEval_EnableGILPermanent() returns 1 if it permanently enabled the GIL +// (which must already be enabled), or 0 if it was already permanently +// enabled. Once _PyEval_EnableGILPermanent() has been called once, all +// subsequent calls to any of the three functions will be no-ops. +// +// _PyEval_DisableGIL() returns 1 if it disabled the GIL, or 0 if the GIL was +// kept enabled because of another request, whether transient or permanent. +// +// All three functions must be called by an attached thread (this implies that +// if the GIL is enabled, the current thread must hold it). +extern int _PyEval_EnableGILTransient(PyThreadState *tstate); +extern int _PyEval_EnableGILPermanent(PyThreadState *tstate); +extern int _PyEval_DisableGIL(PyThreadState *state); + + +static inline _Py_CODEUNIT * +_PyEval_GetExecutableCode(PyThreadState *tstate, PyCodeObject *co) +{ + _Py_CODEUNIT *bc = _PyCode_GetTLBCFast(tstate, co); + if (bc != NULL) { + return bc; + } + return _PyCode_GetTLBC(co); +} + +#endif + +extern void _PyEval_DeactivateOpCache(void); + + +/* --- _Py_EnterRecursiveCall() ----------------------------------------- */ + +static inline int _Py_MakeRecCheck(PyThreadState *tstate) { + uintptr_t here_addr = _Py_get_machine_stack_pointer(); + _PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate; + // Overflow if stack pointer is between soft limit and the base of the hardware stack. + // If it is below the hardware stack base, assume that we have the wrong stack limits, and do nothing. + // We could have the wrong stack limits because of limited platform support, or user-space threads. +#if _Py_STACK_GROWS_DOWN + return here_addr < _tstate->c_stack_soft_limit && here_addr >= _tstate->c_stack_soft_limit - 2 * _PyOS_STACK_MARGIN_BYTES; +#else + return here_addr > _tstate->c_stack_soft_limit && here_addr <= _tstate->c_stack_soft_limit + 2 * _PyOS_STACK_MARGIN_BYTES; +#endif +} + +// Export for '_json' shared extension, used via _Py_EnterRecursiveCall() +// static inline function. +PyAPI_FUNC(int) _Py_CheckRecursiveCall( + PyThreadState *tstate, + const char *where); + +int _Py_CheckRecursiveCallPy( + PyThreadState *tstate); + +static inline int _Py_EnterRecursiveCallTstate(PyThreadState *tstate, + const char *where) { + return (_Py_MakeRecCheck(tstate) && _Py_CheckRecursiveCall(tstate, where)); +} + +static inline int _Py_EnterRecursiveCall(const char *where) { + PyThreadState *tstate = _PyThreadState_GET(); + return _Py_EnterRecursiveCallTstate(tstate, where); +} + +static inline void _Py_LeaveRecursiveCallTstate(PyThreadState *tstate) { + (void)tstate; +} + +PyAPI_FUNC(void) _Py_InitializeRecursionLimits(PyThreadState *tstate); + +static inline int _Py_ReachedRecursionLimit(PyThreadState *tstate) { + uintptr_t here_addr = _Py_get_machine_stack_pointer(); + _PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate; + assert(_tstate->c_stack_hard_limit != 0); +#if _Py_STACK_GROWS_DOWN + return here_addr <= _tstate->c_stack_soft_limit; +#else + return here_addr >= _tstate->c_stack_soft_limit; +#endif +} + +static inline void _Py_LeaveRecursiveCall(void) { +} + +extern _PyInterpreterFrame* _PyEval_GetFrame(void); + +extern PyObject * _PyEval_GetGlobalsFromRunningMain(PyThreadState *); +extern int _PyEval_EnsureBuiltins( + PyThreadState *, + PyObject *, + PyObject **p_builtins); +extern int _PyEval_EnsureBuiltinsWithModule( + PyThreadState *, + PyObject *, + PyObject **p_builtins); + +PyAPI_FUNC(PyObject *)_Py_MakeCoro(PyFunctionObject *func); + +/* Handle signals, pending calls, GIL drop request + and asynchronous exception */ +PyAPI_FUNC(int) _Py_HandlePending(PyThreadState *tstate); + +extern PyObject * _PyEval_GetFrameLocals(void); + +typedef PyObject *(*conversion_func)(PyObject *); + +PyAPI_DATA(const binaryfunc) _PyEval_BinaryOps[]; +PyAPI_DATA(const conversion_func) _PyEval_ConversionFuncs[]; + +typedef struct _special_method { + PyObject *name; + const char *error; + const char *error_suggestion; // improved optional suggestion +} _Py_SpecialMethod; + +PyAPI_DATA(const _Py_SpecialMethod) _Py_SpecialMethods[]; +PyAPI_DATA(const size_t) _Py_FunctionAttributeOffsets[]; + +PyAPI_FUNC(int) _PyEval_CheckExceptStarTypeValid(PyThreadState *tstate, PyObject* right); +PyAPI_FUNC(int) _PyEval_CheckExceptTypeValid(PyThreadState *tstate, PyObject* right); +PyAPI_FUNC(int) _PyEval_ExceptionGroupMatch(_PyInterpreterFrame *, PyObject* exc_value, PyObject *match_type, PyObject **match, PyObject **rest); +PyAPI_FUNC(void) _PyEval_FormatAwaitableError(PyThreadState *tstate, PyTypeObject *type, int oparg); +PyAPI_FUNC(void) _PyEval_FormatExcCheckArg(PyThreadState *tstate, PyObject *exc, const char *format_str, PyObject *obj); +PyAPI_FUNC(void) _PyEval_FormatExcUnbound(PyThreadState *tstate, PyCodeObject *co, int oparg); +PyAPI_FUNC(void) _PyEval_FormatKwargsError(PyThreadState *tstate, PyObject *func, PyObject *kwargs); +PyAPI_FUNC(PyObject *) _PyEval_ImportFrom(PyThreadState *, PyObject *, PyObject *); +PyAPI_FUNC(PyObject *) _PyEval_ImportName(PyThreadState *, _PyInterpreterFrame *, PyObject *, PyObject *, PyObject *); +PyAPI_FUNC(PyObject *)_PyEval_MatchClass(PyThreadState *tstate, PyObject *subject, PyObject *type, Py_ssize_t nargs, PyObject *kwargs); +PyAPI_FUNC(PyObject *)_PyEval_MatchKeys(PyThreadState *tstate, PyObject *map, PyObject *keys); +PyAPI_FUNC(void) _PyEval_MonitorRaise(PyThreadState *tstate, _PyInterpreterFrame *frame, _Py_CODEUNIT *instr); +PyAPI_FUNC(bool) _PyEval_NoToolsForUnwind(PyThreadState *tstate); +PyAPI_FUNC(int) _PyEval_UnpackIterableStackRef(PyThreadState *tstate, PyObject *v, int argcnt, int argcntafter, _PyStackRef *sp); +PyAPI_FUNC(void) _PyEval_FrameClearAndPop(PyThreadState *tstate, _PyInterpreterFrame *frame); +PyAPI_FUNC(PyObject **) _PyObjectArray_FromStackRefArray(_PyStackRef *input, Py_ssize_t nargs, PyObject **scratch); + +PyAPI_FUNC(void) _PyObjectArray_Free(PyObject **array, PyObject **scratch); + +PyAPI_FUNC(PyObject *) _PyEval_GetANext(PyObject *aiter); +PyAPI_FUNC(void) _PyEval_LoadGlobalStackRef(PyObject *globals, PyObject *builtins, PyObject *name, _PyStackRef *writeto); +PyAPI_FUNC(PyObject *) _PyEval_GetAwaitable(PyObject *iterable, int oparg); +PyAPI_FUNC(PyObject *) _PyEval_LoadName(PyThreadState *tstate, _PyInterpreterFrame *frame, PyObject *name); +PyAPI_FUNC(int) +_Py_Check_ArgsIterable(PyThreadState *tstate, PyObject *func, PyObject *args); + +/* + * Indicate whether a special method of given 'oparg' can use the (improved) + * alternative error message instead. Only methods loaded by LOAD_SPECIAL + * support alternative error messages. + * + * Symbol is exported for the JIT (see discussion on GH-132218). + */ +PyAPI_FUNC(int) +_PyEval_SpecialMethodCanSuggest(PyObject *self, int oparg); + +/* Bits that can be set in PyThreadState.eval_breaker */ +#define _PY_GIL_DROP_REQUEST_BIT (1U << 0) +#define _PY_SIGNALS_PENDING_BIT (1U << 1) +#define _PY_CALLS_TO_DO_BIT (1U << 2) +#define _PY_ASYNC_EXCEPTION_BIT (1U << 3) +#define _PY_GC_SCHEDULED_BIT (1U << 4) +#define _PY_EVAL_PLEASE_STOP_BIT (1U << 5) +#define _PY_EVAL_EXPLICIT_MERGE_BIT (1U << 6) +#define _PY_EVAL_JIT_INVALIDATE_COLD_BIT (1U << 7) + +/* Reserve a few bits for future use */ +#define _PY_EVAL_EVENTS_BITS 8 +#define _PY_EVAL_EVENTS_MASK ((1 << _PY_EVAL_EVENTS_BITS)-1) + +static inline void +_Py_set_eval_breaker_bit(PyThreadState *tstate, uintptr_t bit) +{ + _Py_atomic_or_uintptr(&tstate->eval_breaker, bit); +} + +static inline void +_Py_unset_eval_breaker_bit(PyThreadState *tstate, uintptr_t bit) +{ + _Py_atomic_and_uintptr(&tstate->eval_breaker, ~bit); +} + +static inline int +_Py_eval_breaker_bit_is_set(PyThreadState *tstate, uintptr_t bit) +{ + uintptr_t b = _Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker); + return (b & bit) != 0; +} + +// Free-threaded builds use these functions to set or unset a bit on all +// threads in the given interpreter. +void _Py_set_eval_breaker_bit_all(PyInterpreterState *interp, uintptr_t bit); +void _Py_unset_eval_breaker_bit_all(PyInterpreterState *interp, uintptr_t bit); + +PyAPI_FUNC(_PyStackRef) _PyFloat_FromDouble_ConsumeInputs(_PyStackRef left, _PyStackRef right, double value); + +#ifndef Py_SUPPORTS_REMOTE_DEBUG + #if defined(__APPLE__) + #include + # if !defined(TARGET_OS_OSX) +// Older macOS SDKs do not define TARGET_OS_OSX + # define TARGET_OS_OSX 1 + # endif + #endif + #if ((defined(__APPLE__) && TARGET_OS_OSX) || defined(MS_WINDOWS) || (defined(__linux__) && HAVE_PROCESS_VM_READV)) + # define Py_SUPPORTS_REMOTE_DEBUG 1 + #endif +#endif + +#if defined(Py_REMOTE_DEBUG) && defined(Py_SUPPORTS_REMOTE_DEBUG) +extern int _PyRunRemoteDebugger(PyThreadState *tstate); +#endif + +/* Special methods used by LOAD_SPECIAL */ +#define SPECIAL___ENTER__ 0 +#define SPECIAL___EXIT__ 1 +#define SPECIAL___AENTER__ 2 +#define SPECIAL___AEXIT__ 3 +#define SPECIAL_MAX 3 + +PyAPI_FUNC(_PyStackRef) +_Py_LoadAttr_StackRefSteal( + PyThreadState *tstate, _PyStackRef owner, + PyObject *name, _PyStackRef *self_or_null); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_CEVAL_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_ceval_state.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_ceval_state.h new file mode 100644 index 0000000000000000000000000000000000000000..64128a78136e56378107d45b3f92068922ddd8cf --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_ceval_state.h @@ -0,0 +1,48 @@ +#ifndef Py_INTERNAL_CEVAL_STATE_H +#define Py_INTERNAL_CEVAL_STATE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_gil.h" // struct _gil_runtime_state + + +#define MAXPENDINGCALLS PENDINGCALLSARRAYSIZE +/* For interpreter-level pending calls, we want to avoid spending too + much time on pending calls in any one thread, so we apply a limit. */ +#if MAXPENDINGCALLS > 100 +# define MAXPENDINGCALLSLOOP 100 +#else +# define MAXPENDINGCALLSLOOP MAXPENDINGCALLS +#endif + +/* We keep the number small to preserve as much compatibility + as possible with earlier versions. */ +#define MAXPENDINGCALLS_MAIN 32 +/* For the main thread, we want to make sure all pending calls are + run at once, for the sake of prompt signal handling. This is + unlikely to cause any problems since there should be very few + pending calls for the main thread. */ +#define MAXPENDINGCALLSLOOP_MAIN 0 + + +#ifdef PY_HAVE_PERF_TRAMPOLINE +# define _PyEval_RUNTIME_PERF_INIT \ + { \ + .status = PERF_STATUS_NO_INIT, \ + .extra_code_index = -1, \ + .persist_after_fork = 0, \ + } +#else +# define _PyEval_RUNTIME_PERF_INIT {0} +#endif + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_CEVAL_STATE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_code.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_code.h new file mode 100644 index 0000000000000000000000000000000000000000..dc0ea9c669b731262cd1806cb84c88b62c13ad9b --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_code.h @@ -0,0 +1,671 @@ +#ifndef Py_INTERNAL_CODE_H +#define Py_INTERNAL_CODE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_backoff.h" // _Py_BackoffCounter +#include "pycore_structs.h" // _Py_CODEUNIT +#include "pycore_tstate.h" // _PyThreadStateImpl + + +#define _PyCode_CODE(CO) _Py_RVALUE((_Py_CODEUNIT *)(CO)->co_code_adaptive) +#define _PyCode_NBYTES(CO) (Py_SIZE(CO) * (Py_ssize_t)sizeof(_Py_CODEUNIT)) + + +/* These macros only remain defined for compatibility. */ +#define _Py_OPCODE(word) ((word).op.code) +#define _Py_OPARG(word) ((word).op.arg) + +static inline _Py_CODEUNIT +_py_make_codeunit(uint8_t opcode, uint8_t oparg) +{ + // No designated initialisers because of C++ compat + _Py_CODEUNIT word; + word.op.code = opcode; + word.op.arg = oparg; + return word; +} + +static inline void +_py_set_opcode(_Py_CODEUNIT *word, uint8_t opcode) +{ + word->op.code = opcode; +} + +#define _Py_MAKE_CODEUNIT(opcode, oparg) _py_make_codeunit((opcode), (oparg)) +#define _Py_SET_OPCODE(word, opcode) _py_set_opcode(&(word), (opcode)) + + +// We hide some of the newer PyCodeObject fields behind macros. +// This helps with backporting certain changes to 3.12. +#define _PyCode_HAS_EXECUTORS(CODE) \ + (CODE->co_executors != NULL) +#define _PyCode_HAS_INSTRUMENTATION(CODE) \ + (CODE->_co_instrumentation_version > 0) + + +extern PyStatus _PyCode_Init(PyInterpreterState *interp); +extern void _PyCode_Fini(PyInterpreterState *interp); + + +/* PEP 659 + * Specialization and quickening structs and helper functions + */ + + +// Inline caches. If you change the number of cache entries for an instruction, +// you must *also* update the number of cache entries in Lib/opcode.py and bump +// the magic number in Lib/importlib/_bootstrap_external.py! + +#define CACHE_ENTRIES(cache) (sizeof(cache)/sizeof(_Py_CODEUNIT)) + +typedef struct { + _Py_BackoffCounter counter; + uint16_t module_keys_version; + uint16_t builtin_keys_version; + uint16_t index; +} _PyLoadGlobalCache; + +#define INLINE_CACHE_ENTRIES_LOAD_GLOBAL CACHE_ENTRIES(_PyLoadGlobalCache) + +typedef struct { + _Py_BackoffCounter counter; + uint16_t external_cache[4]; +} _PyBinaryOpCache; + +#define INLINE_CACHE_ENTRIES_BINARY_OP CACHE_ENTRIES(_PyBinaryOpCache) + +typedef struct { + _Py_BackoffCounter counter; +} _PyUnpackSequenceCache; + +#define INLINE_CACHE_ENTRIES_UNPACK_SEQUENCE \ + CACHE_ENTRIES(_PyUnpackSequenceCache) + +typedef struct { + _Py_BackoffCounter counter; +} _PyCompareOpCache; + +#define INLINE_CACHE_ENTRIES_COMPARE_OP CACHE_ENTRIES(_PyCompareOpCache) + +typedef struct { + _Py_BackoffCounter counter; +} _PySuperAttrCache; + +#define INLINE_CACHE_ENTRIES_LOAD_SUPER_ATTR CACHE_ENTRIES(_PySuperAttrCache) + +typedef struct { + _Py_BackoffCounter counter; + uint16_t version[2]; + uint16_t index; +} _PyAttrCache; + +typedef struct { + _Py_BackoffCounter counter; + uint16_t type_version[2]; + union { + uint16_t keys_version[2]; + uint16_t dict_offset; + }; + uint16_t descr[4]; +} _PyLoadMethodCache; + + +// MUST be the max(_PyAttrCache, _PyLoadMethodCache) +#define INLINE_CACHE_ENTRIES_LOAD_ATTR CACHE_ENTRIES(_PyLoadMethodCache) + +#define INLINE_CACHE_ENTRIES_STORE_ATTR CACHE_ENTRIES(_PyAttrCache) + +typedef struct { + _Py_BackoffCounter counter; + uint16_t func_version[2]; +} _PyCallCache; + +#define INLINE_CACHE_ENTRIES_CALL CACHE_ENTRIES(_PyCallCache) +#define INLINE_CACHE_ENTRIES_CALL_KW CACHE_ENTRIES(_PyCallCache) + +typedef struct { + _Py_BackoffCounter counter; +} _PyStoreSubscrCache; + +#define INLINE_CACHE_ENTRIES_STORE_SUBSCR CACHE_ENTRIES(_PyStoreSubscrCache) + +typedef struct { + _Py_BackoffCounter counter; +} _PyForIterCache; + +#define INLINE_CACHE_ENTRIES_FOR_ITER CACHE_ENTRIES(_PyForIterCache) + +typedef struct { + _Py_BackoffCounter counter; +} _PySendCache; + +#define INLINE_CACHE_ENTRIES_SEND CACHE_ENTRIES(_PySendCache) + +typedef struct { + _Py_BackoffCounter counter; + uint16_t version[2]; +} _PyToBoolCache; + +#define INLINE_CACHE_ENTRIES_TO_BOOL CACHE_ENTRIES(_PyToBoolCache) + +typedef struct { + _Py_BackoffCounter counter; +} _PyContainsOpCache; + +#define INLINE_CACHE_ENTRIES_CONTAINS_OP CACHE_ENTRIES(_PyContainsOpCache) + +/* "Locals plus" for a code object is the set of locals + cell vars + + * free vars. This relates to variable names as well as offsets into + * the "fast locals" storage array of execution frames. The compiler + * builds the list of names, their offsets, and the corresponding + * kind of local. + * + * Those kinds represent the source of the initial value and the + * variable's scope (as related to closures). A "local" is an + * argument or other variable defined in the current scope. A "free" + * variable is one that is defined in an outer scope and comes from + * the function's closure. A "cell" variable is a local that escapes + * into an inner function as part of a closure, and thus must be + * wrapped in a cell. Any "local" can also be a "cell", but the + * "free" kind is mutually exclusive with both. + */ + +// Note that these all fit within a byte, as do combinations. +#define CO_FAST_ARG_POS (0x02) // pos-only, pos-or-kw, varargs +#define CO_FAST_ARG_KW (0x04) // kw-only, pos-or-kw, varkwargs +#define CO_FAST_ARG_VAR (0x08) // varargs, varkwargs +#define CO_FAST_ARG (CO_FAST_ARG_POS | CO_FAST_ARG_KW | CO_FAST_ARG_VAR) +#define CO_FAST_HIDDEN (0x10) +#define CO_FAST_LOCAL (0x20) +#define CO_FAST_CELL (0x40) +#define CO_FAST_FREE (0x80) + +typedef unsigned char _PyLocals_Kind; + +static inline _PyLocals_Kind +_PyLocals_GetKind(PyObject *kinds, int i) +{ + assert(PyBytes_Check(kinds)); + assert(0 <= i && i < PyBytes_GET_SIZE(kinds)); + char *ptr = PyBytes_AS_STRING(kinds); + return (_PyLocals_Kind)(ptr[i]); +} + +static inline void +_PyLocals_SetKind(PyObject *kinds, int i, _PyLocals_Kind kind) +{ + assert(PyBytes_Check(kinds)); + assert(0 <= i && i < PyBytes_GET_SIZE(kinds)); + char *ptr = PyBytes_AS_STRING(kinds); + ptr[i] = (char) kind; +} + + +struct _PyCodeConstructor { + /* metadata */ + PyObject *filename; + PyObject *name; + PyObject *qualname; + int flags; + + /* the code */ + PyObject *code; + int firstlineno; + PyObject *linetable; + + /* used by the code */ + PyObject *consts; + PyObject *names; + + /* mapping frame offsets to information */ + PyObject *localsplusnames; // Tuple of strings + PyObject *localspluskinds; // Bytes object, one byte per variable + + /* args (within varnames) */ + int argcount; + int posonlyargcount; + // XXX Replace argcount with posorkwargcount (argcount - posonlyargcount). + int kwonlyargcount; + + /* needed to create the frame */ + int stacksize; + + /* used by the eval loop */ + PyObject *exceptiontable; +}; + +// Using an "arguments struct" like this is helpful for maintainability +// in a case such as this with many parameters. It does bear a risk: +// if the struct changes and callers are not updated properly then the +// compiler will not catch problems (like a missing argument). This can +// cause hard-to-debug problems. The risk is mitigated by the use of +// check_code() in codeobject.c. However, we may decide to switch +// back to a regular function signature. Regardless, this approach +// wouldn't be appropriate if this weren't a strictly internal API. +// (See the comments in https://github.com/python/cpython/pull/26258.) +extern int _PyCode_Validate(struct _PyCodeConstructor *); +extern PyCodeObject* _PyCode_New(struct _PyCodeConstructor *); + + +/* Private API */ + +/* Getters for internal PyCodeObject data. */ +extern PyObject* _PyCode_GetVarnames(PyCodeObject *); +extern PyObject* _PyCode_GetCellvars(PyCodeObject *); +extern PyObject* _PyCode_GetFreevars(PyCodeObject *); +extern PyObject* _PyCode_GetCode(PyCodeObject *); + +/** API for initializing the line number tables. */ +extern int _PyCode_InitAddressRange(PyCodeObject* co, PyCodeAddressRange *bounds); + +/** Out of process API for initializing the location table. */ +extern void _PyLineTable_InitAddressRange( + const char *linetable, + Py_ssize_t length, + int firstlineno, + PyCodeAddressRange *range); + +/** API for traversing the line number table. */ +extern int _PyLineTable_NextAddressRange(PyCodeAddressRange *range); +extern int _PyLineTable_PreviousAddressRange(PyCodeAddressRange *range); + +// Similar to PyCode_Addr2Line(), but return -1 if the code object is invalid +// and can be called without an attached tstate. Used by dump_frame() in +// Python/traceback.c. The function uses heuristics to detect freed memory, +// it's not 100% reliable. +extern int _PyCode_SafeAddr2Line(PyCodeObject *co, int addr); + + +/** API for executors */ +extern void _PyCode_Clear_Executors(PyCodeObject *code); + + +#ifdef Py_GIL_DISABLED +// gh-115999 tracks progress on addressing this. +#define ENABLE_SPECIALIZATION 0 +// Use this to enable specialization families once they are thread-safe. All +// uses will be replaced with ENABLE_SPECIALIZATION once all families are +// thread-safe. +#define ENABLE_SPECIALIZATION_FT 1 +#else +#define ENABLE_SPECIALIZATION 1 +#define ENABLE_SPECIALIZATION_FT ENABLE_SPECIALIZATION +#endif + +/* Specialization functions */ + +extern void _Py_Specialize_LoadSuperAttr(_PyStackRef global_super, _PyStackRef cls, + _Py_CODEUNIT *instr, int load_method); +extern void _Py_Specialize_LoadAttr(_PyStackRef owner, _Py_CODEUNIT *instr, + PyObject *name); +extern void _Py_Specialize_StoreAttr(_PyStackRef owner, _Py_CODEUNIT *instr, + PyObject *name); +extern void _Py_Specialize_LoadGlobal(PyObject *globals, PyObject *builtins, + _Py_CODEUNIT *instr, PyObject *name); +extern void _Py_Specialize_StoreSubscr(_PyStackRef container, _PyStackRef sub, + _Py_CODEUNIT *instr); +extern void _Py_Specialize_Call(_PyStackRef callable, _Py_CODEUNIT *instr, + int nargs); +extern void _Py_Specialize_CallKw(_PyStackRef callable, _Py_CODEUNIT *instr, + int nargs); +extern void _Py_Specialize_BinaryOp(_PyStackRef lhs, _PyStackRef rhs, _Py_CODEUNIT *instr, + int oparg, _PyStackRef *locals); +extern void _Py_Specialize_CompareOp(_PyStackRef lhs, _PyStackRef rhs, + _Py_CODEUNIT *instr, int oparg); +extern void _Py_Specialize_UnpackSequence(_PyStackRef seq, _Py_CODEUNIT *instr, + int oparg); +extern void _Py_Specialize_ForIter(_PyStackRef iter, _Py_CODEUNIT *instr, int oparg); +extern void _Py_Specialize_Send(_PyStackRef receiver, _Py_CODEUNIT *instr); +extern void _Py_Specialize_ToBool(_PyStackRef value, _Py_CODEUNIT *instr); +extern void _Py_Specialize_ContainsOp(_PyStackRef value, _Py_CODEUNIT *instr); +extern void _Py_GatherStats_GetIter(_PyStackRef iterable); + +// Utility functions for reading/writing 32/64-bit values in the inline caches. +// Great care should be taken to ensure that these functions remain correct and +// performant! They should compile to just "move" instructions on all supported +// compilers and platforms. + +// We use memcpy to let the C compiler handle unaligned accesses and endianness +// issues for us. It also seems to produce better code than manual copying for +// most compilers (see https://blog.regehr.org/archives/959 for more info). + +static inline void +write_u32(uint16_t *p, uint32_t val) +{ + memcpy(p, &val, sizeof(val)); +} + +static inline void +write_u64(uint16_t *p, uint64_t val) +{ + memcpy(p, &val, sizeof(val)); +} + +static inline void +write_ptr(uint16_t *p, void *val) +{ + memcpy(p, &val, sizeof(val)); +} + +static inline uint16_t +read_u16(uint16_t *p) +{ + return *p; +} + +static inline uint32_t +read_u32(uint16_t *p) +{ + uint32_t val; + memcpy(&val, p, sizeof(val)); + return val; +} + +static inline uint64_t +read_u64(uint16_t *p) +{ + uint64_t val; + memcpy(&val, p, sizeof(val)); + return val; +} + +static inline PyObject * +read_obj(uint16_t *p) +{ + PyObject *val; + memcpy(&val, p, sizeof(val)); + return val; +} + +/* See InternalDocs/exception_handling.md for details. + */ +static inline unsigned char * +parse_varint(unsigned char *p, int *result) { + int val = p[0] & 63; + while (p[0] & 64) { + p++; + val = (val << 6) | (p[0] & 63); + } + *result = val; + return p+1; +} + +static inline int +write_varint(uint8_t *ptr, unsigned int val) +{ + int written = 1; + while (val >= 64) { + *ptr++ = 64 | (val & 63); + val >>= 6; + written++; + } + *ptr = (uint8_t)val; + return written; +} + +static inline int +write_signed_varint(uint8_t *ptr, int val) +{ + unsigned int uval; + if (val < 0) { + // (unsigned int)(-val) has an undefined behavior for INT_MIN + uval = ((0 - (unsigned int)val) << 1) | 1; + } + else { + uval = (unsigned int)val << 1; + } + return write_varint(ptr, uval); +} + +static inline int +write_location_entry_start(uint8_t *ptr, int code, int length) +{ + assert((code & 15) == code); + *ptr = 128 | (uint8_t)(code << 3) | (uint8_t)(length - 1); + return 1; +} + + +/** Counters + * The first 16-bit value in each inline cache is a counter. + * + * When counting executions until the next specialization attempt, + * exponential backoff is used to reduce the number of specialization failures. + * See pycore_backoff.h for more details. + * On a specialization failure, the backoff counter is restarted. + */ + +// A value of 1 means that we attempt to specialize the *second* time each +// instruction is executed. Executing twice is a much better indicator of +// "hotness" than executing once, but additional warmup delays only prevent +// specialization. Most types stabilize by the second execution, too: +#define ADAPTIVE_WARMUP_VALUE 1 +#define ADAPTIVE_WARMUP_BACKOFF 1 + +// A value of 52 means that we attempt to re-specialize after 53 misses (a prime +// number, useful for avoiding artifacts if every nth value is a different type +// or something). Setting the backoff to 0 means that the counter is reset to +// the same state as a warming-up instruction (value == 1, backoff == 1) after +// deoptimization. This isn't strictly necessary, but it is bit easier to reason +// about when thinking about the opcode transitions as a state machine: +#define ADAPTIVE_COOLDOWN_VALUE 52 +#define ADAPTIVE_COOLDOWN_BACKOFF 0 + +// Can't assert this in pycore_backoff.h because of header order dependencies +#if SIDE_EXIT_INITIAL_VALUE <= ADAPTIVE_COOLDOWN_VALUE +# error "Cold exit value should be larger than adaptive cooldown value" +#endif + +static inline _Py_BackoffCounter +adaptive_counter_bits(uint16_t value, uint16_t backoff) { + return make_backoff_counter(value, backoff); +} + +static inline _Py_BackoffCounter +adaptive_counter_warmup(void) { + return adaptive_counter_bits(ADAPTIVE_WARMUP_VALUE, + ADAPTIVE_WARMUP_BACKOFF); +} + +static inline _Py_BackoffCounter +adaptive_counter_cooldown(void) { + return adaptive_counter_bits(ADAPTIVE_COOLDOWN_VALUE, + ADAPTIVE_COOLDOWN_BACKOFF); +} + +static inline _Py_BackoffCounter +adaptive_counter_backoff(_Py_BackoffCounter counter) { + return restart_backoff_counter(counter); +} + +/* Specialization Extensions */ + +/* callbacks for an external specialization */ +typedef int (*binaryopguardfunc)(PyObject *lhs, PyObject *rhs); +typedef PyObject *(*binaryopactionfunc)(PyObject *lhs, PyObject *rhs); + +typedef struct { + int oparg; + binaryopguardfunc guard; + binaryopactionfunc action; +} _PyBinaryOpSpecializationDescr; + +/* Comparison bit masks. */ + +/* Note this evaluates its arguments twice each */ +#define COMPARISON_BIT(x, y) (1 << (2 * ((x) >= (y)) + ((x) <= (y)))) + +/* + * The following bits are chosen so that the value of + * COMPARSION_BIT(left, right) + * masked by the values below will be non-zero if the + * comparison is true, and zero if it is false */ + +/* This is for values that are unordered, ie. NaN, not types that are unordered, e.g. sets */ +#define COMPARISON_UNORDERED 1 + +#define COMPARISON_LESS_THAN 2 +#define COMPARISON_GREATER_THAN 4 +#define COMPARISON_EQUALS 8 + +#define COMPARISON_NOT_EQUALS (COMPARISON_UNORDERED | COMPARISON_LESS_THAN | COMPARISON_GREATER_THAN) + +extern int _Py_Instrument(PyCodeObject *co, PyInterpreterState *interp); + +extern _Py_CODEUNIT _Py_GetBaseCodeUnit(PyCodeObject *code, int offset); + +extern int _PyInstruction_GetLength(PyCodeObject *code, int offset); + +extern PyObject *_PyInstrumentation_BranchesIterator(PyCodeObject *code); + +struct _PyCode8 _PyCode_DEF(8); + +PyAPI_DATA(const struct _PyCode8) _Py_InitCleanup; + +#ifdef Py_GIL_DISABLED + +static inline _PyCodeArray * +_PyCode_GetTLBCArray(PyCodeObject *co) +{ + return _Py_STATIC_CAST(_PyCodeArray *, + _Py_atomic_load_ptr_acquire(&co->co_tlbc)); +} + +// Return a pointer to the thread-local bytecode for the current thread, if it +// exists. +static inline _Py_CODEUNIT * +_PyCode_GetTLBCFast(PyThreadState *tstate, PyCodeObject *co) +{ + _PyCodeArray *code = _PyCode_GetTLBCArray(co); + int32_t idx = ((_PyThreadStateImpl*) tstate)->tlbc_index; + if (idx < code->size && code->entries[idx] != NULL) { + return (_Py_CODEUNIT *) code->entries[idx]; + } + return NULL; +} + +// Return a pointer to the thread-local bytecode for the current thread, +// creating it if necessary. +extern _Py_CODEUNIT *_PyCode_GetTLBC(PyCodeObject *co); + +// Reserve an index for the current thread into thread-local bytecode +// arrays +// +// Returns the reserved index or -1 on error. +extern int32_t _Py_ReserveTLBCIndex(PyInterpreterState *interp); + +// Release the current thread's index into thread-local bytecode arrays +extern void _Py_ClearTLBCIndex(_PyThreadStateImpl *tstate); + +// Free all TLBC copies not associated with live threads. +// +// Returns 0 on success or -1 on error. +extern int _Py_ClearUnusedTLBC(PyInterpreterState *interp); +#endif + + +typedef struct { + int total; + struct co_locals_counts { + int total; + struct { + int total; + int numposonly; + int numposorkw; + int numkwonly; + int varargs; + int varkwargs; + } args; + int numpure; + struct { + int total; + // numargs does not contribute to locals.total. + int numargs; + int numothers; + } cells; + struct { + int total; + int numpure; + int numcells; + } hidden; + } locals; + int numfree; // nonlocal + struct co_unbound_counts { + int total; + struct { + int total; + int numglobal; + int numbuiltin; + int numunknown; + } globals; + int numattrs; + int numunknown; + } unbound; +} _PyCode_var_counts_t; + +PyAPI_FUNC(void) _PyCode_GetVarCounts( + PyCodeObject *, + _PyCode_var_counts_t *); +PyAPI_FUNC(int) _PyCode_SetUnboundVarCounts( + PyThreadState *, + PyCodeObject *, + _PyCode_var_counts_t *, + PyObject *globalnames, + PyObject *attrnames, + PyObject *globalsns, + PyObject *builtinsns); + + +/* "Stateless" code is a function or code object which does not rely on + * external state or internal state. It may rely on arguments and + * builtins, but not globals or a closure. Thus it does not rely + * on __globals__ or __closure__, and a stateless function + * is equivalent to its code object. + * + * Stateless code also does not keep any persistent state + * of its own, so it can't have any executors, monitoring, + * instrumentation, or "extras" (i.e. co_extra). + * + * Stateless code may create nested functions, including closures. + * However, nested functions must themselves be stateless, except they + * *can* close on the enclosing locals. + * + * Stateless code may return any value, including nested functions and closures. + * + * Stateless code that takes no arguments and doesn't return anything + * may be treated like a script. + * + * We consider stateless code to be "portable" if it does not return + * any object that holds a reference to any of the code's locals. Thus + * generators and coroutines are not portable. Likewise a function + * that returns a closure is not portable. The concept of + * portability is useful in cases where the code is run + * in a different execution context than where + * the return value will be used. */ + +PyAPI_FUNC(int) _PyCode_CheckNoInternalState(PyCodeObject *, const char **); +PyAPI_FUNC(int) _PyCode_CheckNoExternalState( + PyCodeObject *, + _PyCode_var_counts_t *, + const char **); +PyAPI_FUNC(int) _PyCode_VerifyStateless( + PyThreadState *, + PyCodeObject *, + PyObject *globalnames, + PyObject *globalsns, + PyObject *builtinsns); + +PyAPI_FUNC(int) _PyCode_CheckPureFunction(PyCodeObject *, const char **); +PyAPI_FUNC(int) _PyCode_ReturnsOnlyNone(PyCodeObject *); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_CODE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_codecs.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_codecs.h new file mode 100644 index 0000000000000000000000000000000000000000..52dca1362592d693e5871d87bbda01cb2cd9420d --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_codecs.h @@ -0,0 +1,76 @@ +#ifndef Py_INTERNAL_CODECS_H +#define Py_INTERNAL_CODECS_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_interp_structs.h" // struct codecs_state + +/* Initialize codecs-related state for the given interpreter, including + registering the first codec search function. Must be called before any other + PyCodec-related functions, and while only one thread is active. */ +extern PyStatus _PyCodec_InitRegistry(PyInterpreterState *interp); + +/* Finalize codecs-related state for the given interpreter. No PyCodec-related + functions other than PyCodec_Unregister() may be called after this. */ +extern void _PyCodec_Fini(PyInterpreterState *interp); + +extern PyObject* _PyCodec_Lookup(const char *encoding); + +/* + * Un-register the error handling callback function registered under + * the given 'name'. Only custom error handlers can be un-registered. + * + * - Return -1 and set an exception if 'name' refers to a built-in + * error handling name (e.g., 'strict'), or if an error occurred. + * - Return 0 if no custom error handler can be found for 'name'. + * - Return 1 if the custom error handler was successfully removed. + */ +extern int _PyCodec_UnregisterError(const char *name); + +/* Text codec specific encoding and decoding API. + + Checks the encoding against a list of codecs which do not + implement a str<->bytes encoding before attempting the + operation. + + Please note that these APIs are internal and should not + be used in Python C extensions. + + XXX (ncoghlan): should we make these, or something like them, public + in Python 3.5+? + + */ +extern PyObject* _PyCodec_LookupTextEncoding( + const char *encoding, + const char *alternate_command); + +extern PyObject* _PyCodec_EncodeText( + PyObject *object, + const char *encoding, + const char *errors); + +extern PyObject* _PyCodec_DecodeText( + PyObject *object, + const char *encoding, + const char *errors); + +/* These two aren't actually text encoding specific, but _io.TextIOWrapper + * is the only current API consumer. + */ +extern PyObject* _PyCodecInfo_GetIncrementalDecoder( + PyObject *codec_info, + const char *errors); + +extern PyObject* _PyCodecInfo_GetIncrementalEncoder( + PyObject *codec_info, + const char *errors); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_CODECS_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_compile.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_compile.h new file mode 100644 index 0000000000000000000000000000000000000000..ed776bbb73a0ee9b2b1d7a46e2c0ff2945f0a4a6 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_compile.h @@ -0,0 +1,230 @@ +#ifndef Py_INTERNAL_COMPILE_H +#define Py_INTERNAL_COMPILE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include + +#include "pycore_ast.h" // mod_ty +#include "pycore_symtable.h" // _Py_SourceLocation +#include "pycore_instruction_sequence.h" + +/* A soft limit for stack use, to avoid excessive + * memory use for large constants, etc. + * + * The value 30 is plucked out of thin air. + * Code that could use more stack than this is + * rare, so the exact value is unimportant. + */ +#define _PY_STACK_USE_GUIDELINE 30 + +struct _arena; // Type defined in pycore_pyarena.h +struct _mod; // Type defined in pycore_ast.h + +// Export for 'test_peg_generator' shared extension +PyAPI_FUNC(PyCodeObject*) _PyAST_Compile( + struct _mod *mod, + PyObject *filename, + PyCompilerFlags *flags, + int optimize, + struct _arena *arena); + +/* AST preprocessing */ +extern int _PyCompile_AstPreprocess( + struct _mod *mod, + PyObject *filename, + PyCompilerFlags *flags, + int optimize, + struct _arena *arena, + int syntax_check_only); + +extern int _PyAST_Preprocess( + struct _mod *, + struct _arena *arena, + PyObject *filename, + int optimize, + int ff_features, + int syntax_check_only, + int enable_warnings); + + +typedef struct { + PyObject *u_name; + PyObject *u_qualname; /* dot-separated qualified name (lazy) */ + + /* The following fields are dicts that map objects to + the index of them in co_XXX. The index is used as + the argument for opcodes that refer to those collections. + */ + PyObject *u_consts; /* all constants */ + PyObject *u_names; /* all names */ + PyObject *u_varnames; /* local variables */ + PyObject *u_cellvars; /* cell variables */ + PyObject *u_freevars; /* free variables */ + PyObject *u_fasthidden; /* dict; keys are names that are fast-locals only + temporarily within an inlined comprehension. When + value is True, treat as fast-local. */ + + Py_ssize_t u_argcount; /* number of arguments for block */ + Py_ssize_t u_posonlyargcount; /* number of positional only arguments for block */ + Py_ssize_t u_kwonlyargcount; /* number of keyword only arguments for block */ + + int u_firstlineno; /* the first lineno of the block */ +} _PyCompile_CodeUnitMetadata; + +struct _PyCompiler; + +typedef enum { + COMPILE_OP_FAST, + COMPILE_OP_GLOBAL, + COMPILE_OP_DEREF, + COMPILE_OP_NAME, +} _PyCompile_optype; + +/* _PyCompile_FBlockInfo tracks the current frame block. + * + * A frame block is used to handle loops, try/except, and try/finally. + * It's called a frame block to distinguish it from a basic block in the + * compiler IR. + */ + +enum _PyCompile_FBlockType { + COMPILE_FBLOCK_WHILE_LOOP, + COMPILE_FBLOCK_FOR_LOOP, + COMPILE_FBLOCK_TRY_EXCEPT, + COMPILE_FBLOCK_FINALLY_TRY, + COMPILE_FBLOCK_FINALLY_END, + COMPILE_FBLOCK_WITH, + COMPILE_FBLOCK_ASYNC_WITH, + COMPILE_FBLOCK_HANDLER_CLEANUP, + COMPILE_FBLOCK_POP_VALUE, + COMPILE_FBLOCK_EXCEPTION_HANDLER, + COMPILE_FBLOCK_EXCEPTION_GROUP_HANDLER, + COMPILE_FBLOCK_ASYNC_COMPREHENSION_GENERATOR, + COMPILE_FBLOCK_STOP_ITERATION, +}; + +typedef struct { + enum _PyCompile_FBlockType fb_type; + _PyJumpTargetLabel fb_block; + _Py_SourceLocation fb_loc; + /* (optional) type-specific exit or cleanup block */ + _PyJumpTargetLabel fb_exit; + /* (optional) additional information required for unwinding */ + void *fb_datum; +} _PyCompile_FBlockInfo; + + +int _PyCompile_PushFBlock(struct _PyCompiler *c, _Py_SourceLocation loc, + enum _PyCompile_FBlockType t, + _PyJumpTargetLabel block_label, + _PyJumpTargetLabel exit, void *datum); +void _PyCompile_PopFBlock(struct _PyCompiler *c, enum _PyCompile_FBlockType t, + _PyJumpTargetLabel block_label); +_PyCompile_FBlockInfo *_PyCompile_TopFBlock(struct _PyCompiler *c); + +int _PyCompile_EnterScope(struct _PyCompiler *c, identifier name, int scope_type, + void *key, int lineno, PyObject *private, + _PyCompile_CodeUnitMetadata *umd); +void _PyCompile_ExitScope(struct _PyCompiler *c); +Py_ssize_t _PyCompile_AddConst(struct _PyCompiler *c, PyObject *o); +_PyInstructionSequence *_PyCompile_InstrSequence(struct _PyCompiler *c); +int _PyCompile_StartAnnotationSetup(struct _PyCompiler *c); +int _PyCompile_EndAnnotationSetup(struct _PyCompiler *c); +int _PyCompile_FutureFeatures(struct _PyCompiler *c); +void _PyCompile_DeferredAnnotations( + struct _PyCompiler *c, PyObject **deferred_annotations, + PyObject **conditional_annotation_indices); +PyObject *_PyCompile_Mangle(struct _PyCompiler *c, PyObject *name); +PyObject *_PyCompile_MaybeMangle(struct _PyCompiler *c, PyObject *name); +int _PyCompile_MaybeAddStaticAttributeToClass(struct _PyCompiler *c, expr_ty e); +int _PyCompile_GetRefType(struct _PyCompiler *c, PyObject *name); +int _PyCompile_LookupCellvar(struct _PyCompiler *c, PyObject *name); +int _PyCompile_ResolveNameop(struct _PyCompiler *c, PyObject *mangled, int scope, + _PyCompile_optype *optype, Py_ssize_t *arg); + +int _PyCompile_IsInteractiveTopLevel(struct _PyCompiler *c); +int _PyCompile_IsInInlinedComp(struct _PyCompiler *c); +int _PyCompile_ScopeType(struct _PyCompiler *c); +int _PyCompile_OptimizationLevel(struct _PyCompiler *c); +int _PyCompile_LookupArg(struct _PyCompiler *c, PyCodeObject *co, PyObject *name); +PyObject *_PyCompile_Qualname(struct _PyCompiler *c); +_PyCompile_CodeUnitMetadata *_PyCompile_Metadata(struct _PyCompiler *c); +PyObject *_PyCompile_StaticAttributesAsTuple(struct _PyCompiler *c); + +struct symtable *_PyCompile_Symtable(struct _PyCompiler *c); +PySTEntryObject *_PyCompile_SymtableEntry(struct _PyCompiler *c); + +enum { + COMPILE_SCOPE_MODULE, + COMPILE_SCOPE_CLASS, + COMPILE_SCOPE_FUNCTION, + COMPILE_SCOPE_ASYNC_FUNCTION, + COMPILE_SCOPE_LAMBDA, + COMPILE_SCOPE_COMPREHENSION, + COMPILE_SCOPE_ANNOTATIONS, +}; + + +typedef struct { + PyObject *pushed_locals; + PyObject *temp_symbols; + PyObject *fast_hidden; + _PyJumpTargetLabel cleanup; +} _PyCompile_InlinedComprehensionState; + +int _PyCompile_TweakInlinedComprehensionScopes(struct _PyCompiler *c, _Py_SourceLocation loc, + PySTEntryObject *entry, + _PyCompile_InlinedComprehensionState *state); +int _PyCompile_RevertInlinedComprehensionScopes(struct _PyCompiler *c, _Py_SourceLocation loc, + _PyCompile_InlinedComprehensionState *state); +int _PyCompile_AddDeferredAnnotation(struct _PyCompiler *c, stmt_ty s, + PyObject **conditional_annotation_index); +void _PyCompile_EnterConditionalBlock(struct _PyCompiler *c); +void _PyCompile_LeaveConditionalBlock(struct _PyCompiler *c); + +int _PyCodegen_AddReturnAtEnd(struct _PyCompiler *c, int addNone); +int _PyCodegen_EnterAnonymousScope(struct _PyCompiler* c, mod_ty mod); +int _PyCodegen_Expression(struct _PyCompiler *c, expr_ty e); +int _PyCodegen_Module(struct _PyCompiler *c, _Py_SourceLocation loc, asdl_stmt_seq *stmts, + bool is_interactive); + +int _PyCompile_ConstCacheMergeOne(PyObject *const_cache, PyObject **obj); + +PyCodeObject *_PyCompile_OptimizeAndAssemble(struct _PyCompiler *c, int addNone); + +Py_ssize_t _PyCompile_DictAddObj(PyObject *dict, PyObject *o); +int _PyCompile_Error(struct _PyCompiler *c, _Py_SourceLocation loc, const char *format, ...); +int _PyCompile_Warn(struct _PyCompiler *c, _Py_SourceLocation loc, const char *format, ...); + +// Export for '_opcode' extension module +PyAPI_FUNC(PyObject*) _PyCompile_GetUnaryIntrinsicName(int index); +PyAPI_FUNC(PyObject*) _PyCompile_GetBinaryIntrinsicName(int index); + +/* Access compiler internals for unit testing */ + +// Export for '_testinternalcapi' shared extension +PyAPI_FUNC(PyObject*) _PyCompile_CleanDoc(PyObject *doc); + +// Export for '_testinternalcapi' shared extension +PyAPI_FUNC(PyObject*) _PyCompile_CodeGen( + PyObject *ast, + PyObject *filename, + PyCompilerFlags *flags, + int optimize, + int compile_mode); + +// Export for '_testinternalcapi' shared extension +PyAPI_FUNC(PyCodeObject*) +_PyCompile_Assemble(_PyCompile_CodeUnitMetadata *umd, PyObject *filename, + PyObject *instructions); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_COMPILE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_complexobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_complexobject.h new file mode 100644 index 0000000000000000000000000000000000000000..f595f6ab7a674d18533a716cbb4e12d342dfe70d --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_complexobject.h @@ -0,0 +1,34 @@ +#ifndef Py_INTERNAL_COMPLEXOBJECT_H +#define Py_INTERNAL_COMPLEXOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_unicodeobject.h" // _PyUnicodeWriter + +/* Format the object based on the format_spec, as defined in PEP 3101 + (Advanced String Formatting). */ +extern int _PyComplex_FormatAdvancedWriter( + _PyUnicodeWriter *writer, + PyObject *obj, + PyObject *format_spec, + Py_ssize_t start, + Py_ssize_t end); + +// Operations on complex numbers. +PyAPI_FUNC(Py_complex) _Py_cr_sum(Py_complex, double); +PyAPI_FUNC(Py_complex) _Py_cr_diff(Py_complex, double); +PyAPI_FUNC(Py_complex) _Py_rc_diff(double, Py_complex); +PyAPI_FUNC(Py_complex) _Py_cr_prod(Py_complex, double); +PyAPI_FUNC(Py_complex) _Py_cr_quot(Py_complex, double); +PyAPI_FUNC(Py_complex) _Py_rc_quot(double, Py_complex); + + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_COMPLEXOBJECT_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_condvar.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_condvar.h new file mode 100644 index 0000000000000000000000000000000000000000..55271f0a4116ba03fe5314751adb2cb4e0067a6c --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_condvar.h @@ -0,0 +1,93 @@ +#ifndef Py_INTERNAL_CONDVAR_H +#define Py_INTERNAL_CONDVAR_H + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_pythread.h" // _POSIX_THREADS + + +#ifdef _POSIX_THREADS +/* + * POSIX support + */ +#define Py_HAVE_CONDVAR + +#ifdef HAVE_PTHREAD_H +# include // pthread_mutex_t +#endif + +#define PyMUTEX_T pthread_mutex_t +#define PyCOND_T pthread_cond_t + +#elif defined(NT_THREADS) +/* + * Windows (XP, 2003 server and later, as well as (hopefully) CE) support + * + * Emulated condition variables ones that work with XP and later, plus + * example native support on VISTA and onwards. + */ +#define Py_HAVE_CONDVAR + +/* include windows if it hasn't been done before */ +#ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +#endif +#include // CRITICAL_SECTION + +/* options */ +/* emulated condition variables are provided for those that want + * to target Windows XP or earlier. Modify this macro to enable them. + */ +#ifndef _PY_EMULATED_WIN_CV +#define _PY_EMULATED_WIN_CV 0 /* use non-emulated condition variables */ +#endif + +/* fall back to emulation if targeting earlier than Vista */ +#if !defined NTDDI_VISTA || NTDDI_VERSION < NTDDI_VISTA +#undef _PY_EMULATED_WIN_CV +#define _PY_EMULATED_WIN_CV 1 +#endif + +#if _PY_EMULATED_WIN_CV + +typedef CRITICAL_SECTION PyMUTEX_T; + +/* The ConditionVariable object. From XP onwards it is easily emulated + with a Semaphore. + Semaphores are available on Windows XP (2003 server) and later. + We use a Semaphore rather than an auto-reset event, because although + an auto-reset event might appear to solve the lost-wakeup bug (race + condition between releasing the outer lock and waiting) because it + maintains state even though a wait hasn't happened, there is still + a lost wakeup problem if more than one thread are interrupted in the + critical place. A semaphore solves that, because its state is + counted, not Boolean. + Because it is ok to signal a condition variable with no one + waiting, we need to keep track of the number of + waiting threads. Otherwise, the semaphore's state could rise + without bound. This also helps reduce the number of "spurious wakeups" + that would otherwise happen. + */ + +typedef struct _PyCOND_T +{ + HANDLE sem; + int waiting; /* to allow PyCOND_SIGNAL to be a no-op */ +} PyCOND_T; + +#else /* !_PY_EMULATED_WIN_CV */ + +/* Use native Windows primitives if build target is Vista or higher */ + +/* SRWLOCK is faster and better than CriticalSection */ +typedef SRWLOCK PyMUTEX_T; + +typedef CONDITION_VARIABLE PyCOND_T; + +#endif /* _PY_EMULATED_WIN_CV */ + +#endif /* _POSIX_THREADS, NT_THREADS */ + +#endif /* Py_INTERNAL_CONDVAR_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_context.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_context.h new file mode 100644 index 0000000000000000000000000000000000000000..c77ef7910c09aa684b290b23de78ed161a7bd1eb --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_context.h @@ -0,0 +1,59 @@ +#ifndef Py_INTERNAL_CONTEXT_H +#define Py_INTERNAL_CONTEXT_H + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_structs.h" + +extern PyTypeObject _PyContextTokenMissing_Type; + +/* runtime lifecycle */ + +PyStatus _PyContext_Init(PyInterpreterState *); + + +/* other API */ + +typedef struct { + PyObject_HEAD +} _PyContextTokenMissing; + +struct _pycontextobject { + PyObject_HEAD + PyContext *ctx_prev; + PyHamtObject *ctx_vars; + PyObject *ctx_weakreflist; + int ctx_entered; +}; + + +struct _pycontextvarobject { + PyObject_HEAD + PyObject *var_name; + PyObject *var_default; +#ifndef Py_GIL_DISABLED + PyObject *var_cached; + uint64_t var_cached_tsid; + uint64_t var_cached_tsver; +#endif + Py_hash_t var_hash; +}; + + +struct _pycontexttokenobject { + PyObject_HEAD + PyContext *tok_ctx; + PyContextVar *tok_var; + PyObject *tok_oldval; + int tok_used; +}; + + +// _testinternalcapi.hamt() used by tests. +// Export for '_testcapi' shared extension +PyAPI_FUNC(PyObject*) _PyContext_NewHamtForTests(void); + + +#endif /* !Py_INTERNAL_CONTEXT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_critical_section.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_critical_section.h new file mode 100644 index 0000000000000000000000000000000000000000..2b49b9f00df3ea5bde0822aca0014a56d391f952 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_critical_section.h @@ -0,0 +1,237 @@ +#ifndef Py_INTERNAL_CRITICAL_SECTION_H +#define Py_INTERNAL_CRITICAL_SECTION_H + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_lock.h" // PyMutex_LockFast() +#include "pycore_pystate.h" // _PyThreadState_GET() +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Tagged pointers to critical sections use the two least significant bits to +// mark if the pointed-to critical section is inactive and whether it is a +// PyCriticalSection2 object. +#define _Py_CRITICAL_SECTION_INACTIVE 0x1 +#define _Py_CRITICAL_SECTION_TWO_MUTEXES 0x2 +#define _Py_CRITICAL_SECTION_MASK 0x3 + +#ifdef Py_GIL_DISABLED +// Specialized version of critical section locking to safely use +// PySequence_Fast APIs without the GIL. For performance, the argument *to* +// PySequence_Fast() is provided to the macro, not the *result* of +// PySequence_Fast(), which would require an extra test to determine if the +// lock must be acquired. +# define Py_BEGIN_CRITICAL_SECTION_SEQUENCE_FAST(original) \ + { \ + PyObject *_orig_seq = _PyObject_CAST(original); \ + const bool _should_lock_cs = PyList_CheckExact(_orig_seq); \ + PyCriticalSection _cs; \ + if (_should_lock_cs) { \ + _PyCriticalSection_Begin(&_cs, _orig_seq); \ + } + +# define Py_END_CRITICAL_SECTION_SEQUENCE_FAST() \ + if (_should_lock_cs) { \ + PyCriticalSection_End(&_cs); \ + } \ + } + +// Asserts that the mutex is locked. The mutex must be held by the +// top-most critical section otherwise there's the possibility +// that the mutex would be swalled out in some code paths. +#define _Py_CRITICAL_SECTION_ASSERT_MUTEX_LOCKED(mutex) \ + _PyCriticalSection_AssertHeld(mutex) + +// Asserts that the mutex for the given object is locked. The mutex must +// be held by the top-most critical section otherwise there's the +// possibility that the mutex would be swalled out in some code paths. +#ifdef Py_DEBUG + +# define _Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(op) \ + if (Py_REFCNT(op) != 1) { \ + _Py_CRITICAL_SECTION_ASSERT_MUTEX_LOCKED(&_PyObject_CAST(op)->ob_mutex); \ + } + +#else /* Py_DEBUG */ + +# define _Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(op) + +#endif /* Py_DEBUG */ + +#else /* !Py_GIL_DISABLED */ +// The critical section APIs are no-ops with the GIL. +# define Py_BEGIN_CRITICAL_SECTION_SEQUENCE_FAST(original) { +# define Py_END_CRITICAL_SECTION_SEQUENCE_FAST() } +# define _Py_CRITICAL_SECTION_ASSERT_MUTEX_LOCKED(mutex) +# define _Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(op) +#endif /* !Py_GIL_DISABLED */ + +// Resumes the top-most critical section. +PyAPI_FUNC(void) +_PyCriticalSection_Resume(PyThreadState *tstate); + +// (private) slow path for locking the mutex +PyAPI_FUNC(void) +_PyCriticalSection_BeginSlow(PyCriticalSection *c, PyMutex *m); + +PyAPI_FUNC(void) +_PyCriticalSection2_BeginSlow(PyCriticalSection2 *c, PyMutex *m1, PyMutex *m2, + int is_m1_locked); + +PyAPI_FUNC(void) +_PyCriticalSection_SuspendAll(PyThreadState *tstate); + +#ifdef Py_GIL_DISABLED + +static inline int +_PyCriticalSection_IsActive(uintptr_t tag) +{ + return tag != 0 && (tag & _Py_CRITICAL_SECTION_INACTIVE) == 0; +} + +static inline void +_PyCriticalSection_BeginMutex(PyCriticalSection *c, PyMutex *m) +{ + if (PyMutex_LockFast(m)) { + PyThreadState *tstate = _PyThreadState_GET(); + c->_cs_mutex = m; + c->_cs_prev = tstate->critical_section; + tstate->critical_section = (uintptr_t)c; + } + else { + _PyCriticalSection_BeginSlow(c, m); + } +} +#define PyCriticalSection_BeginMutex _PyCriticalSection_BeginMutex + +static inline void +_PyCriticalSection_Begin(PyCriticalSection *c, PyObject *op) +{ + _PyCriticalSection_BeginMutex(c, &op->ob_mutex); +} +#define PyCriticalSection_Begin _PyCriticalSection_Begin + +// Removes the top-most critical section from the thread's stack of critical +// sections. If the new top-most critical section is inactive, then it is +// resumed. +static inline void +_PyCriticalSection_Pop(PyCriticalSection *c) +{ + PyThreadState *tstate = _PyThreadState_GET(); + uintptr_t prev = c->_cs_prev; + tstate->critical_section = prev; + + if ((prev & _Py_CRITICAL_SECTION_INACTIVE) != 0) { + _PyCriticalSection_Resume(tstate); + } +} + +static inline void +_PyCriticalSection_End(PyCriticalSection *c) +{ + // If the mutex is NULL, we used the fast path in + // _PyCriticalSection_BeginSlow for locks already held in the top-most + // critical section, and we shouldn't unlock or pop this critical section. + if (c->_cs_mutex == NULL) { + return; + } + PyMutex_Unlock(c->_cs_mutex); + _PyCriticalSection_Pop(c); +} +#define PyCriticalSection_End _PyCriticalSection_End + +static inline void +_PyCriticalSection2_BeginMutex(PyCriticalSection2 *c, PyMutex *m1, PyMutex *m2) +{ + if (m1 == m2) { + // If the two mutex arguments are the same, treat this as a critical + // section with a single mutex. + c->_cs_mutex2 = NULL; + _PyCriticalSection_BeginMutex(&c->_cs_base, m1); + return; + } + + if ((uintptr_t)m2 < (uintptr_t)m1) { + // Sort the mutexes so that the lower address is locked first. + // The exact order does not matter, but we need to acquire the mutexes + // in a consistent order to avoid lock ordering deadlocks. + PyMutex *tmp = m1; + m1 = m2; + m2 = tmp; + } + + if (PyMutex_LockFast(m1)) { + if (PyMutex_LockFast(m2)) { + PyThreadState *tstate = _PyThreadState_GET(); + c->_cs_base._cs_mutex = m1; + c->_cs_mutex2 = m2; + c->_cs_base._cs_prev = tstate->critical_section; + + uintptr_t p = (uintptr_t)c | _Py_CRITICAL_SECTION_TWO_MUTEXES; + tstate->critical_section = p; + } + else { + _PyCriticalSection2_BeginSlow(c, m1, m2, 1); + } + } + else { + _PyCriticalSection2_BeginSlow(c, m1, m2, 0); + } +} +#define PyCriticalSection2_BeginMutex _PyCriticalSection2_BeginMutex + +static inline void +_PyCriticalSection2_Begin(PyCriticalSection2 *c, PyObject *a, PyObject *b) +{ + _PyCriticalSection2_BeginMutex(c, &a->ob_mutex, &b->ob_mutex); +} +#define PyCriticalSection2_Begin _PyCriticalSection2_Begin + +static inline void +_PyCriticalSection2_End(PyCriticalSection2 *c) +{ + // if mutex1 is NULL, we used the fast path in + // _PyCriticalSection_BeginSlow for mutexes that are already held, + // which should only happen when mutex1 and mutex2 were the same mutex, + // and mutex2 should also be NULL. + if (c->_cs_base._cs_mutex == NULL) { + assert(c->_cs_mutex2 == NULL); + return; + } + if (c->_cs_mutex2) { + PyMutex_Unlock(c->_cs_mutex2); + } + PyMutex_Unlock(c->_cs_base._cs_mutex); + _PyCriticalSection_Pop(&c->_cs_base); +} +#define PyCriticalSection2_End _PyCriticalSection2_End + +static inline void +_PyCriticalSection_AssertHeld(PyMutex *mutex) +{ +#ifdef Py_DEBUG + PyThreadState *tstate = _PyThreadState_GET(); + uintptr_t prev = tstate->critical_section; + if (prev & _Py_CRITICAL_SECTION_TWO_MUTEXES) { + PyCriticalSection2 *cs = (PyCriticalSection2 *)(prev & ~_Py_CRITICAL_SECTION_MASK); + assert(cs != NULL && (cs->_cs_base._cs_mutex == mutex || cs->_cs_mutex2 == mutex)); + } + else { + PyCriticalSection *cs = (PyCriticalSection *)(tstate->critical_section & ~_Py_CRITICAL_SECTION_MASK); + assert(cs != NULL && cs->_cs_mutex == mutex); + } + +#endif +} + +#endif /* Py_GIL_DISABLED */ + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_CRITICAL_SECTION_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_crossinterp.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_crossinterp.h new file mode 100644 index 0000000000000000000000000000000000000000..81faffac1941719cfccd5c44f0b8b4fae81f45fe --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_crossinterp.h @@ -0,0 +1,406 @@ +#ifndef Py_INTERNAL_CROSSINTERP_H +#define Py_INTERNAL_CROSSINTERP_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_pyerrors.h" + + +/**************/ +/* exceptions */ +/**************/ + +PyAPI_DATA(PyObject *) PyExc_InterpreterError; +PyAPI_DATA(PyObject *) PyExc_InterpreterNotFoundError; + + +/***************************/ +/* cross-interpreter calls */ +/***************************/ + +typedef int (*_Py_simple_func)(void *); +extern int _Py_CallInInterpreter( + PyInterpreterState *interp, + _Py_simple_func func, + void *arg); +extern int _Py_CallInInterpreterAndRawFree( + PyInterpreterState *interp, + _Py_simple_func func, + void *arg); + + +/**************************/ +/* cross-interpreter data */ +/**************************/ + +typedef struct _xidata _PyXIData_t; +typedef PyObject *(*xid_newobjfunc)(_PyXIData_t *); +typedef void (*xid_freefunc)(void *); + +// _PyXIData_t is similar to Py_buffer as an effectively +// opaque struct that holds data outside the object machinery. This +// is necessary to pass safely between interpreters in the same process. +struct _xidata { + // data is the cross-interpreter-safe derivation of a Python object + // (see _PyObject_GetXIData). It will be NULL if the + // new_object func (below) encodes the data. + void *data; + // obj is the Python object from which the data was derived. This + // is non-NULL only if the data remains bound to the object in some + // way, such that the object must be "released" (via a decref) when + // the data is released. In that case the code that sets the field, + // likely a registered "xidatafunc", is responsible for + // ensuring it owns the reference (i.e. incref). + PyObject *obj; + // interpid is the ID of the owning interpreter of the original + // object. It corresponds to the active interpreter when + // _PyObject_GetXIData() was called. This should only + // be set by the cross-interpreter machinery. + // + // We use the ID rather than the PyInterpreterState to avoid issues + // with deleted interpreters. Note that IDs are never re-used, so + // each one will always correspond to a specific interpreter + // (whether still alive or not). + int64_t interpid; + // new_object is a function that returns a new object in the current + // interpreter given the data. The resulting object (a new + // reference) will be equivalent to the original object. This field + // is required. + xid_newobjfunc new_object; + // free is called when the data is released. If it is NULL then + // nothing will be done to free the data. For some types this is + // okay (e.g. bytes) and for those types this field should be set + // to NULL. However, for most the data was allocated just for + // cross-interpreter use, so it must be freed when + // _PyXIData_Release is called or the memory will + // leak. In that case, at the very least this field should be set + // to PyMem_RawFree (the default if not explicitly set to NULL). + // The call will happen with the original interpreter activated. + xid_freefunc free; +}; + +PyAPI_FUNC(_PyXIData_t *) _PyXIData_New(void); +PyAPI_FUNC(void) _PyXIData_Free(_PyXIData_t *data); + +#define _PyXIData_DATA(DATA) ((DATA)->data) +#define _PyXIData_OBJ(DATA) ((DATA)->obj) +#define _PyXIData_INTERPID(DATA) ((DATA)->interpid) +// Users should not need getters for "new_object" or "free". + + +/* defining cross-interpreter data */ + +PyAPI_FUNC(void) _PyXIData_Init( + _PyXIData_t *data, + PyInterpreterState *interp, void *shared, PyObject *obj, + xid_newobjfunc new_object); +PyAPI_FUNC(int) _PyXIData_InitWithSize( + _PyXIData_t *, + PyInterpreterState *interp, const size_t, PyObject *, + xid_newobjfunc); +PyAPI_FUNC(void) _PyXIData_Clear(PyInterpreterState *, _PyXIData_t *); + +// Normally the Init* functions are sufficient. The only time +// additional initialization might be needed is to set the "free" func, +// though that should be infrequent. +#define _PyXIData_SET_FREE(DATA, FUNC) \ + do { \ + (DATA)->free = (FUNC); \ + } while (0) +#define _PyXIData_CHECK_FREE(DATA, FUNC) \ + ((DATA)->free == (FUNC)) +// Additionally, some shareable types are essentially light wrappers +// around other shareable types. The xidatafunc of the wrapper +// can often be implemented by calling the wrapped object's +// xidatafunc and then changing the "new_object" function. +// We have _PyXIData_SET_NEW_OBJECT() here for that, +// but might be better to have a function like +// _PyXIData_AdaptToWrapper() instead. +#define _PyXIData_SET_NEW_OBJECT(DATA, FUNC) \ + do { \ + (DATA)->new_object = (FUNC); \ + } while (0) +#define _PyXIData_CHECK_NEW_OBJECT(DATA, FUNC) \ + ((DATA)->new_object == (FUNC)) + + +/* getting cross-interpreter data */ + +typedef int xidata_fallback_t; +#define _PyXIDATA_XIDATA_ONLY (0) +#define _PyXIDATA_FULL_FALLBACK (1) + +// Technically, we don't need two different function types; +// we could go with just the fallback one. However, only container +// types like tuple need it, so always having the extra arg would be +// a bit unfortunate. It's also nice to be able to clearly distinguish +// between types that might call _PyObject_GetXIData() and those that won't. +// +typedef int (*xidatafunc)(PyThreadState *, PyObject *, _PyXIData_t *); +typedef int (*xidatafbfunc)( + PyThreadState *, PyObject *, xidata_fallback_t, _PyXIData_t *); +typedef struct { + xidatafunc basic; + xidatafbfunc fallback; +} _PyXIData_getdata_t; + +PyAPI_FUNC(PyObject *) _PyXIData_GetNotShareableErrorType(PyThreadState *); +PyAPI_FUNC(void) _PyXIData_SetNotShareableError(PyThreadState *, const char *); +PyAPI_FUNC(void) _PyXIData_FormatNotShareableError( + PyThreadState *, + const char *, + ...); + +PyAPI_FUNC(_PyXIData_getdata_t) _PyXIData_Lookup( + PyThreadState *, + PyObject *); +PyAPI_FUNC(int) _PyObject_CheckXIData( + PyThreadState *, + PyObject *); + +PyAPI_FUNC(int) _PyObject_GetXIDataNoFallback( + PyThreadState *, + PyObject *, + _PyXIData_t *); +PyAPI_FUNC(int) _PyObject_GetXIData( + PyThreadState *, + PyObject *, + xidata_fallback_t, + _PyXIData_t *); + +// _PyObject_GetXIData() for bytes +typedef struct { + const char *bytes; + Py_ssize_t len; +} _PyBytes_data_t; +PyAPI_FUNC(int) _PyBytes_GetData(PyObject *, _PyBytes_data_t *); +PyAPI_FUNC(PyObject *) _PyBytes_FromData(_PyBytes_data_t *); +PyAPI_FUNC(PyObject *) _PyBytes_FromXIData(_PyXIData_t *); +PyAPI_FUNC(int) _PyBytes_GetXIData( + PyThreadState *, + PyObject *, + _PyXIData_t *); +PyAPI_FUNC(_PyBytes_data_t *) _PyBytes_GetXIDataWrapped( + PyThreadState *, + PyObject *, + size_t, + xid_newobjfunc, + _PyXIData_t *); + +// _PyObject_GetXIData() for pickle +PyAPI_DATA(PyObject *) _PyPickle_LoadFromXIData(_PyXIData_t *); +PyAPI_FUNC(int) _PyPickle_GetXIData( + PyThreadState *, + PyObject *, + _PyXIData_t *); + +// _PyObject_GetXIData() for marshal +PyAPI_FUNC(PyObject *) _PyMarshal_ReadObjectFromXIData(_PyXIData_t *); +PyAPI_FUNC(int) _PyMarshal_GetXIData( + PyThreadState *, + PyObject *, + _PyXIData_t *); + +// _PyObject_GetXIData() for code objects +PyAPI_FUNC(PyObject *) _PyCode_FromXIData(_PyXIData_t *); +PyAPI_FUNC(int) _PyCode_GetXIData( + PyThreadState *, + PyObject *, + _PyXIData_t *); +PyAPI_FUNC(int) _PyCode_GetScriptXIData( + PyThreadState *, + PyObject *, + _PyXIData_t *); +PyAPI_FUNC(int) _PyCode_GetPureScriptXIData( + PyThreadState *, + PyObject *, + _PyXIData_t *); + +// _PyObject_GetXIData() for functions +PyAPI_FUNC(PyObject *) _PyFunction_FromXIData(_PyXIData_t *); +PyAPI_FUNC(int) _PyFunction_GetXIData( + PyThreadState *, + PyObject *, + _PyXIData_t *); + + +/* using cross-interpreter data */ + +PyAPI_FUNC(PyObject *) _PyXIData_NewObject(_PyXIData_t *); +PyAPI_FUNC(int) _PyXIData_Release(_PyXIData_t *); +PyAPI_FUNC(int) _PyXIData_ReleaseAndRawFree(_PyXIData_t *); + + +/* cross-interpreter data registry */ + +#define Py_CORE_CROSSINTERP_DATA_REGISTRY_H +#include "pycore_crossinterp_data_registry.h" +#undef Py_CORE_CROSSINTERP_DATA_REGISTRY_H + + +/*****************************/ +/* runtime state & lifecycle */ +/*****************************/ + +typedef struct _xid_lookup_state _PyXIData_lookup_t; + +typedef struct { + // builtin types + _PyXIData_lookup_t data_lookup; +} _PyXI_global_state_t; + +typedef struct { + // heap types + _PyXIData_lookup_t data_lookup; + + struct xi_exceptions { + // static types + PyObject *PyExc_InterpreterError; + PyObject *PyExc_InterpreterNotFoundError; + // heap types + PyObject *PyExc_NotShareableError; + } exceptions; +} _PyXI_state_t; + +#define _PyXI_GET_GLOBAL_STATE(interp) (&(interp)->runtime->xi) +#define _PyXI_GET_STATE(interp) (&(interp)->xi) + +#ifndef Py_BUILD_CORE_MODULE +extern PyStatus _PyXI_Init(PyInterpreterState *interp); +extern void _PyXI_Fini(PyInterpreterState *interp); +extern PyStatus _PyXI_InitTypes(PyInterpreterState *interp); +extern void _PyXI_FiniTypes(PyInterpreterState *interp); +#endif // Py_BUILD_CORE_MODULE + +int _Py_xi_global_state_init(_PyXI_global_state_t *); +void _Py_xi_global_state_fini(_PyXI_global_state_t *); +int _Py_xi_state_init(_PyXI_state_t *, PyInterpreterState *); +void _Py_xi_state_fini(_PyXI_state_t *, PyInterpreterState *); + + +/***************************/ +/* short-term data sharing */ +/***************************/ + +// Ultimately we'd like to preserve enough information about the +// exception and traceback that we could re-constitute (or at least +// simulate, a la traceback.TracebackException), and even chain, a copy +// of the exception in the calling interpreter. + +typedef struct _excinfo { + struct _excinfo_type { + PyTypeObject *builtin; + const char *name; + const char *qualname; + const char *module; + } type; + const char *msg; + const char *errdisplay; +} _PyXI_excinfo; + +PyAPI_FUNC(_PyXI_excinfo *) _PyXI_NewExcInfo(PyObject *exc); +PyAPI_FUNC(void) _PyXI_FreeExcInfo(_PyXI_excinfo *info); +PyAPI_FUNC(PyObject *) _PyXI_FormatExcInfo(_PyXI_excinfo *info); +PyAPI_FUNC(PyObject *) _PyXI_ExcInfoAsObject(_PyXI_excinfo *info); + + +typedef enum error_code { + _PyXI_ERR_NO_ERROR = 0, + _PyXI_ERR_UNCAUGHT_EXCEPTION = -1, + _PyXI_ERR_OTHER = -2, + _PyXI_ERR_NO_MEMORY = -3, + _PyXI_ERR_ALREADY_RUNNING = -4, + _PyXI_ERR_MAIN_NS_FAILURE = -5, + _PyXI_ERR_APPLY_NS_FAILURE = -6, + _PyXI_ERR_PRESERVE_FAILURE = -7, + _PyXI_ERR_EXC_PROPAGATION_FAILURE = -8, + _PyXI_ERR_NOT_SHAREABLE = -9, +} _PyXI_errcode; + +typedef struct xi_failure _PyXI_failure; + +PyAPI_FUNC(_PyXI_failure *) _PyXI_NewFailure(void); +PyAPI_FUNC(void) _PyXI_FreeFailure(_PyXI_failure *); +PyAPI_FUNC(_PyXI_errcode) _PyXI_GetFailureCode(_PyXI_failure *); +PyAPI_FUNC(int) _PyXI_InitFailure(_PyXI_failure *, _PyXI_errcode, PyObject *); +PyAPI_FUNC(void) _PyXI_InitFailureUTF8( + _PyXI_failure *, + _PyXI_errcode, + const char *); + +PyAPI_FUNC(int) _PyXI_UnwrapNotShareableError( + PyThreadState *, + _PyXI_failure *); + + +// A cross-interpreter session involves entering an interpreter +// with _PyXI_Enter(), doing some work with it, and finally exiting +// that interpreter with _PyXI_Exit(). +// +// At the boundaries of the session, both entering and exiting, +// data may be exchanged between the previous interpreter and the +// target one in a thread-safe way that does not violate the +// isolation between interpreters. This includes setting objects +// in the target's __main__ module on the way in, and capturing +// uncaught exceptions on the way out. +typedef struct xi_session _PyXI_session; + +PyAPI_FUNC(_PyXI_session *) _PyXI_NewSession(void); +PyAPI_FUNC(void) _PyXI_FreeSession(_PyXI_session *); + +typedef struct { + PyObject *preserved; + PyObject *excinfo; + _PyXI_errcode errcode; +} _PyXI_session_result; +PyAPI_FUNC(void) _PyXI_ClearResult(_PyXI_session_result *); + +PyAPI_FUNC(int) _PyXI_Enter( + _PyXI_session *session, + PyInterpreterState *interp, + PyObject *nsupdates, + _PyXI_session_result *); +PyAPI_FUNC(int) _PyXI_Exit( + _PyXI_session *, + _PyXI_failure *, + _PyXI_session_result *); + +PyAPI_FUNC(PyObject *) _PyXI_GetMainNamespace( + _PyXI_session *, + _PyXI_failure *); + +PyAPI_FUNC(int) _PyXI_Preserve( + _PyXI_session *, + const char *, + PyObject *, + _PyXI_failure *); +PyAPI_FUNC(PyObject *) _PyXI_GetPreserved( + _PyXI_session_result *, + const char *); + + +/*************/ +/* other API */ +/*************/ + +// Export for _testinternalcapi shared extension +PyAPI_FUNC(PyInterpreterState *) _PyXI_NewInterpreter( + PyInterpreterConfig *config, + long *maybe_whence, + PyThreadState **p_tstate, + PyThreadState **p_save_tstate); +PyAPI_FUNC(void) _PyXI_EndInterpreter( + PyInterpreterState *interp, + PyThreadState *tstate, + PyThreadState **p_save_tstate); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_CROSSINTERP_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_crossinterp_data_registry.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_crossinterp_data_registry.h new file mode 100644 index 0000000000000000000000000000000000000000..fbb4cad5cac32e0a8a39c72b3223baf16f2c30a1 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_crossinterp_data_registry.h @@ -0,0 +1,41 @@ +#ifndef Py_CORE_CROSSINTERP_DATA_REGISTRY_H +# error "this header must not be included directly" +#endif + + +// For now we use a global registry of shareable classes. An +// alternative would be to add a tp_* slot for a class's +// xidatafunc. It would be simpler and more efficient. + +struct _xid_regitem; + +typedef struct _xid_regitem { + struct _xid_regitem *prev; + struct _xid_regitem *next; + /* This can be a dangling pointer, but only if weakref is set. */ + PyTypeObject *cls; + /* This is NULL for builtin types. */ + PyObject *weakref; + size_t refcount; + _PyXIData_getdata_t getdata; +} _PyXIData_regitem_t; + +typedef struct { + int global; /* builtin types or heap types */ + int initialized; + PyMutex mutex; + _PyXIData_regitem_t *head; +} _PyXIData_registry_t; + +PyAPI_FUNC(int) _PyXIData_RegisterClass( + PyThreadState *, + PyTypeObject *, + _PyXIData_getdata_t); +PyAPI_FUNC(int) _PyXIData_UnregisterClass( + PyThreadState *, + PyTypeObject *); + +struct _xid_lookup_state { + // XXX Remove this field once we have a tp_* slot. + _PyXIData_registry_t registry; +}; diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_debug_offsets.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_debug_offsets.h new file mode 100644 index 0000000000000000000000000000000000000000..8e7cd16acffa48ac8934df9749350842ed1c4bed --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_debug_offsets.h @@ -0,0 +1,379 @@ +#ifndef Py_INTERNAL_DEBUG_OFFSETS_H +#define Py_INTERNAL_DEBUG_OFFSETS_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + + +#define _Py_Debug_Cookie "xdebugpy" + +#if defined(__APPLE__) +# include +#endif + +// Macros to burn global values in custom sections so out-of-process +// profilers can locate them easily. +#define GENERATE_DEBUG_SECTION(name, declaration) \ + _GENERATE_DEBUG_SECTION_WINDOWS(name) \ + _GENERATE_DEBUG_SECTION_APPLE(name) \ + declaration \ + _GENERATE_DEBUG_SECTION_LINUX(name) + +// Please note that section names are truncated to eight bytes +// on Windows! +#if defined(MS_WINDOWS) +#define _GENERATE_DEBUG_SECTION_WINDOWS(name) \ + _Pragma(Py_STRINGIFY(section(Py_STRINGIFY(name), read, write))) \ + __declspec(allocate(Py_STRINGIFY(name))) +#else +#define _GENERATE_DEBUG_SECTION_WINDOWS(name) +#endif + +#if defined(__APPLE__) +#define _GENERATE_DEBUG_SECTION_APPLE(name) \ + __attribute__((section(SEG_DATA "," Py_STRINGIFY(name)))) \ + __attribute__((used)) +#else +#define _GENERATE_DEBUG_SECTION_APPLE(name) +#endif + +#if defined(__linux__) && (defined(__GNUC__) || defined(__clang__)) +#define _GENERATE_DEBUG_SECTION_LINUX(name) \ + __attribute__((section("." Py_STRINGIFY(name)))) \ + __attribute__((used)) +#else +#define _GENERATE_DEBUG_SECTION_LINUX(name) +#endif + +#ifdef Py_GIL_DISABLED +# define _Py_Debug_gilruntimestate_enabled offsetof(struct _gil_runtime_state, enabled) +# define _Py_Debug_Free_Threaded 1 +# define _Py_Debug_code_object_co_tlbc offsetof(PyCodeObject, co_tlbc) +# define _Py_Debug_interpreter_frame_tlbc_index offsetof(_PyInterpreterFrame, tlbc_index) +# define _Py_Debug_interpreter_state_tlbc_generation offsetof(PyInterpreterState, tlbc_indices.tlbc_generation) +#else +# define _Py_Debug_gilruntimestate_enabled 0 +# define _Py_Debug_Free_Threaded 0 +# define _Py_Debug_code_object_co_tlbc 0 +# define _Py_Debug_interpreter_frame_tlbc_index 0 +# define _Py_Debug_interpreter_state_tlbc_generation 0 +#endif + + +typedef struct _Py_DebugOffsets { + char cookie[8] _Py_NONSTRING; + uint64_t version; + uint64_t free_threaded; + // Runtime state offset; + struct _runtime_state { + uint64_t size; + uint64_t finalizing; + uint64_t interpreters_head; + } runtime_state; + + // Interpreter state offset; + struct _interpreter_state { + uint64_t size; + uint64_t id; + uint64_t next; + uint64_t threads_head; + uint64_t threads_main; + uint64_t gc; + uint64_t imports_modules; + uint64_t sysdict; + uint64_t builtins; + uint64_t ceval_gil; + uint64_t gil_runtime_state; + uint64_t gil_runtime_state_enabled; + uint64_t gil_runtime_state_locked; + uint64_t gil_runtime_state_holder; + uint64_t code_object_generation; + uint64_t tlbc_generation; + } interpreter_state; + + // Thread state offset; + struct _thread_state{ + uint64_t size; + uint64_t prev; + uint64_t next; + uint64_t interp; + uint64_t current_frame; + uint64_t thread_id; + uint64_t native_thread_id; + uint64_t datastack_chunk; + uint64_t status; + } thread_state; + + // InterpreterFrame offset; + struct _interpreter_frame { + uint64_t size; + uint64_t previous; + uint64_t executable; + uint64_t instr_ptr; + uint64_t localsplus; + uint64_t owner; + uint64_t stackpointer; + uint64_t tlbc_index; + } interpreter_frame; + + // Code object offset; + struct _code_object { + uint64_t size; + uint64_t filename; + uint64_t name; + uint64_t qualname; + uint64_t linetable; + uint64_t firstlineno; + uint64_t argcount; + uint64_t localsplusnames; + uint64_t localspluskinds; + uint64_t co_code_adaptive; + uint64_t co_tlbc; + } code_object; + + // PyObject offset; + struct _pyobject { + uint64_t size; + uint64_t ob_type; + } pyobject; + + // PyTypeObject object offset; + struct _type_object { + uint64_t size; + uint64_t tp_name; + uint64_t tp_repr; + uint64_t tp_flags; + } type_object; + + // PyTuple object offset; + struct _tuple_object { + uint64_t size; + uint64_t ob_item; + uint64_t ob_size; + } tuple_object; + + // PyList object offset; + struct _list_object { + uint64_t size; + uint64_t ob_item; + uint64_t ob_size; + } list_object; + + // PySet object offset; + struct _set_object { + uint64_t size; + uint64_t used; + uint64_t table; + uint64_t mask; + } set_object; + + // PyDict object offset; + struct _dict_object { + uint64_t size; + uint64_t ma_keys; + uint64_t ma_values; + } dict_object; + + // PyFloat object offset; + struct _float_object { + uint64_t size; + uint64_t ob_fval; + } float_object; + + // PyLong object offset; + struct _long_object { + uint64_t size; + uint64_t lv_tag; + uint64_t ob_digit; + } long_object; + + // PyBytes object offset; + struct _bytes_object { + uint64_t size; + uint64_t ob_size; + uint64_t ob_sval; + } bytes_object; + + // Unicode object offset; + struct _unicode_object { + uint64_t size; + uint64_t state; + uint64_t length; + uint64_t asciiobject_size; + } unicode_object; + + // GC runtime state offset; + struct _gc { + uint64_t size; + uint64_t collecting; + } gc; + + // Generator object offset; + struct _gen_object { + uint64_t size; + uint64_t gi_name; + uint64_t gi_iframe; + uint64_t gi_frame_state; + } gen_object; + + struct _llist_node { + uint64_t next; + uint64_t prev; + } llist_node; + + struct _debugger_support { + uint64_t eval_breaker; + uint64_t remote_debugger_support; + uint64_t remote_debugging_enabled; + uint64_t debugger_pending_call; + uint64_t debugger_script_path; + uint64_t debugger_script_path_size; + } debugger_support; +} _Py_DebugOffsets; + + +#define _Py_DebugOffsets_INIT(debug_cookie) { \ + .cookie = debug_cookie, \ + .version = PY_VERSION_HEX, \ + .free_threaded = _Py_Debug_Free_Threaded, \ + .runtime_state = { \ + .size = sizeof(_PyRuntimeState), \ + .finalizing = offsetof(_PyRuntimeState, _finalizing), \ + .interpreters_head = offsetof(_PyRuntimeState, interpreters.head), \ + }, \ + .interpreter_state = { \ + .size = sizeof(PyInterpreterState), \ + .id = offsetof(PyInterpreterState, id), \ + .next = offsetof(PyInterpreterState, next), \ + .threads_head = offsetof(PyInterpreterState, threads.head), \ + .threads_main = offsetof(PyInterpreterState, threads.main), \ + .gc = offsetof(PyInterpreterState, gc), \ + .imports_modules = offsetof(PyInterpreterState, imports.modules), \ + .sysdict = offsetof(PyInterpreterState, sysdict), \ + .builtins = offsetof(PyInterpreterState, builtins), \ + .ceval_gil = offsetof(PyInterpreterState, ceval.gil), \ + .gil_runtime_state = offsetof(PyInterpreterState, _gil), \ + .gil_runtime_state_enabled = _Py_Debug_gilruntimestate_enabled, \ + .gil_runtime_state_locked = offsetof(PyInterpreterState, _gil.locked), \ + .gil_runtime_state_holder = offsetof(PyInterpreterState, _gil.last_holder), \ + .code_object_generation = offsetof(PyInterpreterState, _code_object_generation), \ + .tlbc_generation = _Py_Debug_interpreter_state_tlbc_generation, \ + }, \ + .thread_state = { \ + .size = sizeof(PyThreadState), \ + .prev = offsetof(PyThreadState, prev), \ + .next = offsetof(PyThreadState, next), \ + .interp = offsetof(PyThreadState, interp), \ + .current_frame = offsetof(PyThreadState, current_frame), \ + .thread_id = offsetof(PyThreadState, thread_id), \ + .native_thread_id = offsetof(PyThreadState, native_thread_id), \ + .datastack_chunk = offsetof(PyThreadState, datastack_chunk), \ + .status = offsetof(PyThreadState, _status), \ + }, \ + .interpreter_frame = { \ + .size = sizeof(_PyInterpreterFrame), \ + .previous = offsetof(_PyInterpreterFrame, previous), \ + .executable = offsetof(_PyInterpreterFrame, f_executable), \ + .instr_ptr = offsetof(_PyInterpreterFrame, instr_ptr), \ + .localsplus = offsetof(_PyInterpreterFrame, localsplus), \ + .owner = offsetof(_PyInterpreterFrame, owner), \ + .stackpointer = offsetof(_PyInterpreterFrame, stackpointer), \ + .tlbc_index = _Py_Debug_interpreter_frame_tlbc_index, \ + }, \ + .code_object = { \ + .size = sizeof(PyCodeObject), \ + .filename = offsetof(PyCodeObject, co_filename), \ + .name = offsetof(PyCodeObject, co_name), \ + .qualname = offsetof(PyCodeObject, co_qualname), \ + .linetable = offsetof(PyCodeObject, co_linetable), \ + .firstlineno = offsetof(PyCodeObject, co_firstlineno), \ + .argcount = offsetof(PyCodeObject, co_argcount), \ + .localsplusnames = offsetof(PyCodeObject, co_localsplusnames), \ + .localspluskinds = offsetof(PyCodeObject, co_localspluskinds), \ + .co_code_adaptive = offsetof(PyCodeObject, co_code_adaptive), \ + .co_tlbc = _Py_Debug_code_object_co_tlbc, \ + }, \ + .pyobject = { \ + .size = sizeof(PyObject), \ + .ob_type = offsetof(PyObject, ob_type), \ + }, \ + .type_object = { \ + .size = sizeof(PyTypeObject), \ + .tp_name = offsetof(PyTypeObject, tp_name), \ + .tp_repr = offsetof(PyTypeObject, tp_repr), \ + .tp_flags = offsetof(PyTypeObject, tp_flags), \ + }, \ + .tuple_object = { \ + .size = sizeof(PyTupleObject), \ + .ob_item = offsetof(PyTupleObject, ob_item), \ + .ob_size = offsetof(PyTupleObject, ob_base.ob_size), \ + }, \ + .list_object = { \ + .size = sizeof(PyListObject), \ + .ob_item = offsetof(PyListObject, ob_item), \ + .ob_size = offsetof(PyListObject, ob_base.ob_size), \ + }, \ + .set_object = { \ + .size = sizeof(PySetObject), \ + .used = offsetof(PySetObject, used), \ + .table = offsetof(PySetObject, table), \ + .mask = offsetof(PySetObject, mask), \ + }, \ + .dict_object = { \ + .size = sizeof(PyDictObject), \ + .ma_keys = offsetof(PyDictObject, ma_keys), \ + .ma_values = offsetof(PyDictObject, ma_values), \ + }, \ + .float_object = { \ + .size = sizeof(PyFloatObject), \ + .ob_fval = offsetof(PyFloatObject, ob_fval), \ + }, \ + .long_object = { \ + .size = sizeof(PyLongObject), \ + .lv_tag = offsetof(PyLongObject, long_value.lv_tag), \ + .ob_digit = offsetof(PyLongObject, long_value.ob_digit), \ + }, \ + .bytes_object = { \ + .size = sizeof(PyBytesObject), \ + .ob_size = offsetof(PyBytesObject, ob_base.ob_size), \ + .ob_sval = offsetof(PyBytesObject, ob_sval), \ + }, \ + .unicode_object = { \ + .size = sizeof(PyUnicodeObject), \ + .state = offsetof(PyUnicodeObject, _base._base.state), \ + .length = offsetof(PyUnicodeObject, _base._base.length), \ + .asciiobject_size = sizeof(PyASCIIObject), \ + }, \ + .gc = { \ + .size = sizeof(struct _gc_runtime_state), \ + .collecting = offsetof(struct _gc_runtime_state, collecting), \ + }, \ + .gen_object = { \ + .size = sizeof(PyGenObject), \ + .gi_name = offsetof(PyGenObject, gi_name), \ + .gi_iframe = offsetof(PyGenObject, gi_iframe), \ + .gi_frame_state = offsetof(PyGenObject, gi_frame_state), \ + }, \ + .llist_node = { \ + .next = offsetof(struct llist_node, next), \ + .prev = offsetof(struct llist_node, prev), \ + }, \ + .debugger_support = { \ + .eval_breaker = offsetof(PyThreadState, eval_breaker), \ + .remote_debugger_support = offsetof(PyThreadState, remote_debugger_support), \ + .remote_debugging_enabled = offsetof(PyInterpreterState, config.remote_debug), \ + .debugger_pending_call = offsetof(_PyRemoteDebuggerSupport, debugger_pending_call), \ + .debugger_script_path = offsetof(_PyRemoteDebuggerSupport, debugger_script_path), \ + .debugger_script_path_size = _Py_MAX_SCRIPT_PATH_SIZE, \ + }, \ +} + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_DEBUG_OFFSETS_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_descrobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_descrobject.h new file mode 100644 index 0000000000000000000000000000000000000000..3cec59a68a3d2b2af5320fe1435c13a4aa66886c --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_descrobject.h @@ -0,0 +1,28 @@ +#ifndef Py_INTERNAL_DESCROBJECT_H +#define Py_INTERNAL_DESCROBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +typedef struct { + PyObject_HEAD + PyObject *prop_get; + PyObject *prop_set; + PyObject *prop_del; + PyObject *prop_doc; + PyObject *prop_name; + int getter_doc; +} propertyobject; + +typedef propertyobject _PyPropertyObject; + +extern PyTypeObject _PyMethodWrapper_Type; + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_DESCROBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_dict.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_dict.h new file mode 100644 index 0000000000000000000000000000000000000000..cfdc63f4d919a37d4e3031b611572a398fc195e2 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_dict.h @@ -0,0 +1,412 @@ +#ifndef Py_INTERNAL_DICT_H +#define Py_INTERNAL_DICT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_object.h" // PyManagedDictPointer +#include "pycore_pyatomic_ft_wrappers.h" // FT_ATOMIC_LOAD_SSIZE_ACQUIRE +#include "pycore_stackref.h" // _PyStackRef +#include "pycore_stats.h" + +// Unsafe flavor of PyDict_GetItemWithError(): no error checking +extern PyObject* _PyDict_GetItemWithError(PyObject *dp, PyObject *key); + +// Delete an item from a dict if a predicate is true +// Returns -1 on error, 1 if the item was deleted, 0 otherwise +// Export for '_asyncio' shared extension +PyAPI_FUNC(int) _PyDict_DelItemIf(PyObject *mp, PyObject *key, + int (*predicate)(PyObject *value, void *arg), + void *arg); + +// "KnownHash" variants +// Export for '_asyncio' shared extension +PyAPI_FUNC(int) _PyDict_SetItem_KnownHash(PyObject *mp, PyObject *key, + PyObject *item, Py_hash_t hash); +// Export for '_asyncio' shared extension +PyAPI_FUNC(int) _PyDict_DelItem_KnownHash(PyObject *mp, PyObject *key, + Py_hash_t hash); + +extern int _PyDict_DelItem_KnownHash_LockHeld(PyObject *mp, PyObject *key, + Py_hash_t hash); + +extern int _PyDict_Contains_KnownHash(PyObject *, PyObject *, Py_hash_t); + +// "Id" variants +extern PyObject* _PyDict_GetItemIdWithError(PyObject *dp, + _Py_Identifier *key); +extern int _PyDict_ContainsId(PyObject *, _Py_Identifier *); +extern int _PyDict_SetItemId(PyObject *dp, _Py_Identifier *key, PyObject *item); +extern int _PyDict_DelItemId(PyObject *mp, _Py_Identifier *key); + +extern int _PyDict_Next( + PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value, Py_hash_t *hash); + +extern int _PyDict_HasOnlyStringKeys(PyObject *mp); + +// Export for '_ctypes' shared extension +PyAPI_FUNC(Py_ssize_t) _PyDict_SizeOf(PyDictObject *); + +extern Py_ssize_t _PyDict_SizeOf_LockHeld(PyDictObject *); + +#define _PyDict_HasSplitTable(d) ((d)->ma_values != NULL) + +/* Like PyDict_Merge, but override can be 0, 1 or 2. If override is 0, + the first occurrence of a key wins, if override is 1, the last occurrence + of a key wins, if override is 2, a KeyError with conflicting key as + argument is raised. +*/ +PyAPI_FUNC(int) _PyDict_MergeEx(PyObject *mp, PyObject *other, int override); + +extern void _PyDict_DebugMallocStats(FILE *out); + + +/* _PyDictView */ + +typedef struct { + PyObject_HEAD + PyDictObject *dv_dict; +} _PyDictViewObject; + +extern PyObject* _PyDictView_New(PyObject *, PyTypeObject *); +extern PyObject* _PyDictView_Intersect(PyObject* self, PyObject *other); + +/* other API */ + +typedef struct { + /* Cached hash code of me_key. */ + Py_hash_t me_hash; + PyObject *me_key; + PyObject *me_value; /* This field is only meaningful for combined tables */ +} PyDictKeyEntry; + +typedef struct { + PyObject *me_key; /* The key must be Unicode and have hash. */ + PyObject *me_value; /* This field is only meaningful for combined tables */ +} PyDictUnicodeEntry; + +extern PyDictKeysObject *_PyDict_NewKeysForClass(PyHeapTypeObject *); +extern PyObject *_PyDict_FromKeys(PyObject *, PyObject *, PyObject *); + +/* Gets a version number unique to the current state of the keys of dict, if possible. + * Returns the version number, or zero if it was not possible to get a version number. */ +extern uint32_t _PyDictKeys_GetVersionForCurrentState( + PyInterpreterState *interp, PyDictKeysObject *dictkeys); + +/* Gets a version number unique to the current state of the keys of dict, if possible. + * + * In free-threaded builds ensures that the dict can be used for lock-free + * reads if a version was assigned. + * + * The caller must hold the per-object lock on dict. + * + * Returns the version number, or zero if it was not possible to get a version number. */ +extern uint32_t _PyDict_GetKeysVersionForCurrentState( + PyInterpreterState *interp, PyDictObject *dict); + +extern size_t _PyDict_KeysSize(PyDictKeysObject *keys); + +extern void _PyDictKeys_DecRef(PyDictKeysObject *keys); + +/* _Py_dict_lookup() returns index of entry which can be used like DK_ENTRIES(dk)[index]. + * -1 when no entry found, -3 when compare raises error. + */ +extern Py_ssize_t _Py_dict_lookup(PyDictObject *mp, PyObject *key, Py_hash_t hash, PyObject **value_addr); +extern Py_ssize_t _Py_dict_lookup_threadsafe(PyDictObject *mp, PyObject *key, Py_hash_t hash, PyObject **value_addr); +extern Py_ssize_t _Py_dict_lookup_threadsafe_stackref(PyDictObject *mp, PyObject *key, Py_hash_t hash, _PyStackRef *value_addr); + +extern int _PyDict_GetMethodStackRef(PyDictObject *dict, PyObject *name, _PyStackRef *method); + +extern Py_ssize_t _PyDict_LookupIndex(PyDictObject *, PyObject *); +extern Py_ssize_t _PyDictKeys_StringLookup(PyDictKeysObject* dictkeys, PyObject *key); + +/* Look up a string key in an all unicode dict keys, assign the keys object a version, and + * store it in version. + * + * Returns DKIX_ERROR if key is not a string or if the keys object is not all + * strings. + * + * Returns DKIX_EMPTY if the key is not present. + */ +extern Py_ssize_t _PyDictKeys_StringLookupAndVersion(PyDictKeysObject* dictkeys, PyObject *key, uint32_t *version); +extern Py_ssize_t _PyDictKeys_StringLookupSplit(PyDictKeysObject* dictkeys, PyObject *key); +PyAPI_FUNC(PyObject *)_PyDict_LoadGlobal(PyDictObject *, PyDictObject *, PyObject *); +PyAPI_FUNC(void) _PyDict_LoadGlobalStackRef(PyDictObject *, PyDictObject *, PyObject *, _PyStackRef *); + +// Loads the __builtins__ object from the globals dict. Returns a new reference. +extern PyObject *_PyDict_LoadBuiltinsFromGlobals(PyObject *globals); + +/* Consumes references to key and value */ +PyAPI_FUNC(int) _PyDict_SetItem_Take2(PyDictObject *op, PyObject *key, PyObject *value); +extern int _PyDict_SetItem_LockHeld(PyDictObject *dict, PyObject *name, PyObject *value); +// Export for '_asyncio' shared extension +PyAPI_FUNC(int) _PyDict_SetItem_KnownHash_LockHeld(PyDictObject *mp, PyObject *key, + PyObject *value, Py_hash_t hash); +// Export for '_asyncio' shared extension +PyAPI_FUNC(int) _PyDict_GetItemRef_KnownHash_LockHeld(PyDictObject *op, PyObject *key, Py_hash_t hash, PyObject **result); +extern int _PyDict_GetItemRef_KnownHash(PyDictObject *op, PyObject *key, Py_hash_t hash, PyObject **result); +extern int _PyDict_GetItemRef_Unicode_LockHeld(PyDictObject *op, PyObject *key, PyObject **result); +extern int _PyObjectDict_SetItem(PyTypeObject *tp, PyObject *obj, PyObject **dictptr, PyObject *name, PyObject *value); + +extern int _PyDict_Pop_KnownHash( + PyDictObject *dict, + PyObject *key, + Py_hash_t hash, + PyObject **result); + +extern void _PyDict_Clear_LockHeld(PyObject *op); + +#ifdef Py_GIL_DISABLED +PyAPI_FUNC(void) _PyDict_EnsureSharedOnRead(PyDictObject *mp); +#endif + +#define DKIX_EMPTY (-1) +#define DKIX_DUMMY (-2) /* Used internally */ +#define DKIX_ERROR (-3) +#define DKIX_KEY_CHANGED (-4) /* Used internally */ + +typedef enum { + DICT_KEYS_GENERAL = 0, + DICT_KEYS_UNICODE = 1, + DICT_KEYS_SPLIT = 2 +} DictKeysKind; + +/* See dictobject.c for actual layout of DictKeysObject */ +struct _dictkeysobject { + Py_ssize_t dk_refcnt; + + /* Size of the hash table (dk_indices). It must be a power of 2. */ + uint8_t dk_log2_size; + + /* Size of the hash table (dk_indices) by bytes. */ + uint8_t dk_log2_index_bytes; + + /* Kind of keys */ + uint8_t dk_kind; + +#ifdef Py_GIL_DISABLED + /* Lock used to protect shared keys */ + PyMutex dk_mutex; +#endif + + /* Version number -- Reset to 0 by any modification to keys */ + uint32_t dk_version; + + /* Number of usable entries in dk_entries. */ + Py_ssize_t dk_usable; + + /* Number of used entries in dk_entries. */ + Py_ssize_t dk_nentries; + + + /* Actual hash table of dk_size entries. It holds indices in dk_entries, + or DKIX_EMPTY(-1) or DKIX_DUMMY(-2). + + Indices must be: 0 <= indice < USABLE_FRACTION(dk_size). + + The size in bytes of an indice depends on dk_size: + + - 1 byte if dk_size <= 0xff (char*) + - 2 bytes if dk_size <= 0xffff (int16_t*) + - 4 bytes if dk_size <= 0xffffffff (int32_t*) + - 8 bytes otherwise (int64_t*) + + Dynamically sized, SIZEOF_VOID_P is minimum. */ + char dk_indices[]; /* char is required to avoid strict aliasing. */ + + /* "PyDictKeyEntry or PyDictUnicodeEntry dk_entries[USABLE_FRACTION(DK_SIZE(dk))];" array follows: + see the DK_ENTRIES() / DK_UNICODE_ENTRIES() functions below */ +}; + +/* This must be no more than 250, for the prefix size to fit in one byte. */ +#define SHARED_KEYS_MAX_SIZE 30 +#define NEXT_LOG2_SHARED_KEYS_MAX_SIZE 6 + +/* Layout of dict values: + * + * The PyObject *values are preceded by an array of bytes holding + * the insertion order and size. + * [-1] = prefix size. [-2] = used size. size[-2-n...] = insertion order. + */ +struct _dictvalues { + uint8_t capacity; + uint8_t size; + uint8_t embedded; + uint8_t valid; + PyObject *values[1]; +}; + +#define DK_LOG_SIZE(dk) _Py_RVALUE((dk)->dk_log2_size) +#if SIZEOF_VOID_P > 4 +#define DK_SIZE(dk) (((int64_t)1)<dk_indices); + size_t index = (size_t)1 << dk->dk_log2_index_bytes; + return (&indices[index]); +} + +static inline PyDictKeyEntry* DK_ENTRIES(PyDictKeysObject *dk) { + assert(dk->dk_kind == DICT_KEYS_GENERAL); + return (PyDictKeyEntry*)_DK_ENTRIES(dk); +} +static inline PyDictUnicodeEntry* DK_UNICODE_ENTRIES(PyDictKeysObject *dk) { + assert(dk->dk_kind != DICT_KEYS_GENERAL); + return (PyDictUnicodeEntry*)_DK_ENTRIES(dk); +} + +#define DK_IS_UNICODE(dk) ((dk)->dk_kind != DICT_KEYS_GENERAL) + +#define DICT_VERSION_INCREMENT (1 << (DICT_MAX_WATCHERS + DICT_WATCHED_MUTATION_BITS)) +#define DICT_WATCHER_MASK ((1 << DICT_MAX_WATCHERS) - 1) +#define DICT_WATCHER_AND_MODIFICATION_MASK ((1 << (DICT_MAX_WATCHERS + DICT_WATCHED_MUTATION_BITS)) - 1) +#define DICT_UNIQUE_ID_SHIFT (32) +#define DICT_UNIQUE_ID_MAX ((UINT64_C(1) << (64 - DICT_UNIQUE_ID_SHIFT)) - 1) + + +PyAPI_FUNC(void) +_PyDict_SendEvent(int watcher_bits, + PyDict_WatchEvent event, + PyDictObject *mp, + PyObject *key, + PyObject *value); + +static inline void +_PyDict_NotifyEvent(PyInterpreterState *interp, + PyDict_WatchEvent event, + PyDictObject *mp, + PyObject *key, + PyObject *value) +{ + assert(Py_REFCNT((PyObject*)mp) > 0); + int watcher_bits = mp->_ma_watcher_tag & DICT_WATCHER_MASK; + if (watcher_bits) { + RARE_EVENT_STAT_INC(watched_dict_modification); + _PyDict_SendEvent(watcher_bits, event, mp, key, value); + } +} + +extern PyDictObject *_PyObject_MaterializeManagedDict(PyObject *obj); + +PyAPI_FUNC(PyObject *)_PyDict_FromItems( + PyObject *const *keys, Py_ssize_t keys_offset, + PyObject *const *values, Py_ssize_t values_offset, + Py_ssize_t length); + +static inline uint8_t * +get_insertion_order_array(PyDictValues *values) +{ + return (uint8_t *)&values->values[values->capacity]; +} + +static inline void +_PyDictValues_AddToInsertionOrder(PyDictValues *values, Py_ssize_t ix) +{ + assert(ix < SHARED_KEYS_MAX_SIZE); + int size = values->size; + uint8_t *array = get_insertion_order_array(values); + assert(size < values->capacity); + assert(((uint8_t)ix) == ix); + array[size] = (uint8_t)ix; + values->size = size+1; +} + +static inline size_t +shared_keys_usable_size(PyDictKeysObject *keys) +{ + // dk_usable will decrease for each instance that is created and each + // value that is added. dk_nentries will increase for each value that + // is added. We want to always return the right value or larger. + // We therefore increase dk_nentries first and we decrease dk_usable + // second, and conversely here we read dk_usable first and dk_entries + // second (to avoid the case where we read entries before the increment + // and read usable after the decrement) + Py_ssize_t dk_usable = FT_ATOMIC_LOAD_SSIZE_ACQUIRE(keys->dk_usable); + Py_ssize_t dk_nentries = FT_ATOMIC_LOAD_SSIZE_ACQUIRE(keys->dk_nentries); + return dk_nentries + dk_usable; +} + +static inline size_t +_PyInlineValuesSize(PyTypeObject *tp) +{ + PyDictKeysObject *keys = ((PyHeapTypeObject*)tp)->ht_cached_keys; + assert(keys != NULL); + size_t size = shared_keys_usable_size(keys); + size_t prefix_size = _Py_SIZE_ROUND_UP(size, sizeof(PyObject *)); + assert(prefix_size < 256); + return prefix_size + (size + 1) * sizeof(PyObject *); +} + +int +_PyDict_DetachFromObject(PyDictObject *dict, PyObject *obj); + +// Enables per-thread ref counting on this dict in the free threading build +extern void _PyDict_EnablePerThreadRefcounting(PyObject *op); + +PyDictObject *_PyObject_MaterializeManagedDict_LockHeld(PyObject *); + +// See `_Py_INCREF_TYPE()` in pycore_object.h +#ifndef Py_GIL_DISABLED +# define _Py_INCREF_DICT Py_INCREF +# define _Py_DECREF_DICT Py_DECREF +# define _Py_INCREF_BUILTINS Py_INCREF +# define _Py_DECREF_BUILTINS Py_DECREF +#else +static inline Py_ssize_t +_PyDict_UniqueId(PyDictObject *mp) +{ + return (Py_ssize_t)(mp->_ma_watcher_tag >> DICT_UNIQUE_ID_SHIFT); +} + +static inline void +_Py_INCREF_DICT(PyObject *op) +{ + assert(PyDict_Check(op)); + Py_ssize_t id = _PyDict_UniqueId((PyDictObject *)op); + _Py_THREAD_INCREF_OBJECT(op, id); +} + +static inline void +_Py_DECREF_DICT(PyObject *op) +{ + assert(PyDict_Check(op)); + Py_ssize_t id = _PyDict_UniqueId((PyDictObject *)op); + _Py_THREAD_DECREF_OBJECT(op, id); +} + +// Like `_Py_INCREF_DICT`, but also handles non-dict objects because builtins +// may not be a dict. +static inline void +_Py_INCREF_BUILTINS(PyObject *op) +{ + if (PyDict_CheckExact(op)) { + _Py_INCREF_DICT(op); + } + else { + Py_INCREF(op); + } +} + +static inline void +_Py_DECREF_BUILTINS(PyObject *op) +{ + if (PyDict_CheckExact(op)) { + _Py_DECREF_DICT(op); + } + else { + Py_DECREF(op); + } +} +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_DICT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_dict_state.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_dict_state.h new file mode 100644 index 0000000000000000000000000000000000000000..11932b8d1e1ab60d49d69693d00dc9cd80ae3fc4 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_dict_state.h @@ -0,0 +1,28 @@ +#ifndef Py_INTERNAL_DICT_STATE_H +#define Py_INTERNAL_DICT_STATE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#define DICT_MAX_WATCHERS 8 +#define DICT_WATCHED_MUTATION_BITS 4 + +struct _Py_dict_state { + uint32_t next_keys_version; + PyDict_WatchCallback watchers[DICT_MAX_WATCHERS]; +}; + +#define _dict_state_INIT \ + { \ + .next_keys_version = 2, \ + } + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_DICT_STATE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_dtoa.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_dtoa.h new file mode 100644 index 0000000000000000000000000000000000000000..2e2e990a7e2d3850b236b94013e896fe2d96772e --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_dtoa.h @@ -0,0 +1,40 @@ +#ifndef Py_INTERNAL_DTOA_H +#define Py_INTERNAL_DTOA_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_pymath.h" // _PY_SHORT_FLOAT_REPR + + +#if defined(Py_USING_MEMORY_DEBUGGER) || _PY_SHORT_FLOAT_REPR == 0 + +#define _dtoa_state_INIT(INTERP) \ + {0} + +#else + +#define _dtoa_state_INIT(INTERP) \ + { \ + .preallocated_next = (INTERP)->dtoa.preallocated, \ + } +#endif + +extern double _Py_dg_strtod(const char *str, char **ptr); +extern char* _Py_dg_dtoa(double d, int mode, int ndigits, + int *decpt, int *sign, char **rve); +extern void _Py_dg_freedtoa(char *s); + + +extern PyStatus _PyDtoa_Init(PyInterpreterState *interp); +extern void _PyDtoa_Fini(PyInterpreterState *interp); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_DTOA_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_emscripten_signal.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_emscripten_signal.h new file mode 100644 index 0000000000000000000000000000000000000000..754193e21dec5a5608200d4302bbfc6c6b1e7eb1 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_emscripten_signal.h @@ -0,0 +1,30 @@ +#ifndef Py_EMSCRIPTEN_SIGNAL_H +#define Py_EMSCRIPTEN_SIGNAL_H + +#if defined(__EMSCRIPTEN__) + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +void +_Py_CheckEmscriptenSignals(void); + +void +_Py_CheckEmscriptenSignalsPeriodically(void); + +#define _Py_CHECK_EMSCRIPTEN_SIGNALS() _Py_CheckEmscriptenSignals() + +#define _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY() _Py_CheckEmscriptenSignalsPeriodically() + +extern int Py_EMSCRIPTEN_SIGNAL_HANDLING; +extern int _Py_emscripten_signal_clock; + +#else + +#define _Py_CHECK_EMSCRIPTEN_SIGNALS() +#define _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY() + +#endif // defined(__EMSCRIPTEN__) + +#endif // ndef Py_EMSCRIPTEN_SIGNAL_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_emscripten_trampoline.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_emscripten_trampoline.h new file mode 100644 index 0000000000000000000000000000000000000000..e37c53a64f4a72347406208084f4acb994467c95 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_emscripten_trampoline.h @@ -0,0 +1,67 @@ +#ifndef Py_EMSCRIPTEN_TRAMPOLINE_H +#define Py_EMSCRIPTEN_TRAMPOLINE_H + +#include "pycore_typedefs.h" // _PyRuntimeState + +/** + * C function call trampolines to mitigate bad function pointer casts. + * + * Section 6.3.2.3, paragraph 8 reads: + * + * A pointer to a function of one type may be converted to a pointer to a + * function of another type and back again; the result shall compare equal to + * the original pointer. If a converted pointer is used to call a function + * whose type is not compatible with the pointed-to type, the behavior is + * undefined. + * + * Typical native ABIs ignore additional arguments or fill in missing values + * with 0/NULL in function pointer cast. Compilers do not show warnings when a + * function pointer is explicitly casted to an incompatible type. + * + * Bad fpcasts are an issue in WebAssembly. WASM's indirect_call has strict + * function signature checks. Argument count, types, and return type must match. + * + * Third party code unintentionally rely on problematic fpcasts. The call + * trampoline mitigates common occurrences of bad fpcasts on Emscripten. + */ + +#if defined(__EMSCRIPTEN__) && defined(PY_CALL_TRAMPOLINE) + +PyObject* +_PyEM_TrampolineCall(PyCFunctionWithKeywords func, + PyObject* self, + PyObject* args, + PyObject* kw); + +#define _PyCFunction_TrampolineCall(meth, self, args) \ + _PyEM_TrampolineCall(*_PyCFunctionWithKeywords_CAST(meth), (self), (args), NULL) + +#define _PyCFunctionWithKeywords_TrampolineCall(meth, self, args, kw) \ + _PyEM_TrampolineCall((meth), (self), (args), (kw)) + +#define descr_set_trampoline_call(set, obj, value, closure) \ + ((int)_PyEM_TrampolineCall(_PyCFunctionWithKeywords_CAST(set), (obj), \ + (value), (PyObject*)(closure))) + +#define descr_get_trampoline_call(get, obj, closure) \ + _PyEM_TrampolineCall(_PyCFunctionWithKeywords_CAST(get), (obj), \ + (PyObject*)(closure), NULL) + + +#else // defined(__EMSCRIPTEN__) && defined(PY_CALL_TRAMPOLINE) + +#define _PyCFunction_TrampolineCall(meth, self, args) \ + (meth)((self), (args)) + +#define _PyCFunctionWithKeywords_TrampolineCall(meth, self, args, kw) \ + (meth)((self), (args), (kw)) + +#define descr_set_trampoline_call(set, obj, value, closure) \ + (set)((obj), (value), (closure)) + +#define descr_get_trampoline_call(get, obj, closure) \ + (get)((obj), (closure)) + +#endif // defined(__EMSCRIPTEN__) && defined(PY_CALL_TRAMPOLINE) + +#endif // ndef Py_EMSCRIPTEN_SIGNAL_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_exceptions.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_exceptions.h new file mode 100644 index 0000000000000000000000000000000000000000..26456d1966bbb0eb6a7becedabe8054d49d8dac7 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_exceptions.h @@ -0,0 +1,40 @@ +#ifndef Py_INTERNAL_EXCEPTIONS_H +#define Py_INTERNAL_EXCEPTIONS_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + + +/* runtime lifecycle */ + +extern PyStatus _PyExc_InitState(PyInterpreterState *); +extern PyStatus _PyExc_InitGlobalObjects(PyInterpreterState *); +extern int _PyExc_InitTypes(PyInterpreterState *); +extern void _PyExc_Fini(PyInterpreterState *); + + +/* other API */ + +struct _Py_exc_state { + // The dict mapping from errno codes to OSError subclasses + PyObject *errnomap; + PyBaseExceptionObject *memerrors_freelist; + int memerrors_numfree; +#ifdef Py_GIL_DISABLED + PyMutex memerrors_lock; +#endif + // The ExceptionGroup type + PyObject *PyExc_ExceptionGroup; +}; + +extern void _PyExc_ClearExceptionGroupType(PyInterpreterState *); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_EXCEPTIONS_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_faulthandler.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_faulthandler.h new file mode 100644 index 0000000000000000000000000000000000000000..78cd657e6ae5aee543f8840d3e7402d55cae4689 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_faulthandler.h @@ -0,0 +1,100 @@ +#ifndef Py_INTERNAL_FAULTHANDLER_H +#define Py_INTERNAL_FAULTHANDLER_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#ifdef HAVE_SIGACTION +# include // sigaction +#endif + + +#ifndef MS_WINDOWS + /* register() is useless on Windows, because only SIGSEGV, SIGABRT and + SIGILL can be handled by the process, and these signals can only be used + with enable(), not using register() */ +# define FAULTHANDLER_USER +#endif + + +#ifdef HAVE_SIGACTION +/* Using an alternative stack requires sigaltstack() + and sigaction() SA_ONSTACK */ +# ifdef HAVE_SIGALTSTACK +# define FAULTHANDLER_USE_ALT_STACK +# endif +typedef struct sigaction _Py_sighandler_t; +#else +typedef PyOS_sighandler_t _Py_sighandler_t; +#endif // HAVE_SIGACTION + + +#ifdef FAULTHANDLER_USER +struct faulthandler_user_signal { + int enabled; + PyObject *file; + int fd; + int all_threads; + int chain; + _Py_sighandler_t previous; + PyInterpreterState *interp; +}; +#endif /* FAULTHANDLER_USER */ + + +struct _faulthandler_runtime_state { + struct { + int enabled; + PyObject *file; + int fd; + int all_threads; + PyInterpreterState *interp; +#ifdef MS_WINDOWS + void *exc_handler; +#endif + int c_stack; + } fatal_error; + + struct { + PyObject *file; + int fd; + PY_TIMEOUT_T timeout_us; /* timeout in microseconds */ + int repeat; + PyInterpreterState *interp; + int exit; + char *header; + size_t header_len; + /* The main thread always holds this lock. It is only released when + faulthandler_thread() is interrupted before this thread exits, or at + Python exit. */ + PyThread_type_lock cancel_event; + /* released by child thread when joined */ + PyThread_type_lock running; + } thread; + +#ifdef FAULTHANDLER_USER + struct faulthandler_user_signal *user_signals; +#endif + +#ifdef FAULTHANDLER_USE_ALT_STACK + stack_t stack; + stack_t old_stack; +#endif +}; + +#define _faulthandler_runtime_state_INIT \ + { \ + .fatal_error = { \ + .fd = -1, \ + }, \ + } + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_FAULTHANDLER_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_fileutils.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_fileutils.h new file mode 100644 index 0000000000000000000000000000000000000000..2c6d6daa01994ee6465d6827c93d22d2596bd0d1 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_fileutils.h @@ -0,0 +1,320 @@ +#ifndef Py_INTERNAL_FILEUTILS_H +#define Py_INTERNAL_FILEUTILS_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include // struct lconv +#include "pycore_interp_structs.h" // _Py_error_handler + + +/* A routine to check if a file descriptor can be select()-ed. */ +#ifdef _MSC_VER + /* On Windows, any socket fd can be select()-ed, no matter how high */ + #define _PyIsSelectable_fd(FD) (1) +#else + #define _PyIsSelectable_fd(FD) ((unsigned int)(FD) < (unsigned int)FD_SETSIZE) +#endif + +// Export for '_testinternalcapi' shared extension +PyAPI_FUNC(_Py_error_handler) _Py_GetErrorHandler(const char *errors); + +// Export for '_testinternalcapi' shared extension +PyAPI_FUNC(int) _Py_DecodeLocaleEx( + const char *arg, + wchar_t **wstr, + size_t *wlen, + const char **reason, + int current_locale, + _Py_error_handler errors); + +// Export for '_testinternalcapi' shared extension +PyAPI_FUNC(int) _Py_EncodeLocaleEx( + const wchar_t *text, + char **str, + size_t *error_pos, + const char **reason, + int current_locale, + _Py_error_handler errors); + +extern char* _Py_EncodeLocaleRaw( + const wchar_t *text, + size_t *error_pos); + +extern PyObject* _Py_device_encoding(int); + +#if defined(MS_WINDOWS) || defined(__APPLE__) + /* On Windows, the count parameter of read() is an int (bpo-9015, bpo-9611). + On macOS 10.13, read() and write() with more than INT_MAX bytes + fail with EINVAL (bpo-24658). */ +# define _PY_READ_MAX INT_MAX +# define _PY_WRITE_MAX INT_MAX +#else + /* write() should truncate the input to PY_SSIZE_T_MAX bytes, + but it's safer to do it ourself to have a portable behaviour */ +# define _PY_READ_MAX PY_SSIZE_T_MAX +# define _PY_WRITE_MAX PY_SSIZE_T_MAX +#endif + +#ifdef MS_WINDOWS +struct _Py_stat_struct { + uint64_t st_dev; + uint64_t st_ino; + unsigned short st_mode; + int st_nlink; + int st_uid; + int st_gid; + unsigned long st_rdev; + __int64 st_size; + time_t st_atime; + int st_atime_nsec; + time_t st_mtime; + int st_mtime_nsec; + time_t st_ctime; + int st_ctime_nsec; + time_t st_birthtime; + int st_birthtime_nsec; + unsigned long st_file_attributes; + unsigned long st_reparse_tag; + uint64_t st_ino_high; +}; +#else +# define _Py_stat_struct stat +#endif + +// Export for 'mmap' shared extension +PyAPI_FUNC(int) _Py_fstat( + int fd, + struct _Py_stat_struct *status); + +// Export for 'mmap' shared extension +PyAPI_FUNC(int) _Py_fstat_noraise( + int fd, + struct _Py_stat_struct *status); + +// Export for '_tkinter' shared extension +PyAPI_FUNC(int) _Py_stat( + PyObject *path, + struct stat *status); + +// Export for 'select' shared extension (Solaris newDevPollObject()) +PyAPI_FUNC(int) _Py_open( + const char *pathname, + int flags); + +// Export for '_posixsubprocess' shared extension +PyAPI_FUNC(int) _Py_open_noraise( + const char *pathname, + int flags); + +extern FILE* _Py_wfopen( + const wchar_t *path, + const wchar_t *mode); + +extern Py_ssize_t _Py_read( + int fd, + void *buf, + size_t count); + +// Export for 'select' shared extension (Solaris devpoll_flush()) +PyAPI_FUNC(Py_ssize_t) _Py_write( + int fd, + const void *buf, + size_t count); + +// Export for '_posixsubprocess' shared extension +PyAPI_FUNC(Py_ssize_t) _Py_write_noraise( + int fd, + const void *buf, + size_t count); + +#ifdef HAVE_READLINK +extern int _Py_wreadlink( + const wchar_t *path, + wchar_t *buf, + /* Number of characters of 'buf' buffer + including the trailing NUL character */ + size_t buflen); +#endif + +#ifdef HAVE_REALPATH +extern wchar_t* _Py_wrealpath( + const wchar_t *path, + wchar_t *resolved_path, + /* Number of characters of 'resolved_path' buffer + including the trailing NUL character */ + size_t resolved_path_len); +#endif + +extern wchar_t* _Py_wgetcwd( + wchar_t *buf, + /* Number of characters of 'buf' buffer + including the trailing NUL character */ + size_t buflen); + +extern int _Py_get_inheritable(int fd); + +// Export for '_socket' shared extension +PyAPI_FUNC(int) _Py_set_inheritable(int fd, int inheritable, + int *atomic_flag_works); + +// Export for '_posixsubprocess' shared extension +PyAPI_FUNC(int) _Py_set_inheritable_async_safe(int fd, int inheritable, + int *atomic_flag_works); + +// Export for '_socket' shared extension +PyAPI_FUNC(int) _Py_dup(int fd); + +extern int _Py_get_blocking(int fd); + +extern int _Py_set_blocking(int fd, int blocking); + +#ifdef MS_WINDOWS +extern void* _Py_get_osfhandle_noraise(int fd); + +// Export for '_testconsole' shared extension +PyAPI_FUNC(void*) _Py_get_osfhandle(int fd); + +extern int _Py_open_osfhandle_noraise(void *handle, int flags); + +extern int _Py_open_osfhandle(void *handle, int flags); +#endif /* MS_WINDOWS */ + +// This is used after getting NULL back from Py_DecodeLocale(). +#define DECODE_LOCALE_ERR(NAME, LEN) \ + ((LEN) == (size_t)-2) \ + ? _PyStatus_ERR("cannot decode " NAME) \ + : _PyStatus_NO_MEMORY() + +extern int _Py_HasFileSystemDefaultEncodeErrors; + +extern int _Py_DecodeUTF8Ex( + const char *arg, + Py_ssize_t arglen, + wchar_t **wstr, + size_t *wlen, + const char **reason, + _Py_error_handler errors); + +extern int _Py_EncodeUTF8Ex( + const wchar_t *text, + char **str, + size_t *error_pos, + const char **reason, + int raw_malloc, + _Py_error_handler errors); + +extern wchar_t* _Py_DecodeUTF8_surrogateescape( + const char *arg, + Py_ssize_t arglen, + size_t *wlen); + +extern int +_Py_wstat(const wchar_t *, struct stat *); + +extern int _Py_GetForceASCII(void); + +/* Reset "force ASCII" mode (if it was initialized). + + This function should be called when Python changes the LC_CTYPE locale, + so the "force ASCII" mode can be detected again on the new locale + encoding. */ +extern void _Py_ResetForceASCII(void); + + +extern int _Py_GetLocaleconvNumeric( + struct lconv *lc, + PyObject **decimal_point, + PyObject **thousands_sep); + +// Export for '_posixsubprocess' (on macOS) +PyAPI_FUNC(void) _Py_closerange(int first, int last); + +extern wchar_t* _Py_GetLocaleEncoding(void); +extern PyObject* _Py_GetLocaleEncodingObject(void); + +#ifdef HAVE_NON_UNICODE_WCHAR_T_REPRESENTATION +extern int _Py_LocaleUsesNonUnicodeWchar(void); + +extern wchar_t* _Py_DecodeNonUnicodeWchar( + const wchar_t* native, + Py_ssize_t size); + +extern int _Py_EncodeNonUnicodeWchar_InPlace( + wchar_t* unicode, + Py_ssize_t size); +#endif + +extern int _Py_isabs(const wchar_t *path); +extern int _Py_abspath(const wchar_t *path, wchar_t **abspath_p); +#ifdef MS_WINDOWS +extern int _PyOS_getfullpathname(const wchar_t *path, wchar_t **abspath_p); +#endif +extern wchar_t* _Py_join_relfile(const wchar_t *dirname, + const wchar_t *relfile); +extern int _Py_add_relfile(wchar_t *dirname, + const wchar_t *relfile, + size_t bufsize); +extern size_t _Py_find_basename(const wchar_t *filename); + +// Export for '_testinternalcapi' shared extension +PyAPI_FUNC(wchar_t*) _Py_normpath(wchar_t *path, Py_ssize_t size); + +extern wchar_t *_Py_normpath_and_size(wchar_t *path, Py_ssize_t size, Py_ssize_t *length); + +// The Windows Games API family does not provide these functions +// so provide our own implementations. Remove them in case they get added +// to the Games API family +#if defined(MS_WINDOWS_GAMES) && !defined(MS_WINDOWS_DESKTOP) +#include // HRESULT + +extern HRESULT PathCchSkipRoot(const wchar_t *pszPath, const wchar_t **ppszRootEnd); +#endif /* defined(MS_WINDOWS_GAMES) && !defined(MS_WINDOWS_DESKTOP) */ + +extern void _Py_skiproot(const wchar_t *path, Py_ssize_t size, Py_ssize_t *drvsize, Py_ssize_t *rootsize); + +// Macros to protect CRT calls against instant termination when passed an +// invalid parameter (bpo-23524). IPH stands for Invalid Parameter Handler. +// Usage: +// +// _Py_BEGIN_SUPPRESS_IPH +// ... +// _Py_END_SUPPRESS_IPH +#if defined _MSC_VER && _MSC_VER >= 1900 + +# include // _set_thread_local_invalid_parameter_handler() + + extern _invalid_parameter_handler _Py_silent_invalid_parameter_handler; +# define _Py_BEGIN_SUPPRESS_IPH \ + { _invalid_parameter_handler _Py_old_handler = \ + _set_thread_local_invalid_parameter_handler(_Py_silent_invalid_parameter_handler); +# define _Py_END_SUPPRESS_IPH \ + _set_thread_local_invalid_parameter_handler(_Py_old_handler); } +#else +# define _Py_BEGIN_SUPPRESS_IPH +# define _Py_END_SUPPRESS_IPH +#endif /* _MSC_VER >= 1900 */ + +// Export for 'select' shared extension (Argument Clinic code) +PyAPI_FUNC(int) _PyLong_FileDescriptor_Converter(PyObject *, void *); + +// Export for test_peg_generator +PyAPI_FUNC(char*) _Py_UniversalNewlineFgetsWithSize(char *, int, FILE*, PyObject *, size_t*); + +extern int _PyFile_Flush(PyObject *); + +#ifndef MS_WINDOWS +extern int _Py_GetTicksPerSecond(long *ticks_per_second); +#endif + +// Export for '_testcapi' shared extension +PyAPI_FUNC(int) _Py_IsValidFD(int fd); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_FILEUTILS_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_fileutils_windows.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_fileutils_windows.h new file mode 100644 index 0000000000000000000000000000000000000000..b79aa9fb4653765cb7f171ade2b1570b5c451e9d --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_fileutils_windows.h @@ -0,0 +1,98 @@ +#ifndef Py_INTERNAL_FILEUTILS_WINDOWS_H +#define Py_INTERNAL_FILEUTILS_WINDOWS_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#ifdef MS_WINDOWS + +#if !defined(NTDDI_WIN10_NI) || !(NTDDI_VERSION >= NTDDI_WIN10_NI) +typedef struct _FILE_STAT_BASIC_INFORMATION { + LARGE_INTEGER FileId; + LARGE_INTEGER CreationTime; + LARGE_INTEGER LastAccessTime; + LARGE_INTEGER LastWriteTime; + LARGE_INTEGER ChangeTime; + LARGE_INTEGER AllocationSize; + LARGE_INTEGER EndOfFile; + ULONG FileAttributes; + ULONG ReparseTag; + ULONG NumberOfLinks; + ULONG DeviceType; + ULONG DeviceCharacteristics; + ULONG Reserved; + LARGE_INTEGER VolumeSerialNumber; + FILE_ID_128 FileId128; +} FILE_STAT_BASIC_INFORMATION; + +typedef enum _FILE_INFO_BY_NAME_CLASS { + FileStatByNameInfo, + FileStatLxByNameInfo, + FileCaseSensitiveByNameInfo, + FileStatBasicByNameInfo, + MaximumFileInfoByNameClass +} FILE_INFO_BY_NAME_CLASS; +#endif + +typedef BOOL (WINAPI *PGetFileInformationByName)( + PCWSTR FileName, + FILE_INFO_BY_NAME_CLASS FileInformationClass, + PVOID FileInfoBuffer, + ULONG FileInfoBufferSize +); + +static inline BOOL _Py_GetFileInformationByName( + PCWSTR FileName, + FILE_INFO_BY_NAME_CLASS FileInformationClass, + PVOID FileInfoBuffer, + ULONG FileInfoBufferSize +) { + static PGetFileInformationByName GetFileInformationByName = NULL; + static int GetFileInformationByName_init = -1; + + if (GetFileInformationByName_init < 0) { + HMODULE hMod = LoadLibraryW(L"api-ms-win-core-file-l2-1-4"); + GetFileInformationByName_init = 0; + if (hMod) { + GetFileInformationByName = (PGetFileInformationByName)GetProcAddress( + hMod, "GetFileInformationByName"); + if (GetFileInformationByName) { + GetFileInformationByName_init = 1; + } else { + FreeLibrary(hMod); + } + } + } + + if (GetFileInformationByName_init <= 0) { + SetLastError(ERROR_NOT_SUPPORTED); + return FALSE; + } + return GetFileInformationByName(FileName, FileInformationClass, FileInfoBuffer, FileInfoBufferSize); +} + +static inline BOOL _Py_GetFileInformationByName_ErrorIsTrustworthy(int error) +{ + switch(error) { + case ERROR_FILE_NOT_FOUND: + case ERROR_PATH_NOT_FOUND: + case ERROR_NOT_READY: + case ERROR_BAD_NET_NAME: + case ERROR_BAD_NETPATH: + case ERROR_BAD_PATHNAME: + case ERROR_INVALID_NAME: + case ERROR_FILENAME_EXCED_RANGE: + return TRUE; + case ERROR_NOT_SUPPORTED: + return FALSE; + } + return FALSE; +} + +#endif + +#endif diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_floatobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_floatobject.h new file mode 100644 index 0000000000000000000000000000000000000000..317f984188bad83f31c21372693f251dfb9f0b67 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_floatobject.h @@ -0,0 +1,49 @@ +#ifndef Py_INTERNAL_FLOATOBJECT_H +#define Py_INTERNAL_FLOATOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_unicodeobject.h" // _PyUnicodeWriter + +/* runtime lifecycle */ + +extern void _PyFloat_InitState(PyInterpreterState *); +extern PyStatus _PyFloat_InitTypes(PyInterpreterState *); +extern void _PyFloat_FiniType(PyInterpreterState *); + + + + +PyAPI_FUNC(void) _PyFloat_ExactDealloc(PyObject *op); + + +extern void _PyFloat_DebugMallocStats(FILE* out); + + +/* Format the object based on the format_spec, as defined in PEP 3101 + (Advanced String Formatting). */ +extern int _PyFloat_FormatAdvancedWriter( + _PyUnicodeWriter *writer, + PyObject *obj, + PyObject *format_spec, + Py_ssize_t start, + Py_ssize_t end); + +extern PyObject* _Py_string_to_number_with_underscores( + const char *str, Py_ssize_t len, const char *what, PyObject *obj, void *arg, + PyObject *(*innerfunc)(const char *, Py_ssize_t, void *)); + +extern double _Py_parse_inf_or_nan(const char *p, char **endptr); + +extern int _Py_convert_int_to_double(PyObject **v, double *dbl); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_FLOATOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_flowgraph.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_flowgraph.h new file mode 100644 index 0000000000000000000000000000000000000000..5043260d2fd99f2a671a57915024c50df4dba0a7 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_flowgraph.h @@ -0,0 +1,47 @@ +#ifndef Py_INTERNAL_CFG_H +#define Py_INTERNAL_CFG_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_compile.h" +#include "pycore_instruction_sequence.h" +#include "pycore_opcode_utils.h" + +struct _PyCfgBuilder; + +int _PyCfgBuilder_UseLabel(struct _PyCfgBuilder *g, _PyJumpTargetLabel lbl); +int _PyCfgBuilder_Addop(struct _PyCfgBuilder *g, int opcode, int oparg, _Py_SourceLocation loc); + +struct _PyCfgBuilder* _PyCfgBuilder_New(void); +void _PyCfgBuilder_Free(struct _PyCfgBuilder *g); +int _PyCfgBuilder_CheckSize(struct _PyCfgBuilder* g); + +int _PyCfg_OptimizeCodeUnit(struct _PyCfgBuilder *g, PyObject *consts, PyObject *const_cache, + int nlocals, int nparams, int firstlineno); + +struct _PyCfgBuilder* _PyCfg_FromInstructionSequence(_PyInstructionSequence *seq); +int _PyCfg_ToInstructionSequence(struct _PyCfgBuilder *g, _PyInstructionSequence *seq); +int _PyCfg_OptimizedCfgToInstructionSequence(struct _PyCfgBuilder *g, _PyCompile_CodeUnitMetadata *umd, + int code_flags, int *stackdepth, int *nlocalsplus, + _PyInstructionSequence *seq); + +PyCodeObject * +_PyAssemble_MakeCodeObject(_PyCompile_CodeUnitMetadata *u, PyObject *const_cache, + PyObject *consts, int maxdepth, _PyInstructionSequence *instrs, + int nlocalsplus, int code_flags, PyObject *filename); + +// Export for '_testinternalcapi' shared extension +PyAPI_FUNC(PyObject*) _PyCompile_OptimizeCfg( + PyObject *instructions, + PyObject *consts, + int nlocals); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_CFG_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_format.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_format.h new file mode 100644 index 0000000000000000000000000000000000000000..1b8d57539ca505fbc56ecb2245785a8b37b85c9f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_format.h @@ -0,0 +1,27 @@ +#ifndef Py_INTERNAL_FORMAT_H +#define Py_INTERNAL_FORMAT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* Format codes + * F_LJUST '-' + * F_SIGN '+' + * F_BLANK ' ' + * F_ALT '#' + * F_ZERO '0' + */ +#define F_LJUST (1<<0) +#define F_SIGN (1<<1) +#define F_BLANK (1<<2) +#define F_ALT (1<<3) +#define F_ZERO (1<<4) + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_FORMAT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_frame.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_frame.h new file mode 100644 index 0000000000000000000000000000000000000000..8c410e9e2083407fd491138fadf84e9f12aa8d82 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_frame.h @@ -0,0 +1,61 @@ +/* See InternalDocs/frames.md for an explanation of the frame stack + * including explanation of the PyFrameObject and _PyInterpreterFrame + * structs. */ + +#ifndef Py_INTERNAL_FRAME_H +#define Py_INTERNAL_FRAME_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_typedefs.h" // _PyInterpreterFrame + + +struct _frame { + PyObject_HEAD + PyFrameObject *f_back; /* previous frame, or NULL */ + _PyInterpreterFrame *f_frame; /* points to the frame data */ + PyObject *f_trace; /* Trace function */ + int f_lineno; /* Current line number. Only valid if non-zero */ + char f_trace_lines; /* Emit per-line trace events? */ + char f_trace_opcodes; /* Emit per-opcode trace events? */ + PyObject *f_extra_locals; /* Dict for locals set by users using f_locals, could be NULL */ + /* This is purely for backwards compatibility for PyEval_GetLocals. + PyEval_GetLocals requires a borrowed reference so the actual reference + is stored here */ + PyObject *f_locals_cache; + /* A tuple containing strong references to fast locals that were overwritten + * via f_locals. Borrowed references to these locals may exist in frames + * closer to the top of the stack. The references in this tuple act as + * "support" for the borrowed references, ensuring that they remain valid. + */ + PyObject *f_overwritten_fast_locals; + /* The frame data, if this frame object owns the frame */ + PyObject *_f_frame_data[1]; +}; + +extern PyFrameObject* _PyFrame_New_NoTrack(PyCodeObject *code); + + +/* other API */ + +typedef enum _framestate { + FRAME_CREATED = -3, + FRAME_SUSPENDED = -2, + FRAME_SUSPENDED_YIELD_FROM = -1, + FRAME_EXECUTING = 0, + FRAME_COMPLETED = 1, + FRAME_CLEARED = 4 +} PyFrameState; + +#define FRAME_STATE_SUSPENDED(S) ((S) == FRAME_SUSPENDED || (S) == FRAME_SUSPENDED_YIELD_FROM) +#define FRAME_STATE_FINISHED(S) ((S) >= FRAME_COMPLETED) + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_FRAME_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_freelist.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_freelist.h new file mode 100644 index 0000000000000000000000000000000000000000..f3c9a669ad3512abfa3cfad4dcba6e1dc8266a58 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_freelist.h @@ -0,0 +1,111 @@ +#ifndef Py_INTERNAL_FREELIST_H +#define Py_INTERNAL_FREELIST_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_freelist_state.h" // struct _Py_freelists +#include "pycore_interp_structs.h" // PyInterpreterState +#include "pycore_pyatomic_ft_wrappers.h" // FT_ATOMIC_STORE_PTR_RELAXED() +#include "pycore_pystate.h" // _PyThreadState_GET +#include "pycore_stats.h" // OBJECT_STAT_INC + +static inline struct _Py_freelists * +_Py_freelists_GET(void) +{ + PyThreadState *tstate = _PyThreadState_GET(); +#ifdef Py_DEBUG + _Py_EnsureTstateNotNULL(tstate); +#endif + +#ifdef Py_GIL_DISABLED + return &((_PyThreadStateImpl*)tstate)->freelists; +#else + return &tstate->interp->object_state.freelists; +#endif +} + +// Pushes `op` to the freelist, calls `freefunc` if the freelist is full +#define _Py_FREELIST_FREE(NAME, op, freefunc) \ + _PyFreeList_Free(&_Py_freelists_GET()->NAME, _PyObject_CAST(op), \ + Py_ ## NAME ## _MAXFREELIST, freefunc) +// Pushes `op` to the freelist, returns 1 if successful, 0 if the freelist is full +#define _Py_FREELIST_PUSH(NAME, op, limit) \ + _PyFreeList_Push(&_Py_freelists_GET()->NAME, _PyObject_CAST(op), limit) + +// Pops a PyObject from the freelist, returns NULL if the freelist is empty. +#define _Py_FREELIST_POP(TYPE, NAME) \ + _Py_CAST(TYPE*, _PyFreeList_Pop(&_Py_freelists_GET()->NAME)) + +// Pops a non-PyObject data structure from the freelist, returns NULL if the +// freelist is empty. +#define _Py_FREELIST_POP_MEM(NAME) \ + _PyFreeList_PopMem(&_Py_freelists_GET()->NAME) + +#define _Py_FREELIST_SIZE(NAME) (int)((_Py_freelists_GET()->NAME).size) + +static inline int +_PyFreeList_Push(struct _Py_freelist *fl, void *obj, Py_ssize_t maxsize) +{ + if (fl->size < maxsize && fl->size >= 0) { + FT_ATOMIC_STORE_PTR_RELAXED(*(void **)obj, fl->freelist); + fl->freelist = obj; + fl->size++; + OBJECT_STAT_INC(to_freelist); + return 1; + } + return 0; +} + +static inline void +_PyFreeList_Free(struct _Py_freelist *fl, void *obj, Py_ssize_t maxsize, + freefunc dofree) +{ + if (!_PyFreeList_Push(fl, obj, maxsize)) { + dofree(obj); + } +} + +static inline void * +_PyFreeList_PopNoStats(struct _Py_freelist *fl) +{ + void *obj = fl->freelist; + if (obj != NULL) { + assert(fl->size > 0); + fl->freelist = *(void **)obj; + fl->size--; + } + return obj; +} + +static inline PyObject * +_PyFreeList_Pop(struct _Py_freelist *fl) +{ + PyObject *op = _PyFreeList_PopNoStats(fl); + if (op != NULL) { + OBJECT_STAT_INC(from_freelist); + _Py_NewReference(op); + } + return op; +} + +static inline void * +_PyFreeList_PopMem(struct _Py_freelist *fl) +{ + void *op = _PyFreeList_PopNoStats(fl); + if (op != NULL) { + OBJECT_STAT_INC(from_freelist); + } + return op; +} + +extern void _PyObject_ClearFreeLists(struct _Py_freelists *freelists, int is_finalization); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_FREELIST_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_freelist_state.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_freelist_state.h new file mode 100644 index 0000000000000000000000000000000000000000..4828dfd948f70ab2257d7acee52ac75b43c87a40 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_freelist_state.h @@ -0,0 +1,70 @@ +#ifndef Py_INTERNAL_FREELIST_STATE_H +#define Py_INTERNAL_FREELIST_STATE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +# define PyTuple_MAXSAVESIZE 20 // Largest tuple to save on freelist +# define Py_tuple_MAXFREELIST 2000 // Maximum number of tuples of each size to save +# define Py_lists_MAXFREELIST 80 +# define Py_list_iters_MAXFREELIST 10 +# define Py_tuple_iters_MAXFREELIST 10 +# define Py_dicts_MAXFREELIST 80 +# define Py_dictkeys_MAXFREELIST 80 +# define Py_floats_MAXFREELIST 100 +# define Py_ints_MAXFREELIST 100 +# define Py_slices_MAXFREELIST 1 +# define Py_ranges_MAXFREELIST 6 +# define Py_range_iters_MAXFREELIST 6 +# define Py_contexts_MAXFREELIST 255 +# define Py_async_gens_MAXFREELIST 80 +# define Py_async_gen_asends_MAXFREELIST 80 +# define Py_futureiters_MAXFREELIST 255 +# define Py_object_stack_chunks_MAXFREELIST 4 +# define Py_unicode_writers_MAXFREELIST 1 +# define Py_pycfunctionobject_MAXFREELIST 16 +# define Py_pycmethodobject_MAXFREELIST 16 +# define Py_pymethodobjects_MAXFREELIST 20 + +// A generic freelist of either PyObjects or other data structures. +struct _Py_freelist { + // Entries are linked together using the first word of the object. + // For PyObjects, this overlaps with the `ob_refcnt` field or the `ob_tid` + // field. + void *freelist; + + // The number of items in the free list or -1 if the free list is disabled + Py_ssize_t size; +}; + +struct _Py_freelists { + struct _Py_freelist floats; + struct _Py_freelist ints; + struct _Py_freelist tuples[PyTuple_MAXSAVESIZE]; + struct _Py_freelist lists; + struct _Py_freelist list_iters; + struct _Py_freelist tuple_iters; + struct _Py_freelist dicts; + struct _Py_freelist dictkeys; + struct _Py_freelist slices; + struct _Py_freelist ranges; + struct _Py_freelist range_iters; + struct _Py_freelist contexts; + struct _Py_freelist async_gens; + struct _Py_freelist async_gen_asends; + struct _Py_freelist futureiters; + struct _Py_freelist object_stack_chunks; + struct _Py_freelist unicode_writers; + struct _Py_freelist pycfunctionobject; + struct _Py_freelist pycmethodobject; + struct _Py_freelist pymethodobjects; +}; + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_FREELIST_STATE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_function.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_function.h new file mode 100644 index 0000000000000000000000000000000000000000..69b9ad548295c7dff9ce7a4fda227eba00fc8ed5 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_function.h @@ -0,0 +1,64 @@ +#ifndef Py_INTERNAL_FUNCTION_H +#define Py_INTERNAL_FUNCTION_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +extern PyObject* _PyFunction_Vectorcall( + PyObject *func, + PyObject *const *stack, + size_t nargsf, + PyObject *kwnames); + + +#define FUNC_VERSION_UNSET 0 +#define FUNC_VERSION_CLEARED 1 +#define FUNC_VERSION_FIRST_VALID 2 + +extern PyFunctionObject* _PyFunction_FromConstructor(PyFrameConstructor *constr); + +static inline int +_PyFunction_IsVersionValid(uint32_t version) +{ + return version >= FUNC_VERSION_FIRST_VALID; +} + +extern uint32_t _PyFunction_GetVersionForCurrentState(PyFunctionObject *func); +PyAPI_FUNC(void) _PyFunction_SetVersion(PyFunctionObject *func, uint32_t version); +void _PyFunction_ClearCodeByVersion(uint32_t version); +PyFunctionObject *_PyFunction_LookupByVersion(uint32_t version, PyObject **p_code); + +extern PyObject *_Py_set_function_type_params( + PyThreadState* unused, PyObject *func, PyObject *type_params); + + +/* See pycore_code.h for explanation about what "stateless" means. */ + +PyAPI_FUNC(int) +_PyFunction_VerifyStateless(PyThreadState *, PyObject *); + +static inline PyObject* _PyFunction_GET_BUILTINS(PyObject *func) { + return _PyFunction_CAST(func)->func_builtins; +} +#define _PyFunction_GET_BUILTINS(func) _PyFunction_GET_BUILTINS(_PyObject_CAST(func)) + + +/* Get the callable wrapped by a classmethod. + Returns a borrowed reference. + The caller must ensure 'cm' is a classmethod object. */ +extern PyObject *_PyClassMethod_GetFunc(PyObject *cm); + +/* Get the callable wrapped by a staticmethod. + Returns a borrowed reference. + The caller must ensure 'sm' is a staticmethod object. */ +extern PyObject *_PyStaticMethod_GetFunc(PyObject *sm); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_FUNCTION_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_gc.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_gc.h new file mode 100644 index 0000000000000000000000000000000000000000..fd284d0e4ecc2f5a03004caa04afbc722419db06 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_gc.h @@ -0,0 +1,378 @@ +#ifndef Py_INTERNAL_GC_H +#define Py_INTERNAL_GC_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_interp_structs.h" // PyGC_Head +#include "pycore_pystate.h" // _PyInterpreterState_GET() +#include "pycore_typedefs.h" // _PyInterpreterFrame + + +/* Get an object's GC head */ +static inline PyGC_Head* _Py_AS_GC(PyObject *op) { + char *gc = ((char*)op) - sizeof(PyGC_Head); + return (PyGC_Head*)gc; +} + +/* Get the object given the GC head */ +static inline PyObject* _Py_FROM_GC(PyGC_Head *gc) { + char *op = ((char *)gc) + sizeof(PyGC_Head); + return (PyObject *)op; +} + + +/* Bit flags for ob_gc_bits (in Py_GIL_DISABLED builds) + * + * Setting the bits requires a relaxed store. The per-object lock must also be + * held, except when the object is only visible to a single thread (e.g. during + * object initialization or destruction). + * + * Reading the bits requires using a relaxed load, but does not require holding + * the per-object lock. + */ +#ifdef Py_GIL_DISABLED +# define _PyGC_BITS_TRACKED (1<<0) // Tracked by the GC +# define _PyGC_BITS_FINALIZED (1<<1) // tp_finalize was called +# define _PyGC_BITS_UNREACHABLE (1<<2) +# define _PyGC_BITS_FROZEN (1<<3) +# define _PyGC_BITS_SHARED (1<<4) +# define _PyGC_BITS_ALIVE (1<<5) // Reachable from a known root. +# define _PyGC_BITS_DEFERRED (1<<6) // Use deferred reference counting +#endif + +#ifdef Py_GIL_DISABLED + +static inline void +_PyObject_SET_GC_BITS(PyObject *op, uint8_t new_bits) +{ + uint8_t bits = _Py_atomic_load_uint8_relaxed(&op->ob_gc_bits); + _Py_atomic_store_uint8_relaxed(&op->ob_gc_bits, bits | new_bits); +} + +static inline int +_PyObject_HAS_GC_BITS(PyObject *op, uint8_t bits) +{ + return (_Py_atomic_load_uint8_relaxed(&op->ob_gc_bits) & bits) != 0; +} + +static inline void +_PyObject_CLEAR_GC_BITS(PyObject *op, uint8_t bits_to_clear) +{ + uint8_t bits = _Py_atomic_load_uint8_relaxed(&op->ob_gc_bits); + _Py_atomic_store_uint8_relaxed(&op->ob_gc_bits, bits & ~bits_to_clear); +} + +#endif + +/* True if the object is currently tracked by the GC. */ +static inline int _PyObject_GC_IS_TRACKED(PyObject *op) { +#ifdef Py_GIL_DISABLED + return _PyObject_HAS_GC_BITS(op, _PyGC_BITS_TRACKED); +#else + PyGC_Head *gc = _Py_AS_GC(op); + return (gc->_gc_next != 0); +#endif +} +#define _PyObject_GC_IS_TRACKED(op) _PyObject_GC_IS_TRACKED(_Py_CAST(PyObject*, op)) + +/* True if the object may be tracked by the GC in the future, or already is. + This can be useful to implement some optimizations. */ +static inline int _PyObject_GC_MAY_BE_TRACKED(PyObject *obj) { + if (!PyObject_IS_GC(obj)) { + return 0; + } + if (PyTuple_CheckExact(obj)) { + return _PyObject_GC_IS_TRACKED(obj); + } + return 1; +} + +#ifdef Py_GIL_DISABLED + +/* True if memory the object references is shared between + * multiple threads and needs special purpose when freeing + * those references due to the possibility of in-flight + * lock-free reads occurring. The object is responsible + * for calling _PyMem_FreeDelayed on the referenced + * memory. */ +static inline int _PyObject_GC_IS_SHARED(PyObject *op) { + return _PyObject_HAS_GC_BITS(op, _PyGC_BITS_SHARED); +} +#define _PyObject_GC_IS_SHARED(op) _PyObject_GC_IS_SHARED(_Py_CAST(PyObject*, op)) + +static inline void _PyObject_GC_SET_SHARED(PyObject *op) { + _PyObject_SET_GC_BITS(op, _PyGC_BITS_SHARED); +} +#define _PyObject_GC_SET_SHARED(op) _PyObject_GC_SET_SHARED(_Py_CAST(PyObject*, op)) + +#endif + +/* Bit flags for _gc_prev */ +/* Bit 0 is set when tp_finalize is called */ +#define _PyGC_PREV_MASK_FINALIZED ((uintptr_t)1) +/* Bit 1 is set when the object is in generation which is GCed currently. */ +#define _PyGC_PREV_MASK_COLLECTING ((uintptr_t)2) + +/* Bit 0 in _gc_next is the old space bit. + * It is set as follows: + * Young: gcstate->visited_space + * old[0]: 0 + * old[1]: 1 + * permanent: 0 + * + * During a collection all objects handled should have the bit set to + * gcstate->visited_space, as objects are moved from the young gen + * and the increment into old[gcstate->visited_space]. + * When object are moved from the pending space, old[gcstate->visited_space^1] + * into the increment, the old space bit is flipped. +*/ +#define _PyGC_NEXT_MASK_OLD_SPACE_1 1 + +#define _PyGC_PREV_SHIFT 2 +#define _PyGC_PREV_MASK (((uintptr_t) -1) << _PyGC_PREV_SHIFT) + +/* set for debugging information */ +#define _PyGC_DEBUG_STATS (1<<0) /* print collection statistics */ +#define _PyGC_DEBUG_COLLECTABLE (1<<1) /* print collectable objects */ +#define _PyGC_DEBUG_UNCOLLECTABLE (1<<2) /* print uncollectable objects */ +#define _PyGC_DEBUG_SAVEALL (1<<5) /* save all garbage in gc.garbage */ +#define _PyGC_DEBUG_LEAK _PyGC_DEBUG_COLLECTABLE | \ + _PyGC_DEBUG_UNCOLLECTABLE | \ + _PyGC_DEBUG_SAVEALL + +typedef enum { + // GC was triggered by heap allocation + _Py_GC_REASON_HEAP, + + // GC was called during shutdown + _Py_GC_REASON_SHUTDOWN, + + // GC was called by gc.collect() or PyGC_Collect() + _Py_GC_REASON_MANUAL +} _PyGC_Reason; + +// Lowest bit of _gc_next is used for flags only in GC. +// But it is always 0 for normal code. +static inline PyGC_Head* _PyGCHead_NEXT(PyGC_Head *gc) { + uintptr_t next = gc->_gc_next & _PyGC_PREV_MASK; + return (PyGC_Head*)next; +} +static inline void _PyGCHead_SET_NEXT(PyGC_Head *gc, PyGC_Head *next) { + uintptr_t unext = (uintptr_t)next; + assert((unext & ~_PyGC_PREV_MASK) == 0); + gc->_gc_next = (gc->_gc_next & ~_PyGC_PREV_MASK) | unext; +} + +// Lowest two bits of _gc_prev is used for _PyGC_PREV_MASK_* flags. +static inline PyGC_Head* _PyGCHead_PREV(PyGC_Head *gc) { + uintptr_t prev = (gc->_gc_prev & _PyGC_PREV_MASK); + return (PyGC_Head*)prev; +} + +static inline void _PyGCHead_SET_PREV(PyGC_Head *gc, PyGC_Head *prev) { + uintptr_t uprev = (uintptr_t)prev; + assert((uprev & ~_PyGC_PREV_MASK) == 0); + gc->_gc_prev = ((gc->_gc_prev & ~_PyGC_PREV_MASK) | uprev); +} + +static inline int _PyGC_FINALIZED(PyObject *op) { +#ifdef Py_GIL_DISABLED + return _PyObject_HAS_GC_BITS(op, _PyGC_BITS_FINALIZED); +#else + PyGC_Head *gc = _Py_AS_GC(op); + return ((gc->_gc_prev & _PyGC_PREV_MASK_FINALIZED) != 0); +#endif +} +static inline void _PyGC_SET_FINALIZED(PyObject *op) { +#ifdef Py_GIL_DISABLED + _PyObject_SET_GC_BITS(op, _PyGC_BITS_FINALIZED); +#else + PyGC_Head *gc = _Py_AS_GC(op); + gc->_gc_prev |= _PyGC_PREV_MASK_FINALIZED; +#endif +} +static inline void _PyGC_CLEAR_FINALIZED(PyObject *op) { +#ifdef Py_GIL_DISABLED + _PyObject_CLEAR_GC_BITS(op, _PyGC_BITS_FINALIZED); +#else + PyGC_Head *gc = _Py_AS_GC(op); + gc->_gc_prev &= ~_PyGC_PREV_MASK_FINALIZED; +#endif +} + +extern void _Py_ScheduleGC(PyThreadState *tstate); + +#ifndef Py_GIL_DISABLED +extern void _Py_TriggerGC(struct _gc_runtime_state *gcstate); +#endif + + +/* Tell the GC to track this object. + * + * The object must not be tracked by the GC. + * + * NB: While the object is tracked by the collector, it must be safe to call the + * ob_traverse method. + * + * Internal note: interp->gc.generation0->_gc_prev doesn't have any bit flags + * because it's not object header. So we don't use _PyGCHead_PREV() and + * _PyGCHead_SET_PREV() for it to avoid unnecessary bitwise operations. + * + * See also the public PyObject_GC_Track() function. + */ +static inline void _PyObject_GC_TRACK( +// The preprocessor removes _PyObject_ASSERT_FROM() calls if NDEBUG is defined +#ifndef NDEBUG + const char *filename, int lineno, +#endif + PyObject *op) +{ + _PyObject_ASSERT_FROM(op, !_PyObject_GC_IS_TRACKED(op), + "object already tracked by the garbage collector", + filename, lineno, __func__); +#ifdef Py_GIL_DISABLED + _PyObject_SET_GC_BITS(op, _PyGC_BITS_TRACKED); +#else + PyGC_Head *gc = _Py_AS_GC(op); + _PyObject_ASSERT_FROM(op, + (gc->_gc_prev & _PyGC_PREV_MASK_COLLECTING) == 0, + "object is in generation which is garbage collected", + filename, lineno, __func__); + + struct _gc_runtime_state *gcstate = &_PyInterpreterState_GET()->gc; + PyGC_Head *generation0 = &gcstate->young.head; + PyGC_Head *last = (PyGC_Head*)(generation0->_gc_prev); + _PyGCHead_SET_NEXT(last, gc); + _PyGCHead_SET_PREV(gc, last); + uintptr_t not_visited = 1 ^ gcstate->visited_space; + gc->_gc_next = ((uintptr_t)generation0) | not_visited; + generation0->_gc_prev = (uintptr_t)gc; + gcstate->young.count++; /* number of tracked GC objects */ + gcstate->heap_size++; + if (gcstate->young.count > gcstate->young.threshold) { + _Py_TriggerGC(gcstate); + } +#endif +} + +/* Tell the GC to stop tracking this object. + * + * Internal note: This may be called while GC. So _PyGC_PREV_MASK_COLLECTING + * must be cleared. But _PyGC_PREV_MASK_FINALIZED bit is kept. + * + * The object must be tracked by the GC. + * + * See also the public PyObject_GC_UnTrack() which accept an object which is + * not tracked. + */ +static inline void _PyObject_GC_UNTRACK( +// The preprocessor removes _PyObject_ASSERT_FROM() calls if NDEBUG is defined +#ifndef NDEBUG + const char *filename, int lineno, +#endif + PyObject *op) +{ + _PyObject_ASSERT_FROM(op, _PyObject_GC_IS_TRACKED(op), + "object not tracked by the garbage collector", + filename, lineno, __func__); + +#ifdef Py_GIL_DISABLED + _PyObject_CLEAR_GC_BITS(op, _PyGC_BITS_TRACKED); +#else + PyGC_Head *gc = _Py_AS_GC(op); + PyGC_Head *prev = _PyGCHead_PREV(gc); + PyGC_Head *next = _PyGCHead_NEXT(gc); + _PyGCHead_SET_NEXT(prev, next); + _PyGCHead_SET_PREV(next, prev); + gc->_gc_next = 0; + gc->_gc_prev &= _PyGC_PREV_MASK_FINALIZED; + struct _gc_runtime_state *gcstate = &_PyInterpreterState_GET()->gc; + if (gcstate->young.count > 0) { + gcstate->young.count--; + } + gcstate->heap_size--; +#endif +} + + + +/* + NOTE: about untracking of mutable objects. + + Certain types of container cannot participate in a reference cycle, and + so do not need to be tracked by the garbage collector. Untracking these + objects reduces the cost of garbage collections. However, determining + which objects may be untracked is not free, and the costs must be + weighed against the benefits for garbage collection. + + There are two possible strategies for when to untrack a container: + + i) When the container is created. + ii) When the container is examined by the garbage collector. + + Tuples containing only immutable objects (integers, strings etc, and + recursively, tuples of immutable objects) do not need to be tracked. + The interpreter creates a large number of tuples, many of which will + not survive until garbage collection. It is therefore not worthwhile + to untrack eligible tuples at creation time. + + Instead, all tuples except the empty tuple are tracked when created. + During garbage collection it is determined whether any surviving tuples + can be untracked. A tuple can be untracked if all of its contents are + already not tracked. Tuples are examined for untracking in all garbage + collection cycles. It may take more than one cycle to untrack a tuple. + + Dictionaries containing only immutable objects also do not need to be + tracked. Dictionaries are untracked when created. If a tracked item is + inserted into a dictionary (either as a key or value), the dictionary + becomes tracked. During a full garbage collection (all generations), + the collector will untrack any dictionaries whose contents are not + tracked. + + The module provides the python function is_tracked(obj), which returns + the CURRENT tracking status of the object. Subsequent garbage + collections may change the tracking status of the object. + + Untracking of certain containers was introduced in issue #4688, and + the algorithm was refined in response to issue #14775. +*/ + +extern void _PyGC_InitState(struct _gc_runtime_state *); + +extern Py_ssize_t _PyGC_Collect(PyThreadState *tstate, int generation, _PyGC_Reason reason); +extern void _PyGC_CollectNoFail(PyThreadState *tstate); + +/* Freeze objects tracked by the GC and ignore them in future collections. */ +extern void _PyGC_Freeze(PyInterpreterState *interp); +/* Unfreezes objects placing them in the oldest generation */ +extern void _PyGC_Unfreeze(PyInterpreterState *interp); +/* Number of frozen objects */ +extern Py_ssize_t _PyGC_GetFreezeCount(PyInterpreterState *interp); + +extern PyObject *_PyGC_GetObjects(PyInterpreterState *interp, int generation); +extern PyObject *_PyGC_GetReferrers(PyInterpreterState *interp, PyObject *objs); + +// Functions to clear types free lists +extern void _PyGC_ClearAllFreeLists(PyInterpreterState *interp); +extern void _Py_RunGC(PyThreadState *tstate); + +union _PyStackRef; + +// GC visit callback for tracked interpreter frames +extern int _PyGC_VisitFrameStack(_PyInterpreterFrame *frame, visitproc visit, void *arg); +extern int _PyGC_VisitStackRef(union _PyStackRef *ref, visitproc visit, void *arg); + +#ifdef Py_GIL_DISABLED +extern void _PyGC_VisitObjectsWorldStopped(PyInterpreterState *interp, + gcvisitobjects_t callback, void *arg); +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_GC_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_genobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_genobject.h new file mode 100644 index 0000000000000000000000000000000000000000..c1fc3511f849ade2444a9c7d7d8a5a70f0853bb3 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_genobject.h @@ -0,0 +1,43 @@ +#ifndef Py_INTERNAL_GENOBJECT_H +#define Py_INTERNAL_GENOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_interpframe_structs.h" // _PyGenObject + +#include // offsetof() + + +static inline +PyGenObject *_PyGen_GetGeneratorFromFrame(_PyInterpreterFrame *frame) +{ + assert(frame->owner == FRAME_OWNED_BY_GENERATOR); + size_t offset_in_gen = offsetof(PyGenObject, gi_iframe); + return (PyGenObject *)(((char *)frame) - offset_in_gen); +} + +PyAPI_FUNC(PyObject *)_PyGen_yf(PyGenObject *); +extern void _PyGen_Finalize(PyObject *self); + +// Export for '_asyncio' shared extension +PyAPI_FUNC(int) _PyGen_SetStopIterationValue(PyObject *); + +// Export for '_asyncio' shared extension +PyAPI_FUNC(int) _PyGen_FetchStopIterationValue(PyObject **); + +PyAPI_FUNC(PyObject *)_PyCoro_GetAwaitableIter(PyObject *o); +extern PyObject *_PyAsyncGenValueWrapperNew(PyThreadState *state, PyObject *); + +extern PyTypeObject _PyCoroWrapper_Type; +extern PyTypeObject _PyAsyncGenWrappedValue_Type; +extern PyTypeObject _PyAsyncGenAThrow_Type; + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_GENOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_getopt.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_getopt.h new file mode 100644 index 0000000000000000000000000000000000000000..7f0dd13ae577f78491f19b7e8fa3ac8c5042bb11 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_getopt.h @@ -0,0 +1,22 @@ +#ifndef Py_INTERNAL_PYGETOPT_H +#define Py_INTERNAL_PYGETOPT_H + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +extern int _PyOS_opterr; +extern Py_ssize_t _PyOS_optind; +extern const wchar_t *_PyOS_optarg; + +extern void _PyOS_ResetGetOpt(void); + +typedef struct { + const wchar_t *name; + int has_arg; + int val; +} _PyOS_LongOption; + +extern int _PyOS_GetOpt(Py_ssize_t argc, wchar_t * const *argv, int *longindex); + +#endif /* !Py_INTERNAL_PYGETOPT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_gil.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_gil.h new file mode 100644 index 0000000000000000000000000000000000000000..a2de5077371ebae37b9b17e870c3195f0e8b7714 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_gil.h @@ -0,0 +1,66 @@ +#ifndef Py_INTERNAL_GIL_H +#define Py_INTERNAL_GIL_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_condvar.h" // PyCOND_T + +#ifndef Py_HAVE_CONDVAR +# error You need either a POSIX-compatible or a Windows system! +#endif + +/* Enable if you want to force the switching of threads at least + every `interval`. */ +#undef FORCE_SWITCHING +#define FORCE_SWITCHING + +struct _gil_runtime_state { +#ifdef Py_GIL_DISABLED + /* If this GIL is disabled, enabled == 0. + + If this GIL is enabled transiently (most likely to initialize a module + of unknown safety), enabled indicates the number of active transient + requests. + + If this GIL is enabled permanently, enabled == INT_MAX. + + It must not be modified directly; use _PyEval_EnableGILTransiently(), + _PyEval_EnableGILPermanently(), and _PyEval_DisableGIL() + + It is always read and written atomically, but a thread can assume its + value will be stable as long as that thread is attached or knows that no + other threads are attached (e.g., during a stop-the-world.). */ + int enabled; +#endif + /* microseconds (the Python API uses seconds, though) */ + unsigned long interval; + /* Last PyThreadState holding / having held the GIL. This helps us + know whether anyone else was scheduled after we dropped the GIL. */ + PyThreadState* last_holder; + /* Whether the GIL is already taken (-1 if uninitialized). This is + atomic because it can be read without any lock taken in ceval.c. */ + int locked; + /* Number of GIL switches since the beginning. */ + unsigned long switch_number; + /* This condition variable allows one or several threads to wait + until the GIL is released. In addition, the mutex also protects + the above variables. */ + PyCOND_T cond; + PyMUTEX_T mutex; +#ifdef FORCE_SWITCHING + /* This condition variable helps the GIL-releasing thread wait for + a GIL-awaiting thread to be scheduled and take the GIL. */ + PyCOND_T switch_cond; + PyMUTEX_T switch_mutex; +#endif +}; + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_GIL_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_global_objects.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_global_objects.h new file mode 100644 index 0000000000000000000000000000000000000000..13251d4676be7d5f697b7862ea6ce5c8de0ebf21 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_global_objects.h @@ -0,0 +1,34 @@ +#ifndef Py_INTERNAL_GLOBAL_OBJECTS_H +#define Py_INTERNAL_GLOBAL_OBJECTS_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + + +// Only immutable objects should be considered runtime-global. +// All others must be per-interpreter. + +#define _Py_GLOBAL_OBJECT(NAME) \ + _PyRuntime.static_objects.NAME +#define _Py_SINGLETON(NAME) \ + _Py_GLOBAL_OBJECT(singletons.NAME) + + +#define _Py_INTERP_CACHED_OBJECT(interp, NAME) \ + (interp)->cached_objects.NAME + + +#define _Py_INTERP_STATIC_OBJECT(interp, NAME) \ + (interp)->static_objects.NAME +#define _Py_INTERP_SINGLETON(interp, NAME) \ + _Py_INTERP_STATIC_OBJECT(interp, singletons.NAME) + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_GLOBAL_OBJECTS_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_global_objects_fini_generated.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_global_objects_fini_generated.h new file mode 100644 index 0000000000000000000000000000000000000000..5997858378cfe0acec3503a0d57734a318cee5a6 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_global_objects_fini_generated.h @@ -0,0 +1,1592 @@ +#ifndef Py_INTERNAL_GLOBAL_OBJECTS_FINI_GENERATED_INIT_H +#define Py_INTERNAL_GLOBAL_OBJECTS_FINI_GENERATED_INIT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#ifdef Py_DEBUG +static inline void +_PyStaticObject_CheckRefcnt(PyObject *obj) { + if (!_Py_IsImmortal(obj)) { + fprintf(stderr, "Immortal Object has less refcnt than expected.\n"); + _PyObject_Dump(obj); + } +} +#endif + +/* The following is auto-generated by Tools/build/generate_global_objects.py. */ +#ifdef Py_DEBUG +static inline void +_PyStaticObjects_CheckRefcnt(PyInterpreterState *interp) { + /* generated runtime-global */ + // (see pycore_runtime_init_generated.h) + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + -5]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + -4]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + -3]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + -2]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + -1]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 0]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 1]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 2]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 3]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 4]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 5]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 6]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 7]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 8]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 9]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 10]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 11]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 12]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 13]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 14]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 15]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 16]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 17]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 18]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 19]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 20]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 21]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 22]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 23]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 24]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 25]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 26]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 27]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 28]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 29]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 30]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 31]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 32]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 33]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 34]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 35]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 36]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 37]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 38]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 39]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 40]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 41]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 42]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 43]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 44]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 45]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 46]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 47]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 48]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 49]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 50]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 51]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 52]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 53]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 54]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 55]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 56]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 57]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 58]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 59]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 60]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 61]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 62]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 63]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 64]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 65]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 66]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 67]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 68]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 69]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 70]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 71]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 72]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 73]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 74]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 75]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 76]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 77]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 78]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 79]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 80]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 81]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 82]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 83]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 84]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 85]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 86]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 87]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 88]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 89]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 90]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 91]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 92]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 93]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 94]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 95]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 96]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 97]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 98]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 99]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 100]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 101]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 102]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 103]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 104]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 105]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 106]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 107]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 108]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 109]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 110]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 111]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 112]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 113]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 114]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 115]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 116]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 117]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 118]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 119]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 120]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 121]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 122]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 123]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 124]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 125]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 126]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 127]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 129]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 130]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 131]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 132]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 133]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 134]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 135]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 136]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 137]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 138]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 139]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 140]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 141]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 142]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 143]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 144]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 145]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 146]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 147]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 148]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 149]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 150]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 151]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 152]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 153]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 154]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 155]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 156]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 157]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 158]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 159]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 160]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 161]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 162]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 163]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 164]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 165]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 166]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 167]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 168]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 169]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 170]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 171]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 172]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 173]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 174]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 175]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 176]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 177]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 178]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 179]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 180]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 181]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 182]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 183]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 184]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 185]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 186]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 187]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 188]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 189]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 190]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 191]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 192]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 193]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 194]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 195]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 196]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 197]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 198]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 199]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 200]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 201]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 202]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 203]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 204]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 205]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 206]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 207]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 208]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 209]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 210]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 211]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 212]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 213]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 214]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 215]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 216]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 217]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 218]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 219]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 220]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 221]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 222]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 223]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 224]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 225]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 226]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 227]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 228]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 229]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 230]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 231]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 232]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 233]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 234]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 235]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 236]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 237]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 238]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 239]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 240]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 241]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 242]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 243]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 244]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 245]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 246]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 247]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 248]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 249]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 250]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 251]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 252]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 253]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 254]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 255]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + 256]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[0]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[1]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[2]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[3]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[4]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[5]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[6]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[7]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[8]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[9]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[10]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[11]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[12]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[13]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[14]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[15]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[16]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[17]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[18]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[19]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[20]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[21]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[22]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[23]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[24]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[25]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[26]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[27]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[28]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[29]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[30]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[31]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[32]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[33]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[34]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[35]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[36]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[37]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[38]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[39]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[40]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[41]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[42]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[43]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[44]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[45]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[46]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[47]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[48]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[49]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[50]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[51]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[52]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[53]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[54]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[55]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[56]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[57]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[58]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[59]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[60]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[61]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[62]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[63]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[64]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[65]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[66]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[67]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[68]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[69]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[70]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[71]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[72]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[73]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[74]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[75]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[76]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[77]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[78]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[79]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[80]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[81]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[82]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[83]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[84]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[85]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[86]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[87]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[88]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[89]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[90]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[91]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[92]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[93]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[94]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[95]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[96]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[97]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[98]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[99]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[100]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[101]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[102]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[103]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[104]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[105]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[106]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[107]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[108]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[109]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[110]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[111]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[112]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[113]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[114]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[115]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[116]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[117]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[118]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[119]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[120]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[121]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[122]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[123]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[124]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[125]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[126]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[127]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[129]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[130]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[131]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[132]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[133]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[134]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[135]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[136]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[137]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[138]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[139]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[140]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[141]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[142]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[143]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[144]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[145]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[146]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[147]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[148]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[149]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[150]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[151]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[152]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[153]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[154]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[155]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[156]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[157]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[158]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[159]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[160]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[161]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[162]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[163]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[164]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[165]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[166]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[167]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[168]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[169]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[170]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[171]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[172]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[173]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[174]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[175]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[176]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[177]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[178]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[179]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[180]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[181]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[182]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[183]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[184]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[185]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[186]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[187]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[188]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[189]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[190]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[191]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[192]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[193]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[194]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[195]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[196]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[197]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[198]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[199]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[200]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[201]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[202]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[203]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[204]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[205]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[206]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[207]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[208]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[209]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[210]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[211]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[212]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[213]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[214]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[215]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[216]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[217]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[218]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[219]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[220]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[221]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[222]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[223]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[224]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[225]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[226]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[227]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[228]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[229]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[230]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[231]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[232]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[233]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[234]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[235]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[236]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[237]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[238]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[239]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[240]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[241]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[242]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[243]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[244]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[245]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[246]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[247]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[248]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[249]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[250]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[251]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[252]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[253]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[254]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[255]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(anon_dictcomp)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(anon_genexpr)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(anon_lambda)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(anon_listcomp)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(anon_module)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(anon_null)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(anon_setcomp)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(anon_string)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(anon_unknown)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(dbl_close_br)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(dbl_open_br)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(dbl_percent)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(defaults)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(dot_locals)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(empty)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(format)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(generic_base)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(json_decoder)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(kwdefaults)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(list_err)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(str_replace_inf)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(type_params)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(utf_8)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(CANCELLED)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(FINISHED)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(False)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(JSONDecodeError)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(PENDING)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(Py_Repr)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(TextIOWrapper)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(True)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(WarningMessage)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_WindowsConsoleIO)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__IOBase_closed)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__abc_tpflags__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__abs__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__abstractmethods__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__add__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__aenter__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__aexit__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__aiter__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__all__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__and__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__anext__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__annotate__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__annotate_func__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__annotations__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__annotations_cache__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__args__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__await__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__bases__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__bool__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__buffer__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__build_class__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__builtins__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__bytes__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__call__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__cantrace__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__ceil__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__class__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__class_getitem__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__classcell__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__classdict__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__classdictcell__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__complex__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__conditional_annotations__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__contains__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__ctypes_from_outparam__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__del__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__delattr__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__delete__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__delitem__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__dict__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__dictoffset__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__dir__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__divmod__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__doc__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__enter__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__eq__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__exit__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__file__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__firstlineno__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__float__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__floor__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__floordiv__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__format__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__fspath__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__ge__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__get__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__getattr__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__getattribute__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__getinitargs__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__getitem__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__getnewargs__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__getnewargs_ex__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__getstate__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__gt__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__hash__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__iadd__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__iand__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__ifloordiv__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__ilshift__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__imatmul__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__imod__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__import__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__imul__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__index__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__init__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__init_subclass__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__instancecheck__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__int__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__invert__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__ior__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__ipow__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__irshift__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__isabstractmethod__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__isub__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__iter__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__itruediv__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__ixor__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__le__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__len__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__length_hint__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__lltrace__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__loader__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__lshift__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__lt__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__main__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__match_args__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__matmul__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__missing__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__mod__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__module__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__mro_entries__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__mul__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__name__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__ne__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__neg__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__new__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__newobj__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__newobj_ex__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__next__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__notes__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__or__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__orig_class__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__origin__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__package__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__parameters__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__path__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__pos__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__pow__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__prepare__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__qualname__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__radd__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__rand__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__rdivmod__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__reduce__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__reduce_ex__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__release_buffer__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__repr__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__reversed__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__rfloordiv__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__rlshift__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__rmatmul__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__rmod__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__rmul__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__ror__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__round__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__rpow__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__rrshift__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__rshift__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__rsub__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__rtruediv__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__rxor__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__set__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__set_name__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__setattr__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__setitem__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__setstate__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__sizeof__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__slotnames__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__slots__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__spec__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__static_attributes__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__str__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__sub__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__subclasscheck__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__subclasshook__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__truediv__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__trunc__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__type_params__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__typing_is_unpacked_typevartuple__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__typing_prepare_subst__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__typing_subst__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__typing_unpacked_tuple_args__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__warningregistry__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__weaklistoffset__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__weakref__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(__xor__)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_abc_impl)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_abstract_)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_active)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_anonymous_)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_argtypes_)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_as_parameter_)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_asyncio_future_blocking)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_blksize)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_bootstrap)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_check_retval_)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_dealloc_warn)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_feature_version)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_field_types)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_fields_)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_filters)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_finalizing)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_find_and_load)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_fix_up_module)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_flags_)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_get_sourcefile)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_handle_fromlist)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_initializing)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_internal_use)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_io)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_is_text_encoding)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_isatty_open_only)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_length_)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_limbo)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_lock_unlock_module)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_loop)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_needs_com_addref_)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_only_immortal)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_restype_)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_showwarnmsg)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_shutdown)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_slotnames)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_strptime)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_strptime_datetime_date)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_strptime_datetime_datetime)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_strptime_datetime_time)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_type_)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_uninitialized_submodules)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_warn_unawaited_coroutine)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_xoptions)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(abs_tol)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(access)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(aclose)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(add)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(add_done_callback)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(after_in_child)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(after_in_parent)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(aggregate_class)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(alias)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(align)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(all)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(all_threads)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(allow_code)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(any)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(append)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(arg)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(argdefs)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(args)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(arguments)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(argv)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(as_integer_ratio)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(asend)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(ast)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(athrow)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(attribute)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(authorizer_callback)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(autocommit)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(backtick)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(base)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(before)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(big)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(binary_form)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(bit_offset)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(bit_size)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(block)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(bound)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(buffer)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(buffer_callback)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(buffer_size)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(buffering)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(buffers)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(bufsize)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(builtins)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(byte_offset)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(byte_size)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(byteorder)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(bytes)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(bytes_per_sep)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(c_call)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(c_exception)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(c_parameter_type)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(c_return)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(cached_datetime_module)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(cached_statements)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(cadata)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(cafile)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(call)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(call_exception_handler)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(call_soon)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(callback)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(cancel)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(capath)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(category)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(cb_type)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(certfile)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(check_same_thread)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(clear)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(close)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(closed)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(closefd)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(closure)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(co_argcount)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(co_cellvars)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(co_code)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(co_consts)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(co_exceptiontable)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(co_filename)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(co_firstlineno)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(co_flags)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(co_freevars)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(co_kwonlyargcount)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(co_linetable)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(co_name)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(co_names)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(co_nlocals)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(co_posonlyargcount)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(co_qualname)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(co_stacksize)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(co_varnames)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(code)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(col_offset)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(command)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(comment_factory)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(compile_mode)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(consts)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(context)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(contravariant)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(conversion)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(cookie)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(copy)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(copyreg)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(coro)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(count)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(covariant)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(cwd)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(d_parameter_type)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(data)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(database)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(day)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(debug)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(decode)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(decoder)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(default)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(defaultaction)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(delete)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(depth)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(desired_access)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(detect_types)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(deterministic)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(device)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(dict)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(dictcomp)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(difference_update)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(digest)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(digest_size)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(digestmod)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(dir_fd)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(discard)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(dispatch_table)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(displayhook)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(dklen)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(doc)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(done)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(dont_inherit)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(dst)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(dst_dir_fd)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(eager_start)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(effective_ids)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(element_factory)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(encode)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(encoding)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(end)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(end_col_offset)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(end_lineno)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(end_offset)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(endpos)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(entrypoint)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(env)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(errors)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(event)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(eventmask)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(exc_type)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(exc_value)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(excepthook)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(exception)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(existing_file_name)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(exp)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(expression)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(extend)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(extra_tokens)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(facility)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(factory)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(false)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(family)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(fanout)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(fd)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(fd2)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(fdel)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(fget)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(fields)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(file)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(file_actions)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(filename)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(fileno)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(filepath)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(fillvalue)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(filter)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(filters)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(final)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(find_class)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(fix_imports)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(flags)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(flush)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(fold)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(follow_symlinks)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(format)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(format_spec)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(frame_buffer)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(from_param)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(fromlist)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(fromtimestamp)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(fromutc)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(fset)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(func)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(future)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(generation)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(genexpr)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(get)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(get_debug)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(get_event_loop)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(get_loop)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(get_source)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(getattr)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(getstate)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(gid)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(globals)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(groupindex)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(groups)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(handle)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(handle_seq)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(has_location)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(hash_name)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(header)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(headers)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(hi)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(hook)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(hour)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(id)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(ident)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(identity_hint)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(ignore)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(imag)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(importlib)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(in_fd)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(incoming)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(index)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(indexgroup)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(inf)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(infer_variance)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(inherit_handle)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(inheritable)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(initial)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(initial_bytes)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(initial_owner)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(initial_state)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(initial_value)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(initval)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(inner_size)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(input)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(insert_comments)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(insert_pis)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(instructions)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(intern)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(intersection)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(interval)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(io)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(is_compress)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(is_raw)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(is_running)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(is_struct)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(isatty)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(isinstance)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(isoformat)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(isolation_level)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(istext)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(item)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(items)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(iter)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(iterable)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(iterations)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(join)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(jump)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(keepends)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(key)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(keyfile)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(keys)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(kind)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(kw)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(kw1)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(kw2)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(kwdefaults)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(label)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(lambda)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(last)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(last_exc)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(last_node)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(last_traceback)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(last_type)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(last_value)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(latin1)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(leaf_size)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(len)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(length)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(level)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(limit)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(line)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(line_buffering)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(lineno)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(listcomp)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(little)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(lo)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(locale)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(locals)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(logoption)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(loop)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(manual_reset)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(mapping)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(match)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(max_length)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(maxdigits)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(maxevents)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(maxlen)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(maxmem)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(maxsplit)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(maxvalue)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(memLevel)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(memlimit)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(message)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(metaclass)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(metadata)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(method)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(microsecond)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(milliseconds)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(minute)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(mod)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(mode)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(module)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(module_globals)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(modules)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(month)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(mro)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(msg)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(mutex)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(mycmp)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(n_arg)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(n_fields)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(n_sequence_fields)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(n_unnamed_fields)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(name)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(name_from)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(namespace_separator)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(namespaces)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(narg)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(ndigits)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(nested)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(new_file_name)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(new_limit)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(newline)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(newlines)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(next)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(nlocals)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(node_depth)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(node_offset)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(ns)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(nstype)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(nt)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(null)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(number)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(obj)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(object)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(offset)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(offset_dst)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(offset_src)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(on_type_read)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(onceregistry)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(only_active_thread)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(only_keys)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(oparg)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(opcode)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(open)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(opener)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(operation)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(optimize)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(options)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(order)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(origin)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(out_fd)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(outgoing)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(outpath)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(overlapped)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(owner)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(pages)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(parameter)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(parent)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(password)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(path)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(pattern)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(peek)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(persistent_id)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(persistent_load)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(person)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(pi_factory)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(pid)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(policy)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(pos)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(pos1)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(pos2)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(posix)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(print_file_and_line)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(priority)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(progress)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(progress_handler)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(progress_routine)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(proto)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(protocol)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(ps1)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(ps2)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(query)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(quotetabs)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(raw)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(read)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(read1)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(readable)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(readall)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(readinto)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(readinto1)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(readline)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(readonly)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(real)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(reducer_override)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(registry)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(rel_tol)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(release)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(reload)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(repl)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(replace)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(reserved)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(reset)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(resetids)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(return)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(reverse)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(reversed)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(salt)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(sched_priority)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(scheduler)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(script)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(second)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(security_attributes)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(seek)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(seekable)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(selectors)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(self)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(send)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(sep)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(sequence)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(server_hostname)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(server_side)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(session)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(setcomp)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(setpgroup)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(setsid)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(setsigdef)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(setsigmask)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(setstate)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(shape)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(show_cmd)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(signed)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(size)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(sizehint)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(skip_file_prefixes)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(sleep)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(sock)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(sort)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(source)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(source_traceback)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(spam)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(src)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(src_dir_fd)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(stacklevel)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(start)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(statement)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(status)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(stderr)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(stdin)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(stdout)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(step)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(steps)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(store_name)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(strategy)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(strftime)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(strict)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(strict_mode)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(string)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(sub_key)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(subcalls)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(symmetric_difference_update)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(tabsize)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(tag)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(target)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(target_is_directory)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(task)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(tb_frame)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(tb_lasti)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(tb_lineno)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(tb_next)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(tell)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(template)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(term)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(text)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(threading)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(throw)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(timeout)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(timer)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(times)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(timetuple)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(timeunit)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(top)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(trace_callback)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(traceback)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(trailers)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(translate)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(true)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(truncate)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(twice)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(txt)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(type)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(type_params)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(tz)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(tzinfo)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(tzname)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(uid)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(unlink)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(unraisablehook)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(uri)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(usedforsecurity)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(value)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(values)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(version)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(volume)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(wait_all)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(warn_on_full_buffer)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(warnings)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(warnoptions)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(wbits)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(week)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(weekday)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(which)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(who)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(withdata)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(writable)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(write)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(write_through)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(year)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(zdict)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(zstd_dict)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[0]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[1]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[2]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[3]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[4]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[5]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[6]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[7]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[8]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[9]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[10]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[11]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[12]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[13]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[14]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[15]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[16]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[17]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[18]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[19]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[20]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[21]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[22]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[23]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[24]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[25]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[26]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[27]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[28]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[29]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[30]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[31]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[32]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[33]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[34]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[35]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[36]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[37]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[38]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[39]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[40]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[41]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[42]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[43]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[44]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[45]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[46]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[47]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[48]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[49]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[50]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[51]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[52]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[53]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[54]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[55]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[56]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[57]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[58]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[59]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[60]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[61]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[62]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[63]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[64]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[65]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[66]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[67]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[68]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[69]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[70]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[71]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[72]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[73]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[74]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[75]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[76]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[77]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[78]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[79]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[80]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[81]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[82]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[83]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[84]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[85]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[86]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[87]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[88]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[89]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[90]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[91]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[92]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[93]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[94]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[95]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[96]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[97]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[98]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[99]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[100]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[101]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[102]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[103]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[104]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[105]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[106]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[107]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[108]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[109]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[110]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[111]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[112]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[113]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[114]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[115]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[116]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[117]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[118]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[119]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[120]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[121]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[122]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[123]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[124]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[125]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[126]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).ascii[127]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[128 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[129 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[130 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[131 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[132 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[133 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[134 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[135 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[136 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[137 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[138 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[139 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[140 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[141 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[142 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[143 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[144 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[145 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[146 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[147 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[148 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[149 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[150 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[151 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[152 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[153 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[154 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[155 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[156 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[157 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[158 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[159 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[160 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[161 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[162 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[163 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[164 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[165 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[166 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[167 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[168 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[169 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[170 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[171 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[172 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[173 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[174 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[175 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[176 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[177 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[178 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[179 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[180 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[181 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[182 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[183 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[184 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[185 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[186 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[187 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[188 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[189 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[190 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[191 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[192 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[193 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[194 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[195 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[196 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[197 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[198 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[199 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[200 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[201 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[202 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[203 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[204 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[205 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[206 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[207 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[208 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[209 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[210 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[211 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[212 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[213 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[214 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[215 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[216 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[217 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[218 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[219 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[220 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[221 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[222 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[223 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[224 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[225 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[226 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[227 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[228 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[229 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[230 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[231 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[232 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[233 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[234 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[235 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[236 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[237 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[238 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[239 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[240 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[241 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[242 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[243 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[244 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[245 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[246 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[247 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[248 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[249 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[250 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[251 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[252 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[253 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[254 - 128]); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(strings).latin1[255 - 128]); + /* non-generated */ + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_empty)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(tuple_empty)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(hamt_bitmap_node_empty)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_INTERP_SINGLETON(interp, hamt_empty)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(context_token_missing)); +} +#endif // Py_DEBUG +/* End auto-generated code */ + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_GLOBAL_OBJECTS_FINI_GENERATED_INIT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_global_strings.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_global_strings.h new file mode 100644 index 0000000000000000000000000000000000000000..bab5da70f3400c19d2e1bfd3cfde63bbae637373 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_global_strings.h @@ -0,0 +1,854 @@ +#ifndef Py_INTERNAL_GLOBAL_STRINGS_H +#define Py_INTERNAL_GLOBAL_STRINGS_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_global_objects.h" // struct _Py_SINGLETON + +// The data structure & init here are inspired by Tools/build/deepfreeze.py. + +// All field names generated by ASCII_STR() have a common prefix, +// to help avoid collisions with keywords, macros, etc. + +#define STRUCT_FOR_ASCII_STR(LITERAL) \ + struct { \ + PyASCIIObject _ascii; \ + uint8_t _data[sizeof(LITERAL)]; \ + } +#define STRUCT_FOR_STR(NAME, LITERAL) \ + STRUCT_FOR_ASCII_STR(LITERAL) _py_ ## NAME; +#define STRUCT_FOR_ID(NAME) \ + STRUCT_FOR_ASCII_STR(#NAME) _py_ ## NAME; + +// XXX Order by frequency of use? + +/* The following is auto-generated by Tools/build/generate_global_objects.py. */ +struct _Py_global_strings { + struct { + STRUCT_FOR_STR(anon_dictcomp, "") + STRUCT_FOR_STR(anon_genexpr, "") + STRUCT_FOR_STR(anon_lambda, "") + STRUCT_FOR_STR(anon_listcomp, "") + STRUCT_FOR_STR(anon_module, "") + STRUCT_FOR_STR(anon_null, "") + STRUCT_FOR_STR(anon_setcomp, "") + STRUCT_FOR_STR(anon_string, "") + STRUCT_FOR_STR(anon_unknown, "") + STRUCT_FOR_STR(dbl_close_br, "}}") + STRUCT_FOR_STR(dbl_open_br, "{{") + STRUCT_FOR_STR(dbl_percent, "%%") + STRUCT_FOR_STR(defaults, ".defaults") + STRUCT_FOR_STR(dot_locals, ".") + STRUCT_FOR_STR(empty, "") + STRUCT_FOR_STR(format, ".format") + STRUCT_FOR_STR(generic_base, ".generic_base") + STRUCT_FOR_STR(json_decoder, "json.decoder") + STRUCT_FOR_STR(kwdefaults, ".kwdefaults") + STRUCT_FOR_STR(list_err, "list index out of range") + STRUCT_FOR_STR(str_replace_inf, "1e309") + STRUCT_FOR_STR(type_params, ".type_params") + STRUCT_FOR_STR(utf_8, "utf-8") + } literals; + + struct { + STRUCT_FOR_ID(CANCELLED) + STRUCT_FOR_ID(FINISHED) + STRUCT_FOR_ID(False) + STRUCT_FOR_ID(JSONDecodeError) + STRUCT_FOR_ID(PENDING) + STRUCT_FOR_ID(Py_Repr) + STRUCT_FOR_ID(TextIOWrapper) + STRUCT_FOR_ID(True) + STRUCT_FOR_ID(WarningMessage) + STRUCT_FOR_ID(_WindowsConsoleIO) + STRUCT_FOR_ID(__IOBase_closed) + STRUCT_FOR_ID(__abc_tpflags__) + STRUCT_FOR_ID(__abs__) + STRUCT_FOR_ID(__abstractmethods__) + STRUCT_FOR_ID(__add__) + STRUCT_FOR_ID(__aenter__) + STRUCT_FOR_ID(__aexit__) + STRUCT_FOR_ID(__aiter__) + STRUCT_FOR_ID(__all__) + STRUCT_FOR_ID(__and__) + STRUCT_FOR_ID(__anext__) + STRUCT_FOR_ID(__annotate__) + STRUCT_FOR_ID(__annotate_func__) + STRUCT_FOR_ID(__annotations__) + STRUCT_FOR_ID(__annotations_cache__) + STRUCT_FOR_ID(__args__) + STRUCT_FOR_ID(__await__) + STRUCT_FOR_ID(__bases__) + STRUCT_FOR_ID(__bool__) + STRUCT_FOR_ID(__buffer__) + STRUCT_FOR_ID(__build_class__) + STRUCT_FOR_ID(__builtins__) + STRUCT_FOR_ID(__bytes__) + STRUCT_FOR_ID(__call__) + STRUCT_FOR_ID(__cantrace__) + STRUCT_FOR_ID(__ceil__) + STRUCT_FOR_ID(__class__) + STRUCT_FOR_ID(__class_getitem__) + STRUCT_FOR_ID(__classcell__) + STRUCT_FOR_ID(__classdict__) + STRUCT_FOR_ID(__classdictcell__) + STRUCT_FOR_ID(__complex__) + STRUCT_FOR_ID(__conditional_annotations__) + STRUCT_FOR_ID(__contains__) + STRUCT_FOR_ID(__ctypes_from_outparam__) + STRUCT_FOR_ID(__del__) + STRUCT_FOR_ID(__delattr__) + STRUCT_FOR_ID(__delete__) + STRUCT_FOR_ID(__delitem__) + STRUCT_FOR_ID(__dict__) + STRUCT_FOR_ID(__dictoffset__) + STRUCT_FOR_ID(__dir__) + STRUCT_FOR_ID(__divmod__) + STRUCT_FOR_ID(__doc__) + STRUCT_FOR_ID(__enter__) + STRUCT_FOR_ID(__eq__) + STRUCT_FOR_ID(__exit__) + STRUCT_FOR_ID(__file__) + STRUCT_FOR_ID(__firstlineno__) + STRUCT_FOR_ID(__float__) + STRUCT_FOR_ID(__floor__) + STRUCT_FOR_ID(__floordiv__) + STRUCT_FOR_ID(__format__) + STRUCT_FOR_ID(__fspath__) + STRUCT_FOR_ID(__ge__) + STRUCT_FOR_ID(__get__) + STRUCT_FOR_ID(__getattr__) + STRUCT_FOR_ID(__getattribute__) + STRUCT_FOR_ID(__getinitargs__) + STRUCT_FOR_ID(__getitem__) + STRUCT_FOR_ID(__getnewargs__) + STRUCT_FOR_ID(__getnewargs_ex__) + STRUCT_FOR_ID(__getstate__) + STRUCT_FOR_ID(__gt__) + STRUCT_FOR_ID(__hash__) + STRUCT_FOR_ID(__iadd__) + STRUCT_FOR_ID(__iand__) + STRUCT_FOR_ID(__ifloordiv__) + STRUCT_FOR_ID(__ilshift__) + STRUCT_FOR_ID(__imatmul__) + STRUCT_FOR_ID(__imod__) + STRUCT_FOR_ID(__import__) + STRUCT_FOR_ID(__imul__) + STRUCT_FOR_ID(__index__) + STRUCT_FOR_ID(__init__) + STRUCT_FOR_ID(__init_subclass__) + STRUCT_FOR_ID(__instancecheck__) + STRUCT_FOR_ID(__int__) + STRUCT_FOR_ID(__invert__) + STRUCT_FOR_ID(__ior__) + STRUCT_FOR_ID(__ipow__) + STRUCT_FOR_ID(__irshift__) + STRUCT_FOR_ID(__isabstractmethod__) + STRUCT_FOR_ID(__isub__) + STRUCT_FOR_ID(__iter__) + STRUCT_FOR_ID(__itruediv__) + STRUCT_FOR_ID(__ixor__) + STRUCT_FOR_ID(__le__) + STRUCT_FOR_ID(__len__) + STRUCT_FOR_ID(__length_hint__) + STRUCT_FOR_ID(__lltrace__) + STRUCT_FOR_ID(__loader__) + STRUCT_FOR_ID(__lshift__) + STRUCT_FOR_ID(__lt__) + STRUCT_FOR_ID(__main__) + STRUCT_FOR_ID(__match_args__) + STRUCT_FOR_ID(__matmul__) + STRUCT_FOR_ID(__missing__) + STRUCT_FOR_ID(__mod__) + STRUCT_FOR_ID(__module__) + STRUCT_FOR_ID(__mro_entries__) + STRUCT_FOR_ID(__mul__) + STRUCT_FOR_ID(__name__) + STRUCT_FOR_ID(__ne__) + STRUCT_FOR_ID(__neg__) + STRUCT_FOR_ID(__new__) + STRUCT_FOR_ID(__newobj__) + STRUCT_FOR_ID(__newobj_ex__) + STRUCT_FOR_ID(__next__) + STRUCT_FOR_ID(__notes__) + STRUCT_FOR_ID(__or__) + STRUCT_FOR_ID(__orig_class__) + STRUCT_FOR_ID(__origin__) + STRUCT_FOR_ID(__package__) + STRUCT_FOR_ID(__parameters__) + STRUCT_FOR_ID(__path__) + STRUCT_FOR_ID(__pos__) + STRUCT_FOR_ID(__pow__) + STRUCT_FOR_ID(__prepare__) + STRUCT_FOR_ID(__qualname__) + STRUCT_FOR_ID(__radd__) + STRUCT_FOR_ID(__rand__) + STRUCT_FOR_ID(__rdivmod__) + STRUCT_FOR_ID(__reduce__) + STRUCT_FOR_ID(__reduce_ex__) + STRUCT_FOR_ID(__release_buffer__) + STRUCT_FOR_ID(__repr__) + STRUCT_FOR_ID(__reversed__) + STRUCT_FOR_ID(__rfloordiv__) + STRUCT_FOR_ID(__rlshift__) + STRUCT_FOR_ID(__rmatmul__) + STRUCT_FOR_ID(__rmod__) + STRUCT_FOR_ID(__rmul__) + STRUCT_FOR_ID(__ror__) + STRUCT_FOR_ID(__round__) + STRUCT_FOR_ID(__rpow__) + STRUCT_FOR_ID(__rrshift__) + STRUCT_FOR_ID(__rshift__) + STRUCT_FOR_ID(__rsub__) + STRUCT_FOR_ID(__rtruediv__) + STRUCT_FOR_ID(__rxor__) + STRUCT_FOR_ID(__set__) + STRUCT_FOR_ID(__set_name__) + STRUCT_FOR_ID(__setattr__) + STRUCT_FOR_ID(__setitem__) + STRUCT_FOR_ID(__setstate__) + STRUCT_FOR_ID(__sizeof__) + STRUCT_FOR_ID(__slotnames__) + STRUCT_FOR_ID(__slots__) + STRUCT_FOR_ID(__spec__) + STRUCT_FOR_ID(__static_attributes__) + STRUCT_FOR_ID(__str__) + STRUCT_FOR_ID(__sub__) + STRUCT_FOR_ID(__subclasscheck__) + STRUCT_FOR_ID(__subclasshook__) + STRUCT_FOR_ID(__truediv__) + STRUCT_FOR_ID(__trunc__) + STRUCT_FOR_ID(__type_params__) + STRUCT_FOR_ID(__typing_is_unpacked_typevartuple__) + STRUCT_FOR_ID(__typing_prepare_subst__) + STRUCT_FOR_ID(__typing_subst__) + STRUCT_FOR_ID(__typing_unpacked_tuple_args__) + STRUCT_FOR_ID(__warningregistry__) + STRUCT_FOR_ID(__weaklistoffset__) + STRUCT_FOR_ID(__weakref__) + STRUCT_FOR_ID(__xor__) + STRUCT_FOR_ID(_abc_impl) + STRUCT_FOR_ID(_abstract_) + STRUCT_FOR_ID(_active) + STRUCT_FOR_ID(_anonymous_) + STRUCT_FOR_ID(_argtypes_) + STRUCT_FOR_ID(_as_parameter_) + STRUCT_FOR_ID(_asyncio_future_blocking) + STRUCT_FOR_ID(_blksize) + STRUCT_FOR_ID(_bootstrap) + STRUCT_FOR_ID(_check_retval_) + STRUCT_FOR_ID(_dealloc_warn) + STRUCT_FOR_ID(_feature_version) + STRUCT_FOR_ID(_field_types) + STRUCT_FOR_ID(_fields_) + STRUCT_FOR_ID(_filters) + STRUCT_FOR_ID(_finalizing) + STRUCT_FOR_ID(_find_and_load) + STRUCT_FOR_ID(_fix_up_module) + STRUCT_FOR_ID(_flags_) + STRUCT_FOR_ID(_get_sourcefile) + STRUCT_FOR_ID(_handle_fromlist) + STRUCT_FOR_ID(_initializing) + STRUCT_FOR_ID(_internal_use) + STRUCT_FOR_ID(_io) + STRUCT_FOR_ID(_is_text_encoding) + STRUCT_FOR_ID(_isatty_open_only) + STRUCT_FOR_ID(_length_) + STRUCT_FOR_ID(_limbo) + STRUCT_FOR_ID(_lock_unlock_module) + STRUCT_FOR_ID(_loop) + STRUCT_FOR_ID(_needs_com_addref_) + STRUCT_FOR_ID(_only_immortal) + STRUCT_FOR_ID(_restype_) + STRUCT_FOR_ID(_showwarnmsg) + STRUCT_FOR_ID(_shutdown) + STRUCT_FOR_ID(_slotnames) + STRUCT_FOR_ID(_strptime) + STRUCT_FOR_ID(_strptime_datetime_date) + STRUCT_FOR_ID(_strptime_datetime_datetime) + STRUCT_FOR_ID(_strptime_datetime_time) + STRUCT_FOR_ID(_type_) + STRUCT_FOR_ID(_uninitialized_submodules) + STRUCT_FOR_ID(_warn_unawaited_coroutine) + STRUCT_FOR_ID(_xoptions) + STRUCT_FOR_ID(abs_tol) + STRUCT_FOR_ID(access) + STRUCT_FOR_ID(aclose) + STRUCT_FOR_ID(add) + STRUCT_FOR_ID(add_done_callback) + STRUCT_FOR_ID(after_in_child) + STRUCT_FOR_ID(after_in_parent) + STRUCT_FOR_ID(aggregate_class) + STRUCT_FOR_ID(alias) + STRUCT_FOR_ID(align) + STRUCT_FOR_ID(all) + STRUCT_FOR_ID(all_threads) + STRUCT_FOR_ID(allow_code) + STRUCT_FOR_ID(any) + STRUCT_FOR_ID(append) + STRUCT_FOR_ID(arg) + STRUCT_FOR_ID(argdefs) + STRUCT_FOR_ID(args) + STRUCT_FOR_ID(arguments) + STRUCT_FOR_ID(argv) + STRUCT_FOR_ID(as_integer_ratio) + STRUCT_FOR_ID(asend) + STRUCT_FOR_ID(ast) + STRUCT_FOR_ID(athrow) + STRUCT_FOR_ID(attribute) + STRUCT_FOR_ID(authorizer_callback) + STRUCT_FOR_ID(autocommit) + STRUCT_FOR_ID(backtick) + STRUCT_FOR_ID(base) + STRUCT_FOR_ID(before) + STRUCT_FOR_ID(big) + STRUCT_FOR_ID(binary_form) + STRUCT_FOR_ID(bit_offset) + STRUCT_FOR_ID(bit_size) + STRUCT_FOR_ID(block) + STRUCT_FOR_ID(bound) + STRUCT_FOR_ID(buffer) + STRUCT_FOR_ID(buffer_callback) + STRUCT_FOR_ID(buffer_size) + STRUCT_FOR_ID(buffering) + STRUCT_FOR_ID(buffers) + STRUCT_FOR_ID(bufsize) + STRUCT_FOR_ID(builtins) + STRUCT_FOR_ID(byte_offset) + STRUCT_FOR_ID(byte_size) + STRUCT_FOR_ID(byteorder) + STRUCT_FOR_ID(bytes) + STRUCT_FOR_ID(bytes_per_sep) + STRUCT_FOR_ID(c_call) + STRUCT_FOR_ID(c_exception) + STRUCT_FOR_ID(c_parameter_type) + STRUCT_FOR_ID(c_return) + STRUCT_FOR_ID(cached_datetime_module) + STRUCT_FOR_ID(cached_statements) + STRUCT_FOR_ID(cadata) + STRUCT_FOR_ID(cafile) + STRUCT_FOR_ID(call) + STRUCT_FOR_ID(call_exception_handler) + STRUCT_FOR_ID(call_soon) + STRUCT_FOR_ID(callback) + STRUCT_FOR_ID(cancel) + STRUCT_FOR_ID(capath) + STRUCT_FOR_ID(category) + STRUCT_FOR_ID(cb_type) + STRUCT_FOR_ID(certfile) + STRUCT_FOR_ID(check_same_thread) + STRUCT_FOR_ID(clear) + STRUCT_FOR_ID(close) + STRUCT_FOR_ID(closed) + STRUCT_FOR_ID(closefd) + STRUCT_FOR_ID(closure) + STRUCT_FOR_ID(co_argcount) + STRUCT_FOR_ID(co_cellvars) + STRUCT_FOR_ID(co_code) + STRUCT_FOR_ID(co_consts) + STRUCT_FOR_ID(co_exceptiontable) + STRUCT_FOR_ID(co_filename) + STRUCT_FOR_ID(co_firstlineno) + STRUCT_FOR_ID(co_flags) + STRUCT_FOR_ID(co_freevars) + STRUCT_FOR_ID(co_kwonlyargcount) + STRUCT_FOR_ID(co_linetable) + STRUCT_FOR_ID(co_name) + STRUCT_FOR_ID(co_names) + STRUCT_FOR_ID(co_nlocals) + STRUCT_FOR_ID(co_posonlyargcount) + STRUCT_FOR_ID(co_qualname) + STRUCT_FOR_ID(co_stacksize) + STRUCT_FOR_ID(co_varnames) + STRUCT_FOR_ID(code) + STRUCT_FOR_ID(col_offset) + STRUCT_FOR_ID(command) + STRUCT_FOR_ID(comment_factory) + STRUCT_FOR_ID(compile_mode) + STRUCT_FOR_ID(consts) + STRUCT_FOR_ID(context) + STRUCT_FOR_ID(contravariant) + STRUCT_FOR_ID(conversion) + STRUCT_FOR_ID(cookie) + STRUCT_FOR_ID(copy) + STRUCT_FOR_ID(copyreg) + STRUCT_FOR_ID(coro) + STRUCT_FOR_ID(count) + STRUCT_FOR_ID(covariant) + STRUCT_FOR_ID(cwd) + STRUCT_FOR_ID(d_parameter_type) + STRUCT_FOR_ID(data) + STRUCT_FOR_ID(database) + STRUCT_FOR_ID(day) + STRUCT_FOR_ID(debug) + STRUCT_FOR_ID(decode) + STRUCT_FOR_ID(decoder) + STRUCT_FOR_ID(default) + STRUCT_FOR_ID(defaultaction) + STRUCT_FOR_ID(delete) + STRUCT_FOR_ID(depth) + STRUCT_FOR_ID(desired_access) + STRUCT_FOR_ID(detect_types) + STRUCT_FOR_ID(deterministic) + STRUCT_FOR_ID(device) + STRUCT_FOR_ID(dict) + STRUCT_FOR_ID(dictcomp) + STRUCT_FOR_ID(difference_update) + STRUCT_FOR_ID(digest) + STRUCT_FOR_ID(digest_size) + STRUCT_FOR_ID(digestmod) + STRUCT_FOR_ID(dir_fd) + STRUCT_FOR_ID(discard) + STRUCT_FOR_ID(dispatch_table) + STRUCT_FOR_ID(displayhook) + STRUCT_FOR_ID(dklen) + STRUCT_FOR_ID(doc) + STRUCT_FOR_ID(done) + STRUCT_FOR_ID(dont_inherit) + STRUCT_FOR_ID(dst) + STRUCT_FOR_ID(dst_dir_fd) + STRUCT_FOR_ID(eager_start) + STRUCT_FOR_ID(effective_ids) + STRUCT_FOR_ID(element_factory) + STRUCT_FOR_ID(encode) + STRUCT_FOR_ID(encoding) + STRUCT_FOR_ID(end) + STRUCT_FOR_ID(end_col_offset) + STRUCT_FOR_ID(end_lineno) + STRUCT_FOR_ID(end_offset) + STRUCT_FOR_ID(endpos) + STRUCT_FOR_ID(entrypoint) + STRUCT_FOR_ID(env) + STRUCT_FOR_ID(errors) + STRUCT_FOR_ID(event) + STRUCT_FOR_ID(eventmask) + STRUCT_FOR_ID(exc_type) + STRUCT_FOR_ID(exc_value) + STRUCT_FOR_ID(excepthook) + STRUCT_FOR_ID(exception) + STRUCT_FOR_ID(existing_file_name) + STRUCT_FOR_ID(exp) + STRUCT_FOR_ID(expression) + STRUCT_FOR_ID(extend) + STRUCT_FOR_ID(extra_tokens) + STRUCT_FOR_ID(facility) + STRUCT_FOR_ID(factory) + STRUCT_FOR_ID(false) + STRUCT_FOR_ID(family) + STRUCT_FOR_ID(fanout) + STRUCT_FOR_ID(fd) + STRUCT_FOR_ID(fd2) + STRUCT_FOR_ID(fdel) + STRUCT_FOR_ID(fget) + STRUCT_FOR_ID(fields) + STRUCT_FOR_ID(file) + STRUCT_FOR_ID(file_actions) + STRUCT_FOR_ID(filename) + STRUCT_FOR_ID(fileno) + STRUCT_FOR_ID(filepath) + STRUCT_FOR_ID(fillvalue) + STRUCT_FOR_ID(filter) + STRUCT_FOR_ID(filters) + STRUCT_FOR_ID(final) + STRUCT_FOR_ID(find_class) + STRUCT_FOR_ID(fix_imports) + STRUCT_FOR_ID(flags) + STRUCT_FOR_ID(flush) + STRUCT_FOR_ID(fold) + STRUCT_FOR_ID(follow_symlinks) + STRUCT_FOR_ID(format) + STRUCT_FOR_ID(format_spec) + STRUCT_FOR_ID(frame_buffer) + STRUCT_FOR_ID(from_param) + STRUCT_FOR_ID(fromlist) + STRUCT_FOR_ID(fromtimestamp) + STRUCT_FOR_ID(fromutc) + STRUCT_FOR_ID(fset) + STRUCT_FOR_ID(func) + STRUCT_FOR_ID(future) + STRUCT_FOR_ID(generation) + STRUCT_FOR_ID(genexpr) + STRUCT_FOR_ID(get) + STRUCT_FOR_ID(get_debug) + STRUCT_FOR_ID(get_event_loop) + STRUCT_FOR_ID(get_loop) + STRUCT_FOR_ID(get_source) + STRUCT_FOR_ID(getattr) + STRUCT_FOR_ID(getstate) + STRUCT_FOR_ID(gid) + STRUCT_FOR_ID(globals) + STRUCT_FOR_ID(groupindex) + STRUCT_FOR_ID(groups) + STRUCT_FOR_ID(handle) + STRUCT_FOR_ID(handle_seq) + STRUCT_FOR_ID(has_location) + STRUCT_FOR_ID(hash_name) + STRUCT_FOR_ID(header) + STRUCT_FOR_ID(headers) + STRUCT_FOR_ID(hi) + STRUCT_FOR_ID(hook) + STRUCT_FOR_ID(hour) + STRUCT_FOR_ID(id) + STRUCT_FOR_ID(ident) + STRUCT_FOR_ID(identity_hint) + STRUCT_FOR_ID(ignore) + STRUCT_FOR_ID(imag) + STRUCT_FOR_ID(importlib) + STRUCT_FOR_ID(in_fd) + STRUCT_FOR_ID(incoming) + STRUCT_FOR_ID(index) + STRUCT_FOR_ID(indexgroup) + STRUCT_FOR_ID(inf) + STRUCT_FOR_ID(infer_variance) + STRUCT_FOR_ID(inherit_handle) + STRUCT_FOR_ID(inheritable) + STRUCT_FOR_ID(initial) + STRUCT_FOR_ID(initial_bytes) + STRUCT_FOR_ID(initial_owner) + STRUCT_FOR_ID(initial_state) + STRUCT_FOR_ID(initial_value) + STRUCT_FOR_ID(initval) + STRUCT_FOR_ID(inner_size) + STRUCT_FOR_ID(input) + STRUCT_FOR_ID(insert_comments) + STRUCT_FOR_ID(insert_pis) + STRUCT_FOR_ID(instructions) + STRUCT_FOR_ID(intern) + STRUCT_FOR_ID(intersection) + STRUCT_FOR_ID(interval) + STRUCT_FOR_ID(io) + STRUCT_FOR_ID(is_compress) + STRUCT_FOR_ID(is_raw) + STRUCT_FOR_ID(is_running) + STRUCT_FOR_ID(is_struct) + STRUCT_FOR_ID(isatty) + STRUCT_FOR_ID(isinstance) + STRUCT_FOR_ID(isoformat) + STRUCT_FOR_ID(isolation_level) + STRUCT_FOR_ID(istext) + STRUCT_FOR_ID(item) + STRUCT_FOR_ID(items) + STRUCT_FOR_ID(iter) + STRUCT_FOR_ID(iterable) + STRUCT_FOR_ID(iterations) + STRUCT_FOR_ID(join) + STRUCT_FOR_ID(jump) + STRUCT_FOR_ID(keepends) + STRUCT_FOR_ID(key) + STRUCT_FOR_ID(keyfile) + STRUCT_FOR_ID(keys) + STRUCT_FOR_ID(kind) + STRUCT_FOR_ID(kw) + STRUCT_FOR_ID(kw1) + STRUCT_FOR_ID(kw2) + STRUCT_FOR_ID(kwdefaults) + STRUCT_FOR_ID(label) + STRUCT_FOR_ID(lambda) + STRUCT_FOR_ID(last) + STRUCT_FOR_ID(last_exc) + STRUCT_FOR_ID(last_node) + STRUCT_FOR_ID(last_traceback) + STRUCT_FOR_ID(last_type) + STRUCT_FOR_ID(last_value) + STRUCT_FOR_ID(latin1) + STRUCT_FOR_ID(leaf_size) + STRUCT_FOR_ID(len) + STRUCT_FOR_ID(length) + STRUCT_FOR_ID(level) + STRUCT_FOR_ID(limit) + STRUCT_FOR_ID(line) + STRUCT_FOR_ID(line_buffering) + STRUCT_FOR_ID(lineno) + STRUCT_FOR_ID(listcomp) + STRUCT_FOR_ID(little) + STRUCT_FOR_ID(lo) + STRUCT_FOR_ID(locale) + STRUCT_FOR_ID(locals) + STRUCT_FOR_ID(logoption) + STRUCT_FOR_ID(loop) + STRUCT_FOR_ID(manual_reset) + STRUCT_FOR_ID(mapping) + STRUCT_FOR_ID(match) + STRUCT_FOR_ID(max_length) + STRUCT_FOR_ID(maxdigits) + STRUCT_FOR_ID(maxevents) + STRUCT_FOR_ID(maxlen) + STRUCT_FOR_ID(maxmem) + STRUCT_FOR_ID(maxsplit) + STRUCT_FOR_ID(maxvalue) + STRUCT_FOR_ID(memLevel) + STRUCT_FOR_ID(memlimit) + STRUCT_FOR_ID(message) + STRUCT_FOR_ID(metaclass) + STRUCT_FOR_ID(metadata) + STRUCT_FOR_ID(method) + STRUCT_FOR_ID(microsecond) + STRUCT_FOR_ID(milliseconds) + STRUCT_FOR_ID(minute) + STRUCT_FOR_ID(mod) + STRUCT_FOR_ID(mode) + STRUCT_FOR_ID(module) + STRUCT_FOR_ID(module_globals) + STRUCT_FOR_ID(modules) + STRUCT_FOR_ID(month) + STRUCT_FOR_ID(mro) + STRUCT_FOR_ID(msg) + STRUCT_FOR_ID(mutex) + STRUCT_FOR_ID(mycmp) + STRUCT_FOR_ID(n_arg) + STRUCT_FOR_ID(n_fields) + STRUCT_FOR_ID(n_sequence_fields) + STRUCT_FOR_ID(n_unnamed_fields) + STRUCT_FOR_ID(name) + STRUCT_FOR_ID(name_from) + STRUCT_FOR_ID(namespace_separator) + STRUCT_FOR_ID(namespaces) + STRUCT_FOR_ID(narg) + STRUCT_FOR_ID(ndigits) + STRUCT_FOR_ID(nested) + STRUCT_FOR_ID(new_file_name) + STRUCT_FOR_ID(new_limit) + STRUCT_FOR_ID(newline) + STRUCT_FOR_ID(newlines) + STRUCT_FOR_ID(next) + STRUCT_FOR_ID(nlocals) + STRUCT_FOR_ID(node_depth) + STRUCT_FOR_ID(node_offset) + STRUCT_FOR_ID(ns) + STRUCT_FOR_ID(nstype) + STRUCT_FOR_ID(nt) + STRUCT_FOR_ID(null) + STRUCT_FOR_ID(number) + STRUCT_FOR_ID(obj) + STRUCT_FOR_ID(object) + STRUCT_FOR_ID(offset) + STRUCT_FOR_ID(offset_dst) + STRUCT_FOR_ID(offset_src) + STRUCT_FOR_ID(on_type_read) + STRUCT_FOR_ID(onceregistry) + STRUCT_FOR_ID(only_active_thread) + STRUCT_FOR_ID(only_keys) + STRUCT_FOR_ID(oparg) + STRUCT_FOR_ID(opcode) + STRUCT_FOR_ID(open) + STRUCT_FOR_ID(opener) + STRUCT_FOR_ID(operation) + STRUCT_FOR_ID(optimize) + STRUCT_FOR_ID(options) + STRUCT_FOR_ID(order) + STRUCT_FOR_ID(origin) + STRUCT_FOR_ID(out_fd) + STRUCT_FOR_ID(outgoing) + STRUCT_FOR_ID(outpath) + STRUCT_FOR_ID(overlapped) + STRUCT_FOR_ID(owner) + STRUCT_FOR_ID(pages) + STRUCT_FOR_ID(parameter) + STRUCT_FOR_ID(parent) + STRUCT_FOR_ID(password) + STRUCT_FOR_ID(path) + STRUCT_FOR_ID(pattern) + STRUCT_FOR_ID(peek) + STRUCT_FOR_ID(persistent_id) + STRUCT_FOR_ID(persistent_load) + STRUCT_FOR_ID(person) + STRUCT_FOR_ID(pi_factory) + STRUCT_FOR_ID(pid) + STRUCT_FOR_ID(policy) + STRUCT_FOR_ID(pos) + STRUCT_FOR_ID(pos1) + STRUCT_FOR_ID(pos2) + STRUCT_FOR_ID(posix) + STRUCT_FOR_ID(print_file_and_line) + STRUCT_FOR_ID(priority) + STRUCT_FOR_ID(progress) + STRUCT_FOR_ID(progress_handler) + STRUCT_FOR_ID(progress_routine) + STRUCT_FOR_ID(proto) + STRUCT_FOR_ID(protocol) + STRUCT_FOR_ID(ps1) + STRUCT_FOR_ID(ps2) + STRUCT_FOR_ID(query) + STRUCT_FOR_ID(quotetabs) + STRUCT_FOR_ID(raw) + STRUCT_FOR_ID(read) + STRUCT_FOR_ID(read1) + STRUCT_FOR_ID(readable) + STRUCT_FOR_ID(readall) + STRUCT_FOR_ID(readinto) + STRUCT_FOR_ID(readinto1) + STRUCT_FOR_ID(readline) + STRUCT_FOR_ID(readonly) + STRUCT_FOR_ID(real) + STRUCT_FOR_ID(reducer_override) + STRUCT_FOR_ID(registry) + STRUCT_FOR_ID(rel_tol) + STRUCT_FOR_ID(release) + STRUCT_FOR_ID(reload) + STRUCT_FOR_ID(repl) + STRUCT_FOR_ID(replace) + STRUCT_FOR_ID(reserved) + STRUCT_FOR_ID(reset) + STRUCT_FOR_ID(resetids) + STRUCT_FOR_ID(return) + STRUCT_FOR_ID(reverse) + STRUCT_FOR_ID(reversed) + STRUCT_FOR_ID(salt) + STRUCT_FOR_ID(sched_priority) + STRUCT_FOR_ID(scheduler) + STRUCT_FOR_ID(script) + STRUCT_FOR_ID(second) + STRUCT_FOR_ID(security_attributes) + STRUCT_FOR_ID(seek) + STRUCT_FOR_ID(seekable) + STRUCT_FOR_ID(selectors) + STRUCT_FOR_ID(self) + STRUCT_FOR_ID(send) + STRUCT_FOR_ID(sep) + STRUCT_FOR_ID(sequence) + STRUCT_FOR_ID(server_hostname) + STRUCT_FOR_ID(server_side) + STRUCT_FOR_ID(session) + STRUCT_FOR_ID(setcomp) + STRUCT_FOR_ID(setpgroup) + STRUCT_FOR_ID(setsid) + STRUCT_FOR_ID(setsigdef) + STRUCT_FOR_ID(setsigmask) + STRUCT_FOR_ID(setstate) + STRUCT_FOR_ID(shape) + STRUCT_FOR_ID(show_cmd) + STRUCT_FOR_ID(signed) + STRUCT_FOR_ID(size) + STRUCT_FOR_ID(sizehint) + STRUCT_FOR_ID(skip_file_prefixes) + STRUCT_FOR_ID(sleep) + STRUCT_FOR_ID(sock) + STRUCT_FOR_ID(sort) + STRUCT_FOR_ID(source) + STRUCT_FOR_ID(source_traceback) + STRUCT_FOR_ID(spam) + STRUCT_FOR_ID(src) + STRUCT_FOR_ID(src_dir_fd) + STRUCT_FOR_ID(stacklevel) + STRUCT_FOR_ID(start) + STRUCT_FOR_ID(statement) + STRUCT_FOR_ID(status) + STRUCT_FOR_ID(stderr) + STRUCT_FOR_ID(stdin) + STRUCT_FOR_ID(stdout) + STRUCT_FOR_ID(step) + STRUCT_FOR_ID(steps) + STRUCT_FOR_ID(store_name) + STRUCT_FOR_ID(strategy) + STRUCT_FOR_ID(strftime) + STRUCT_FOR_ID(strict) + STRUCT_FOR_ID(strict_mode) + STRUCT_FOR_ID(string) + STRUCT_FOR_ID(sub_key) + STRUCT_FOR_ID(subcalls) + STRUCT_FOR_ID(symmetric_difference_update) + STRUCT_FOR_ID(tabsize) + STRUCT_FOR_ID(tag) + STRUCT_FOR_ID(target) + STRUCT_FOR_ID(target_is_directory) + STRUCT_FOR_ID(task) + STRUCT_FOR_ID(tb_frame) + STRUCT_FOR_ID(tb_lasti) + STRUCT_FOR_ID(tb_lineno) + STRUCT_FOR_ID(tb_next) + STRUCT_FOR_ID(tell) + STRUCT_FOR_ID(template) + STRUCT_FOR_ID(term) + STRUCT_FOR_ID(text) + STRUCT_FOR_ID(threading) + STRUCT_FOR_ID(throw) + STRUCT_FOR_ID(timeout) + STRUCT_FOR_ID(timer) + STRUCT_FOR_ID(times) + STRUCT_FOR_ID(timetuple) + STRUCT_FOR_ID(timeunit) + STRUCT_FOR_ID(top) + STRUCT_FOR_ID(trace_callback) + STRUCT_FOR_ID(traceback) + STRUCT_FOR_ID(trailers) + STRUCT_FOR_ID(translate) + STRUCT_FOR_ID(true) + STRUCT_FOR_ID(truncate) + STRUCT_FOR_ID(twice) + STRUCT_FOR_ID(txt) + STRUCT_FOR_ID(type) + STRUCT_FOR_ID(type_params) + STRUCT_FOR_ID(tz) + STRUCT_FOR_ID(tzinfo) + STRUCT_FOR_ID(tzname) + STRUCT_FOR_ID(uid) + STRUCT_FOR_ID(unlink) + STRUCT_FOR_ID(unraisablehook) + STRUCT_FOR_ID(uri) + STRUCT_FOR_ID(usedforsecurity) + STRUCT_FOR_ID(value) + STRUCT_FOR_ID(values) + STRUCT_FOR_ID(version) + STRUCT_FOR_ID(volume) + STRUCT_FOR_ID(wait_all) + STRUCT_FOR_ID(warn_on_full_buffer) + STRUCT_FOR_ID(warnings) + STRUCT_FOR_ID(warnoptions) + STRUCT_FOR_ID(wbits) + STRUCT_FOR_ID(week) + STRUCT_FOR_ID(weekday) + STRUCT_FOR_ID(which) + STRUCT_FOR_ID(who) + STRUCT_FOR_ID(withdata) + STRUCT_FOR_ID(writable) + STRUCT_FOR_ID(write) + STRUCT_FOR_ID(write_through) + STRUCT_FOR_ID(year) + STRUCT_FOR_ID(zdict) + STRUCT_FOR_ID(zstd_dict) + } identifiers; + struct { + PyASCIIObject _ascii; + uint8_t _data[2]; + } ascii[128]; + struct { + PyCompactUnicodeObject _latin1; + uint8_t _data[2]; + } latin1[128]; +}; +/* End auto-generated code */ + +#undef ID +#undef STR + + +#define _Py_ID(NAME) \ + (_Py_SINGLETON(strings.identifiers._py_ ## NAME._ascii.ob_base)) +#define _Py_STR(NAME) \ + (_Py_SINGLETON(strings.literals._py_ ## NAME._ascii.ob_base)) +#define _Py_LATIN1_CHR(CH) \ + ((CH) < 128 \ + ? (PyObject*)&_Py_SINGLETON(strings).ascii[(CH)] \ + : (PyObject*)&_Py_SINGLETON(strings).latin1[(CH) - 128]) + +/* _Py_DECLARE_STR() should precede all uses of _Py_STR() in a function. + + This is true even if the same string has already been declared + elsewhere, even in the same file. Mismatched duplicates are detected + by Tools/scripts/generate-global-objects.py. + + Pairing _Py_DECLARE_STR() with every use of _Py_STR() makes sure the + string keeps working even if the declaration is removed somewhere + else. It also makes it clear what the actual string is at every + place it is being used. */ +#define _Py_DECLARE_STR(name, str) + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_GLOBAL_STRINGS_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_hamt.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_hamt.h new file mode 100644 index 0000000000000000000000000000000000000000..f973ce6dcb20e08ad16ea8108ea72663db69c64b --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_hamt.h @@ -0,0 +1,113 @@ +#ifndef Py_INTERNAL_HAMT_H +#define Py_INTERNAL_HAMT_H + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_structs.h" // PyHamtNode + +/* +HAMT tree is shaped by hashes of keys. Every group of 5 bits of a hash denotes +the exact position of the key in one level of the tree. Since we're using +32 bit hashes, we can have at most 7 such levels. Although if there are +two distinct keys with equal hashes, they will have to occupy the same +cell in the 7th level of the tree -- so we'd put them in a "collision" node. +Which brings the total possible tree depth to 8. Read more about the actual +layout of the HAMT tree in `hamt.c`. + +This constant is used to define a datastucture for storing iteration state. +*/ +#define _Py_HAMT_MAX_TREE_DEPTH 8 + + +extern PyTypeObject _PyHamt_Type; +extern PyTypeObject _PyHamt_ArrayNode_Type; +extern PyTypeObject _PyHamt_BitmapNode_Type; +extern PyTypeObject _PyHamt_CollisionNode_Type; +extern PyTypeObject _PyHamtKeys_Type; +extern PyTypeObject _PyHamtValues_Type; +extern PyTypeObject _PyHamtItems_Type; + + +/* other API */ + +#define PyHamt_Check(o) Py_IS_TYPE((o), &_PyHamt_Type) + + +/* A struct to hold the state of depth-first traverse of the tree. + + HAMT is an immutable collection. Iterators will hold a strong reference + to it, and every node in the HAMT has strong references to its children. + + So for iterators, we can implement zero allocations and zero reference + inc/dec depth-first iteration. + + - i_nodes: an array of seven pointers to tree nodes + - i_level: the current node in i_nodes + - i_pos: an array of positions within nodes in i_nodes. +*/ +typedef struct { + PyHamtNode *i_nodes[_Py_HAMT_MAX_TREE_DEPTH]; + Py_ssize_t i_pos[_Py_HAMT_MAX_TREE_DEPTH]; + int8_t i_level; +} PyHamtIteratorState; + + +/* Base iterator object. + + Contains the iteration state, a pointer to the HAMT tree, + and a pointer to the 'yield function'. The latter is a simple + function that returns a key/value tuple for the 'Items' iterator, + just a key for the 'Keys' iterator, and a value for the 'Values' + iterator. +*/ +typedef struct { + PyObject_HEAD + PyHamtObject *hi_obj; + PyHamtIteratorState hi_iter; + binaryfunc hi_yield; +} PyHamtIterator; + + +/* Create a new HAMT immutable mapping. */ +PyHamtObject * _PyHamt_New(void); + +/* Return a new collection based on "o", but with an additional + key/val pair. */ +PyHamtObject * _PyHamt_Assoc(PyHamtObject *o, PyObject *key, PyObject *val); + +/* Return a new collection based on "o", but without "key". */ +PyHamtObject * _PyHamt_Without(PyHamtObject *o, PyObject *key); + +/* Find "key" in the "o" collection. + + Return: + - -1: An error occurred. + - 0: "key" wasn't found in "o". + - 1: "key" is in "o"; "*val" is set to its value (a borrowed ref). +*/ +int _PyHamt_Find(PyHamtObject *o, PyObject *key, PyObject **val); + +/* Check if "v" is equal to "w". + + Return: + - 0: v != w + - 1: v == w + - -1: An error occurred. +*/ +int _PyHamt_Eq(PyHamtObject *v, PyHamtObject *w); + +/* Return the size of "o"; equivalent of "len(o)". */ +Py_ssize_t _PyHamt_Len(PyHamtObject *o); + +/* Return a Keys iterator over "o". */ +PyObject * _PyHamt_NewIterKeys(PyHamtObject *o); + +/* Return a Values iterator over "o". */ +PyObject * _PyHamt_NewIterValues(PyHamtObject *o); + +/* Return a Items iterator over "o". */ +PyObject * _PyHamt_NewIterItems(PyHamtObject *o); + +#endif /* !Py_INTERNAL_HAMT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_hashtable.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_hashtable.h new file mode 100644 index 0000000000000000000000000000000000000000..369d49c42bbfccde2e72c2adf5611a5322fb06c6 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_hashtable.h @@ -0,0 +1,150 @@ +#ifndef Py_INTERNAL_HASHTABLE_H +#define Py_INTERNAL_HASHTABLE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* Single linked list */ + +typedef struct _Py_slist_item_s { + struct _Py_slist_item_s *next; +} _Py_slist_item_t; + +typedef struct { + _Py_slist_item_t *head; +} _Py_slist_t; + +#define _Py_SLIST_ITEM_NEXT(ITEM) _Py_RVALUE(((_Py_slist_item_t *)(ITEM))->next) + +#define _Py_SLIST_HEAD(SLIST) _Py_RVALUE(((_Py_slist_t *)(SLIST))->head) + + +/* _Py_hashtable: table entry */ + +typedef struct { + /* used by _Py_hashtable_t.buckets to link entries */ + _Py_slist_item_t _Py_slist_item; + + Py_uhash_t key_hash; + void *key; + void *value; +} _Py_hashtable_entry_t; + + +/* _Py_hashtable: prototypes */ + +/* Forward declaration */ +struct _Py_hashtable_t; +typedef struct _Py_hashtable_t _Py_hashtable_t; + +typedef Py_uhash_t (*_Py_hashtable_hash_func) (const void *key); +typedef int (*_Py_hashtable_compare_func) (const void *key1, const void *key2); +typedef void (*_Py_hashtable_destroy_func) (void *key); +typedef _Py_hashtable_entry_t* (*_Py_hashtable_get_entry_func)(_Py_hashtable_t *ht, + const void *key); + +typedef struct { + // Allocate a memory block + void* (*malloc) (size_t size); + + // Release a memory block + void (*free) (void *ptr); +} _Py_hashtable_allocator_t; + + +/* _Py_hashtable: table */ +struct _Py_hashtable_t { + size_t nentries; // Total number of entries in the table + size_t nbuckets; + _Py_slist_t *buckets; + + _Py_hashtable_get_entry_func get_entry_func; + _Py_hashtable_hash_func hash_func; + _Py_hashtable_compare_func compare_func; + _Py_hashtable_destroy_func key_destroy_func; + _Py_hashtable_destroy_func value_destroy_func; + _Py_hashtable_allocator_t alloc; +}; + +// Export _Py_hashtable functions for '_testinternalcapi' shared extension +PyAPI_FUNC(_Py_hashtable_t *) _Py_hashtable_new( + _Py_hashtable_hash_func hash_func, + _Py_hashtable_compare_func compare_func); + +/* Hash a pointer (void*) */ +PyAPI_FUNC(Py_uhash_t) _Py_hashtable_hash_ptr(const void *key); + +/* Comparison using memcmp() */ +PyAPI_FUNC(int) _Py_hashtable_compare_direct( + const void *key1, + const void *key2); + +PyAPI_FUNC(_Py_hashtable_t *) _Py_hashtable_new_full( + _Py_hashtable_hash_func hash_func, + _Py_hashtable_compare_func compare_func, + _Py_hashtable_destroy_func key_destroy_func, + _Py_hashtable_destroy_func value_destroy_func, + _Py_hashtable_allocator_t *allocator); + +PyAPI_FUNC(void) _Py_hashtable_destroy(_Py_hashtable_t *ht); + +PyAPI_FUNC(void) _Py_hashtable_clear(_Py_hashtable_t *ht); + +typedef int (*_Py_hashtable_foreach_func) (_Py_hashtable_t *ht, + const void *key, const void *value, + void *user_data); + +/* Call func() on each entry of the hashtable. + Iteration stops if func() result is non-zero, in this case it's the result + of the call. Otherwise, the function returns 0. */ +PyAPI_FUNC(int) _Py_hashtable_foreach( + _Py_hashtable_t *ht, + _Py_hashtable_foreach_func func, + void *user_data); + +PyAPI_FUNC(size_t) _Py_hashtable_size(const _Py_hashtable_t *ht); +PyAPI_FUNC(size_t) _Py_hashtable_len(const _Py_hashtable_t *ht); + +/* Add a new entry to the hash. The key must not be present in the hash table. + Return 0 on success, -1 on memory error. */ +PyAPI_FUNC(int) _Py_hashtable_set( + _Py_hashtable_t *ht, + const void *key, + void *value); + + +/* Get an entry. + Return NULL if the key does not exist. */ +static inline _Py_hashtable_entry_t * +_Py_hashtable_get_entry(_Py_hashtable_t *ht, const void *key) +{ + return ht->get_entry_func(ht, key); +} + + +/* Get value from an entry. + Return NULL if the entry is not found. + + Use _Py_hashtable_get_entry() to distinguish entry value equal to NULL + and entry not found. */ +PyAPI_FUNC(void*) _Py_hashtable_get(_Py_hashtable_t *ht, const void *key); + + +/* Remove a key and its associated value without calling key and value destroy + functions. + + Return the removed value if the key was found. + Return NULL if the key was not found. */ +PyAPI_FUNC(void*) _Py_hashtable_steal( + _Py_hashtable_t *ht, + const void *key); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_HASHTABLE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_import.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_import.h new file mode 100644 index 0000000000000000000000000000000000000000..13fbff4eb65cb2aa20b4ee9984472bbe9eb9a126 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_import.h @@ -0,0 +1,141 @@ +#ifndef Py_LIMITED_API +#ifndef Py_INTERNAL_IMPORT_H +#define Py_INTERNAL_IMPORT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_hashtable.h" // _Py_hashtable_t +#include "pycore_interp_structs.h" // _import_state + +extern int _PyImport_IsInitialized(PyInterpreterState *); + +// Export for 'pyexpat' shared extension +PyAPI_FUNC(int) _PyImport_SetModule(PyObject *name, PyObject *module); + +extern int _PyImport_SetModuleString(const char *name, PyObject* module); + +extern void _PyImport_AcquireLock(PyInterpreterState *interp); +extern void _PyImport_ReleaseLock(PyInterpreterState *interp); +extern void _PyImport_ReInitLock(PyInterpreterState *interp); + +// This is used exclusively for the sys and builtins modules: +extern int _PyImport_FixupBuiltin( + PyThreadState *tstate, + PyObject *mod, + const char *name, /* UTF-8 encoded string */ + PyObject *modules + ); + +#ifdef HAVE_DLOPEN +# include // RTLD_NOW, RTLD_LAZY +# if HAVE_DECL_RTLD_NOW +# define _Py_DLOPEN_FLAGS RTLD_NOW +# else +# define _Py_DLOPEN_FLAGS RTLD_LAZY +# endif +# define DLOPENFLAGS_INIT .dlopenflags = _Py_DLOPEN_FLAGS, +#else +# define _Py_DLOPEN_FLAGS 0 +# define DLOPENFLAGS_INIT +#endif + +#define IMPORTS_INIT \ + { \ + DLOPENFLAGS_INIT \ + .find_and_load = { \ + .header = 1, \ + }, \ + } + +extern void _PyImport_ClearCore(PyInterpreterState *interp); + +extern Py_ssize_t _PyImport_GetNextModuleIndex(void); +extern const char * _PyImport_ResolveNameWithPackageContext(const char *name); +extern const char * _PyImport_SwapPackageContext(const char *newcontext); + +extern int _PyImport_GetDLOpenFlags(PyInterpreterState *interp); +extern void _PyImport_SetDLOpenFlags(PyInterpreterState *interp, int new_val); + +extern PyObject * _PyImport_InitModules(PyInterpreterState *interp); +extern PyObject * _PyImport_GetModules(PyInterpreterState *interp); +extern PyObject * _PyImport_GetModulesRef(PyInterpreterState *interp); +extern void _PyImport_ClearModules(PyInterpreterState *interp); + +extern void _PyImport_ClearModulesByIndex(PyInterpreterState *interp); + +extern int _PyImport_InitDefaultImportFunc(PyInterpreterState *interp); +extern int _PyImport_IsDefaultImportFunc( + PyInterpreterState *interp, + PyObject *func); + +extern PyObject * _PyImport_GetImportlibLoader( + PyInterpreterState *interp, + const char *loader_name); +extern PyObject * _PyImport_GetImportlibExternalLoader( + PyInterpreterState *interp, + const char *loader_name); +extern PyObject * _PyImport_BlessMyLoader( + PyInterpreterState *interp, + PyObject *module_globals); +extern PyObject * _PyImport_ImportlibModuleRepr( + PyInterpreterState *interp, + PyObject *module); + + +extern PyStatus _PyImport_Init(void); +extern void _PyImport_Fini(void); +extern void _PyImport_Fini2(void); + +extern PyStatus _PyImport_InitCore( + PyThreadState *tstate, + PyObject *sysmod, + int importlib); +extern PyStatus _PyImport_InitExternal(PyThreadState *tstate); +extern void _PyImport_FiniCore(PyInterpreterState *interp); +extern void _PyImport_FiniExternal(PyInterpreterState *interp); + + +extern PyObject* _PyImport_GetBuiltinModuleNames(void); + +struct _module_alias { + const char *name; /* ASCII encoded string */ + const char *orig; /* ASCII encoded string */ +}; + +// Export these 3 symbols for test_ctypes +PyAPI_DATA(const struct _frozen*) _PyImport_FrozenBootstrap; +PyAPI_DATA(const struct _frozen*) _PyImport_FrozenStdlib; +PyAPI_DATA(const struct _frozen*) _PyImport_FrozenTest; + +extern const struct _module_alias * _PyImport_FrozenAliases; + +extern int _PyImport_CheckSubinterpIncompatibleExtensionAllowed( + const char *name); + + +// Export for '_testinternalcapi' shared extension +PyAPI_FUNC(int) _PyImport_ClearExtension(PyObject *name, PyObject *filename); + +#ifdef Py_GIL_DISABLED +// Assuming that the GIL is enabled from a call to +// _PyEval_EnableGILTransient(), resolve the transient request depending on the +// state of the module argument: +// - If module is NULL or a PyModuleObject with md_gil == Py_MOD_GIL_NOT_USED, +// call _PyEval_DisableGIL(). +// - Otherwise, call _PyEval_EnableGILPermanent(). If the GIL was not already +// enabled permanently, issue a warning referencing the module's name. +// +// This function may raise an exception. +extern int _PyImport_CheckGILForModule(PyObject *module, PyObject *module_name); +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_IMPORT_H */ +#endif /* !Py_LIMITED_API */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_importdl.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_importdl.h new file mode 100644 index 0000000000000000000000000000000000000000..525a16f6b97274668ac9b4f8b4fd90502c8f10dd --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_importdl.h @@ -0,0 +1,139 @@ +#ifndef Py_INTERNAL_IMPORTDL_H +#define Py_INTERNAL_IMPORTDL_H + +#include "patchlevel.h" // PY_MAJOR_VERSION + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + + +extern const char *_PyImport_DynLoadFiletab[]; + + +typedef enum ext_module_kind { + _Py_ext_module_kind_UNKNOWN = 0, + _Py_ext_module_kind_SINGLEPHASE = 1, + _Py_ext_module_kind_MULTIPHASE = 2, + _Py_ext_module_kind_INVALID = 3, +} _Py_ext_module_kind; + +typedef enum ext_module_origin { + _Py_ext_module_origin_CORE = 1, + _Py_ext_module_origin_BUILTIN = 2, + _Py_ext_module_origin_DYNAMIC = 3, +} _Py_ext_module_origin; + +/* Input for loading an extension module. */ +struct _Py_ext_module_loader_info { + PyObject *filename; +#ifndef MS_WINDOWS + PyObject *filename_encoded; +#endif + PyObject *name; + PyObject *name_encoded; + /* path is always a borrowed ref of name or filename, + * depending on if it's builtin or not. */ + PyObject *path; + _Py_ext_module_origin origin; + const char *hook_prefix; + const char *newcontext; +}; +extern void _Py_ext_module_loader_info_clear( + struct _Py_ext_module_loader_info *info); +extern int _Py_ext_module_loader_info_init( + struct _Py_ext_module_loader_info *info, + PyObject *name, + PyObject *filename, + _Py_ext_module_origin origin); +extern int _Py_ext_module_loader_info_init_for_core( + struct _Py_ext_module_loader_info *p_info, + PyObject *name); +extern int _Py_ext_module_loader_info_init_for_builtin( + struct _Py_ext_module_loader_info *p_info, + PyObject *name); +#ifdef HAVE_DYNAMIC_LOADING +extern int _Py_ext_module_loader_info_init_from_spec( + struct _Py_ext_module_loader_info *info, + PyObject *spec); +#endif + +/* The result from running an extension module's init function. */ +struct _Py_ext_module_loader_result { + PyModuleDef *def; + PyObject *module; + _Py_ext_module_kind kind; + struct _Py_ext_module_loader_result_error *err; + struct _Py_ext_module_loader_result_error { + enum _Py_ext_module_loader_result_error_kind { + _Py_ext_module_loader_result_EXCEPTION = 0, + _Py_ext_module_loader_result_ERR_MISSING = 1, + _Py_ext_module_loader_result_ERR_UNREPORTED_EXC = 2, + _Py_ext_module_loader_result_ERR_UNINITIALIZED = 3, + _Py_ext_module_loader_result_ERR_NONASCII_NOT_MULTIPHASE = 4, + _Py_ext_module_loader_result_ERR_NOT_MODULE = 5, + _Py_ext_module_loader_result_ERR_MISSING_DEF = 6, + } kind; + PyObject *exc; + } _err; +}; +extern void _Py_ext_module_loader_result_clear( + struct _Py_ext_module_loader_result *res); +extern void _Py_ext_module_loader_result_apply_error( + struct _Py_ext_module_loader_result *res, + const char *name); + +/* The module init function. */ +typedef PyObject *(*PyModInitFunction)(void); +#ifdef HAVE_DYNAMIC_LOADING +extern PyModInitFunction _PyImport_GetModInitFunc( + struct _Py_ext_module_loader_info *info, + FILE *fp); +#endif +extern int _PyImport_RunModInitFunc( + PyModInitFunction p0, + struct _Py_ext_module_loader_info *info, + struct _Py_ext_module_loader_result *p_res); + + +/* Max length of module suffix searched for -- accommodates "module.slb" */ +#define MAXSUFFIXSIZE 12 + +#ifdef MS_WINDOWS +#include +typedef FARPROC dl_funcptr; + +#ifdef _DEBUG +# define PYD_DEBUG_SUFFIX "_d" +#else +# define PYD_DEBUG_SUFFIX "" +#endif + +#ifdef Py_GIL_DISABLED +# define PYD_THREADING_TAG "t" +#else +# define PYD_THREADING_TAG "" +#endif + +#ifdef PYD_PLATFORM_TAG +# define PYD_SOABI "cp" Py_STRINGIFY(PY_MAJOR_VERSION) Py_STRINGIFY(PY_MINOR_VERSION) PYD_THREADING_TAG "-" PYD_PLATFORM_TAG +#else +# define PYD_SOABI "cp" Py_STRINGIFY(PY_MAJOR_VERSION) Py_STRINGIFY(PY_MINOR_VERSION) PYD_THREADING_TAG +#endif + +#define PYD_TAGGED_SUFFIX PYD_DEBUG_SUFFIX "." PYD_SOABI ".pyd" +#define PYD_UNTAGGED_SUFFIX PYD_DEBUG_SUFFIX ".pyd" + +#else +typedef void (*dl_funcptr)(void); +#endif + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_IMPORTDL_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_index_pool.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_index_pool.h new file mode 100644 index 0000000000000000000000000000000000000000..2ce06be48c537968182efd79bdb6e2764411bce0 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_index_pool.h @@ -0,0 +1,36 @@ +#ifndef Py_INTERNAL_INDEX_POOL_H +#define Py_INTERNAL_INDEX_POOL_H + +#include "Python.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#ifdef Py_GIL_DISABLED + +#include "pycore_interp_structs.h" + +// This contains code for allocating unique indices in an array. It is used by +// the free-threaded build to assign each thread a globally unique index into +// each code object's thread-local bytecode array. + + +// Allocate the smallest available index. Returns -1 on error. +extern int32_t _PyIndexPool_AllocIndex(_PyIndexPool *indices); + +// Release `index` back to the pool +extern void _PyIndexPool_FreeIndex(_PyIndexPool *indices, int32_t index); + +extern void _PyIndexPool_Fini(_PyIndexPool *indices); + +#endif // Py_GIL_DISABLED + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_INDEX_POOL_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_initconfig.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_initconfig.h new file mode 100644 index 0000000000000000000000000000000000000000..183b2d45c5ede1c569f333eb15a76f0498268da8 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_initconfig.h @@ -0,0 +1,197 @@ +#ifndef Py_INTERNAL_CORECONFIG_H +#define Py_INTERNAL_CORECONFIG_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_typedefs.h" // _PyRuntimeState + +/* --- PyStatus ----------------------------------------------- */ + +/* Almost all errors causing Python initialization to fail */ +#ifdef _MSC_VER + /* Visual Studio 2015 doesn't implement C99 __func__ in C */ +# define _PyStatus_GET_FUNC() __FUNCTION__ +#else +# define _PyStatus_GET_FUNC() __func__ +#endif + +#define _PyStatus_OK() \ + (PyStatus){._type = _PyStatus_TYPE_OK} + /* other fields are set to 0 */ +#define _PyStatus_ERR(ERR_MSG) \ + (PyStatus){ \ + ._type = _PyStatus_TYPE_ERROR, \ + .func = _PyStatus_GET_FUNC(), \ + .err_msg = (ERR_MSG)} + /* other fields are set to 0 */ +#define _PyStatus_NO_MEMORY_ERRMSG "memory allocation failed" +#define _PyStatus_NO_MEMORY() _PyStatus_ERR(_PyStatus_NO_MEMORY_ERRMSG) +#define _PyStatus_EXIT(EXITCODE) \ + (PyStatus){ \ + ._type = _PyStatus_TYPE_EXIT, \ + .exitcode = (EXITCODE)} +#define _PyStatus_IS_ERROR(err) \ + ((err)._type == _PyStatus_TYPE_ERROR) +#define _PyStatus_IS_EXIT(err) \ + ((err)._type == _PyStatus_TYPE_EXIT) +#define _PyStatus_EXCEPTION(err) \ + ((err)._type != _PyStatus_TYPE_OK) +#define _PyStatus_UPDATE_FUNC(err) \ + do { (err).func = _PyStatus_GET_FUNC(); } while (0) + +// Export for '_testinternalcapi' shared extension +PyAPI_FUNC(void) _PyErr_SetFromPyStatus(PyStatus status); + + +/* --- PyWideStringList ------------------------------------------------ */ + +#define _PyWideStringList_INIT (PyWideStringList){.length = 0, .items = NULL} + +#ifndef NDEBUG +extern int _PyWideStringList_CheckConsistency(const PyWideStringList *list); +#endif +extern void _PyWideStringList_Clear(PyWideStringList *list); +extern int _PyWideStringList_Copy(PyWideStringList *list, + const PyWideStringList *list2); +extern PyStatus _PyWideStringList_Extend(PyWideStringList *list, + const PyWideStringList *list2); +extern PyObject* _PyWideStringList_AsList(const PyWideStringList *list); + + +/* --- _PyArgv ---------------------------------------------------- */ + +typedef struct _PyArgv { + Py_ssize_t argc; + int use_bytes_argv; + char * const *bytes_argv; + wchar_t * const *wchar_argv; +} _PyArgv; + +extern PyStatus _PyArgv_AsWstrList(const _PyArgv *args, + PyWideStringList *list); + + +/* --- Helper functions ------------------------------------------- */ + +extern int _Py_str_to_int( + const char *str, + int *result); +extern const wchar_t* _Py_get_xoption( + const PyWideStringList *xoptions, + const wchar_t *name); +extern const char* _Py_GetEnv( + int use_environment, + const char *name); +extern void _Py_get_env_flag( + int use_environment, + int *flag, + const char *name); + +/* Py_GetArgcArgv() helper */ +extern void _Py_ClearArgcArgv(void); + + +/* --- _PyPreCmdline ------------------------------------------------- */ + +typedef struct { + PyWideStringList argv; + PyWideStringList xoptions; /* "-X value" option */ + int isolated; /* -I option */ + int use_environment; /* -E option */ + int dev_mode; /* -X dev and PYTHONDEVMODE */ + int warn_default_encoding; /* -X warn_default_encoding and PYTHONWARNDEFAULTENCODING */ +} _PyPreCmdline; + +#define _PyPreCmdline_INIT \ + (_PyPreCmdline){ \ + .use_environment = -1, \ + .isolated = -1, \ + .dev_mode = -1} +/* Note: _PyPreCmdline_INIT sets other fields to 0/NULL */ + +extern void _PyPreCmdline_Clear(_PyPreCmdline *cmdline); +extern PyStatus _PyPreCmdline_SetArgv(_PyPreCmdline *cmdline, + const _PyArgv *args); +extern PyStatus _PyPreCmdline_SetConfig( + const _PyPreCmdline *cmdline, + PyConfig *config); +extern PyStatus _PyPreCmdline_Read(_PyPreCmdline *cmdline, + const PyPreConfig *preconfig); + + +/* --- PyPreConfig ----------------------------------------------- */ + +// Export for '_testembed' program +PyAPI_FUNC(void) _PyPreConfig_InitCompatConfig(PyPreConfig *preconfig); + +extern void _PyPreConfig_InitFromConfig( + PyPreConfig *preconfig, + const PyConfig *config); +extern PyStatus _PyPreConfig_InitFromPreConfig( + PyPreConfig *preconfig, + const PyPreConfig *config2); +extern PyObject* _PyPreConfig_AsDict(const PyPreConfig *preconfig); +extern void _PyPreConfig_GetConfig(PyPreConfig *preconfig, + const PyConfig *config); +extern PyStatus _PyPreConfig_Read(PyPreConfig *preconfig, + const _PyArgv *args); +extern PyStatus _PyPreConfig_Write(const PyPreConfig *preconfig); + + +/* --- PyConfig ---------------------------------------------- */ + +typedef enum { + /* Py_Initialize() API: backward compatibility with Python 3.6 and 3.7 */ + _PyConfig_INIT_COMPAT = 1, + _PyConfig_INIT_PYTHON = 2, + _PyConfig_INIT_ISOLATED = 3 +} _PyConfigInitEnum; + +typedef enum { + /* In free threaded builds, this means that the GIL is disabled at startup, + but may be enabled by loading an incompatible extension module. */ + _PyConfig_GIL_DEFAULT = -1, + + /* The GIL has been forced off or on, and will not be affected by module loading. */ + _PyConfig_GIL_DISABLE = 0, + _PyConfig_GIL_ENABLE = 1, +} _PyConfigGILEnum; + +// Export for '_testembed' program +PyAPI_FUNC(void) _PyConfig_InitCompatConfig(PyConfig *config); + +extern PyStatus _PyConfig_Copy( + PyConfig *config, + const PyConfig *config2); +extern PyStatus _PyConfig_InitPathConfig( + PyConfig *config, + int compute_path_config); +extern PyStatus _PyConfig_InitImportConfig(PyConfig *config); +extern PyStatus _PyConfig_Read(PyConfig *config, int compute_path_config); +extern PyStatus _PyConfig_Write(const PyConfig *config, + _PyRuntimeState *runtime); +extern PyStatus _PyConfig_SetPyArgv( + PyConfig *config, + const _PyArgv *args); +extern PyObject* _PyConfig_CreateXOptionsDict(const PyConfig *config); + +extern void _Py_DumpPathConfig(PyThreadState *tstate); + + +/* --- Function used for testing ---------------------------------- */ + +// Export these functions for '_testinternalcapi' shared extension +PyAPI_FUNC(PyObject*) _PyConfig_AsDict(const PyConfig *config); +PyAPI_FUNC(int) _PyConfig_FromDict(PyConfig *config, PyObject *dict); +PyAPI_FUNC(PyObject*) _Py_Get_Getpath_CodeObject(void); +PyAPI_FUNC(PyObject*) _Py_GetConfigsAsDict(void); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_CORECONFIG_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_instruction_sequence.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_instruction_sequence.h new file mode 100644 index 0000000000000000000000000000000000000000..b5c927735374bebf4ff09d45f279c8c72db94144 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_instruction_sequence.h @@ -0,0 +1,83 @@ +#ifndef Py_INTERNAL_INSTRUCTION_SEQUENCE_H +#define Py_INTERNAL_INSTRUCTION_SEQUENCE_H + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_symtable.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +typedef struct { + int h_label; + int h_startdepth; + int h_preserve_lasti; +} _PyExceptHandlerInfo; + +typedef struct { + int i_opcode; + int i_oparg; + _Py_SourceLocation i_loc; + _PyExceptHandlerInfo i_except_handler_info; + + /* Temporary fields, used by the assembler and in instr_sequence_to_cfg */ + int i_target; + int i_offset; +} _PyInstruction; + +typedef struct instruction_sequence { + PyObject_HEAD + _PyInstruction *s_instrs; + int s_allocated; + int s_used; + + int s_next_free_label; /* next free label id */ + + /* Map of a label id to instruction offset (index into s_instrs). + * If s_labelmap is NULL, then each label id is the offset itself. + */ + int *s_labelmap; + int s_labelmap_size; + + /* PyList of instruction sequences of nested functions */ + PyObject *s_nested; + + /* Code for creating annotations, spliced into the main sequence later */ + struct instruction_sequence *s_annotations_code; +} _PyInstructionSequence; + +typedef struct { + int id; +} _PyJumpTargetLabel; + +#define NO_LABEL ((const _PyJumpTargetLabel){-1}) + +#define SAME_JUMP_TARGET_LABEL(L1, L2) ((L1).id == (L2).id) +#define IS_JUMP_TARGET_LABEL(L) (!SAME_JUMP_TARGET_LABEL((L), (NO_LABEL))) + +PyAPI_FUNC(PyObject*)_PyInstructionSequence_New(void); + +int _PyInstructionSequence_UseLabel(_PyInstructionSequence *seq, int lbl); +int _PyInstructionSequence_Addop(_PyInstructionSequence *seq, + int opcode, int oparg, + _Py_SourceLocation loc); +_PyJumpTargetLabel _PyInstructionSequence_NewLabel(_PyInstructionSequence *seq); +int _PyInstructionSequence_ApplyLabelMap(_PyInstructionSequence *seq); +int _PyInstructionSequence_InsertInstruction(_PyInstructionSequence *seq, int pos, + int opcode, int oparg, _Py_SourceLocation loc); +int _PyInstructionSequence_SetAnnotationsCode(_PyInstructionSequence *seq, + _PyInstructionSequence *annotations); +int _PyInstructionSequence_AddNested(_PyInstructionSequence *seq, _PyInstructionSequence *nested); +void PyInstructionSequence_Fini(_PyInstructionSequence *seq); + +extern PyTypeObject _PyInstructionSequence_Type; +#define _PyInstructionSequence_Check(v) Py_IS_TYPE((v), &_PyInstructionSequence_Type) + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_INSTRUCTION_SEQUENCE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_instruments.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_instruments.h new file mode 100644 index 0000000000000000000000000000000000000000..7658adca719e86dbfa09366e52eb10f318e6d920 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_instruments.h @@ -0,0 +1,127 @@ +#ifndef Py_INTERNAL_INSTRUMENT_H +#define Py_INTERNAL_INSTRUMENT_H + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_structs.h" // _Py_CODEUNIT +#include "pycore_typedefs.h" // _PyInterpreterFrame + +#ifdef __cplusplus +extern "C" { +#endif + +typedef uint32_t _PyMonitoringEventSet; + +/* Tool IDs */ + +/* These are defined in PEP 669 for convenience to avoid clashes */ +#define PY_MONITORING_DEBUGGER_ID 0 +#define PY_MONITORING_COVERAGE_ID 1 +#define PY_MONITORING_PROFILER_ID 2 +#define PY_MONITORING_OPTIMIZER_ID 5 + +/* Internal IDs used to support sys.setprofile() and sys.settrace() */ +#define PY_MONITORING_SYS_PROFILE_ID 6 +#define PY_MONITORING_SYS_TRACE_ID 7 + + +PyObject *_PyMonitoring_RegisterCallback(int tool_id, int event_id, PyObject *obj); + +int _PyMonitoring_SetEvents(int tool_id, _PyMonitoringEventSet events); +int _PyMonitoring_SetLocalEvents(PyCodeObject *code, int tool_id, _PyMonitoringEventSet events); +int _PyMonitoring_GetLocalEvents(PyCodeObject *code, int tool_id, _PyMonitoringEventSet *events); + +extern int +_Py_call_instrumentation(PyThreadState *tstate, int event, + _PyInterpreterFrame *frame, _Py_CODEUNIT *instr); + +extern int +_Py_call_instrumentation_line(PyThreadState *tstate, _PyInterpreterFrame* frame, + _Py_CODEUNIT *instr, _Py_CODEUNIT *prev); + +extern int +_Py_call_instrumentation_instruction( + PyThreadState *tstate, _PyInterpreterFrame* frame, _Py_CODEUNIT *instr); + +_Py_CODEUNIT * +_Py_call_instrumentation_jump( + _Py_CODEUNIT *instr, PyThreadState *tstate, int event, + _PyInterpreterFrame *frame, _Py_CODEUNIT *src, _Py_CODEUNIT *dest); + +extern int +_Py_call_instrumentation_arg(PyThreadState *tstate, int event, + _PyInterpreterFrame *frame, _Py_CODEUNIT *instr, PyObject *arg); + +extern int +_Py_call_instrumentation_2args(PyThreadState *tstate, int event, + _PyInterpreterFrame *frame, _Py_CODEUNIT *instr, PyObject *arg0, PyObject *arg1); + +extern void +_Py_call_instrumentation_exc2(PyThreadState *tstate, int event, + _PyInterpreterFrame *frame, _Py_CODEUNIT *instr, PyObject *arg0, PyObject *arg1); + +extern int +_Py_Instrumentation_GetLine(PyCodeObject *code, int index); + +extern PyObject _PyInstrumentation_MISSING; +extern PyObject _PyInstrumentation_DISABLE; + + +/* Total tool ids available */ +#define PY_MONITORING_TOOL_IDS 8 +/* Count of all local monitoring events */ +#define _PY_MONITORING_LOCAL_EVENTS 11 +/* Count of all "real" monitoring events (not derived from other events) */ +#define _PY_MONITORING_UNGROUPED_EVENTS 16 +/* Count of all monitoring events */ +#define _PY_MONITORING_EVENTS 19 + +/* Tables of which tools are active for each monitored event. */ +typedef struct _Py_LocalMonitors { + uint8_t tools[_PY_MONITORING_LOCAL_EVENTS]; +} _Py_LocalMonitors; + +typedef struct _Py_GlobalMonitors { + uint8_t tools[_PY_MONITORING_UNGROUPED_EVENTS]; +} _Py_GlobalMonitors; + +/* Ancillary data structure used for instrumentation. + Line instrumentation creates this with sufficient + space for one entry per code unit. The total size + of the data will be `bytes_per_entry * Py_SIZE(code)` */ +typedef struct { + uint8_t bytes_per_entry; + uint8_t data[1]; +} _PyCoLineInstrumentationData; + + +/* Main data structure used for instrumentation. + * This is allocated when needed for instrumentation + */ +typedef struct _PyCoMonitoringData { + /* Monitoring specific to this code object */ + _Py_LocalMonitors local_monitors; + /* Monitoring that is active on this code object */ + _Py_LocalMonitors active_monitors; + /* The tools that are to be notified for events for the matching code unit */ + uint8_t *tools; + /* The version of tools when they instrument the code */ + uintptr_t tool_versions[PY_MONITORING_TOOL_IDS]; + /* Information to support line events */ + _PyCoLineInstrumentationData *lines; + /* The tools that are to be notified for line events for the matching code unit */ + uint8_t *line_tools; + /* Information to support instruction events */ + /* The underlying instructions, which can themselves be instrumented */ + uint8_t *per_instruction_opcodes; + /* The tools that are to be notified for instruction events for the matching code unit */ + uint8_t *per_instruction_tools; +} _PyCoMonitoringData; + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_INSTRUMENT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_interp.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_interp.h new file mode 100644 index 0000000000000000000000000000000000000000..5b1bb202191b51c3921d652324b6bdb4ff1571d3 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_interp.h @@ -0,0 +1,109 @@ +#ifndef Py_INTERNAL_INTERP_H +#define Py_INTERNAL_INTERP_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_interp_structs.h" // PyInterpreterState + + +/* interpreter state */ + +#define _PyInterpreterState_WHENCE_NOTSET -1 +#define _PyInterpreterState_WHENCE_UNKNOWN 0 +#define _PyInterpreterState_WHENCE_RUNTIME 1 +#define _PyInterpreterState_WHENCE_LEGACY_CAPI 2 +#define _PyInterpreterState_WHENCE_CAPI 3 +#define _PyInterpreterState_WHENCE_XI 4 +#define _PyInterpreterState_WHENCE_STDLIB 5 +#define _PyInterpreterState_WHENCE_MAX 5 + + +/* other API */ + +extern void _PyInterpreterState_Clear(PyThreadState *tstate); + +static inline PyThreadState* +_PyInterpreterState_GetFinalizing(PyInterpreterState *interp) { + return (PyThreadState*)_Py_atomic_load_ptr_relaxed(&interp->_finalizing); +} + +static inline unsigned long +_PyInterpreterState_GetFinalizingID(PyInterpreterState *interp) { + return _Py_atomic_load_ulong_relaxed(&interp->_finalizing_id); +} + +static inline void +_PyInterpreterState_SetFinalizing(PyInterpreterState *interp, PyThreadState *tstate) { + _Py_atomic_store_ptr_relaxed(&interp->_finalizing, tstate); + if (tstate == NULL) { + _Py_atomic_store_ulong_relaxed(&interp->_finalizing_id, 0); + } + else { + // XXX Re-enable this assert once gh-109860 is fixed. + //assert(tstate->thread_id == PyThread_get_thread_ident()); + _Py_atomic_store_ulong_relaxed(&interp->_finalizing_id, + tstate->thread_id); + } +} + + +// Exports for the _testinternalcapi module. +PyAPI_FUNC(int64_t) _PyInterpreterState_ObjectToID(PyObject *); +PyAPI_FUNC(PyInterpreterState *) _PyInterpreterState_LookUpID(int64_t); +PyAPI_FUNC(PyInterpreterState *) _PyInterpreterState_LookUpIDObject(PyObject *); +PyAPI_FUNC(void) _PyInterpreterState_IDIncref(PyInterpreterState *); +PyAPI_FUNC(void) _PyInterpreterState_IDDecref(PyInterpreterState *); + +PyAPI_FUNC(int) _PyInterpreterState_IsReady(PyInterpreterState *interp); + +PyAPI_FUNC(long) _PyInterpreterState_GetWhence(PyInterpreterState *interp); +extern void _PyInterpreterState_SetWhence( + PyInterpreterState *interp, + long whence); + +/* +Runtime Feature Flags + +Each flag indicate whether or not a specific runtime feature +is available in a given context. For example, forking the process +might not be allowed in the current interpreter (i.e. os.fork() would fail). +*/ + +/* Set if the interpreter share obmalloc runtime state + with the main interpreter. */ +#define Py_RTFLAGS_USE_MAIN_OBMALLOC (1UL << 5) + +/* Set if import should check a module for subinterpreter support. */ +#define Py_RTFLAGS_MULTI_INTERP_EXTENSIONS (1UL << 8) + +/* Set if threads are allowed. */ +#define Py_RTFLAGS_THREADS (1UL << 10) + +/* Set if daemon threads are allowed. */ +#define Py_RTFLAGS_DAEMON_THREADS (1UL << 11) + +/* Set if os.fork() is allowed. */ +#define Py_RTFLAGS_FORK (1UL << 15) + +/* Set if os.exec*() is allowed. */ +#define Py_RTFLAGS_EXEC (1UL << 16) + +extern int _PyInterpreterState_HasFeature(PyInterpreterState *interp, + unsigned long feature); + +PyAPI_FUNC(PyStatus) _PyInterpreterState_New( + PyThreadState *tstate, + PyInterpreterState **pinterp); + +extern const PyConfig* _PyInterpreterState_GetConfig( + PyInterpreterState *interp); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_INTERP_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_interp_structs.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_interp_structs.h new file mode 100644 index 0000000000000000000000000000000000000000..c3d9533e90fdec85bb537410457539c69fc52f67 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_interp_structs.h @@ -0,0 +1,980 @@ +/* This file contains the struct definitions for interpreter state + * and other necessary structs */ + +#ifndef Py_INTERNAL_INTERP_STRUCTS_H +#define Py_INTERNAL_INTERP_STRUCTS_H +#ifdef __cplusplus +extern "C" { +#endif + +#include "pycore_ast_state.h" // struct ast_state +#include "pycore_llist.h" // struct llist_node +#include "pycore_opcode_utils.h" // NUM_COMMON_CONSTANTS +#include "pycore_pymath.h" // _PY_SHORT_FLOAT_REPR +#include "pycore_structs.h" // PyHamtObject +#include "pycore_tstate.h" // _PyThreadStateImpl +#include "pycore_typedefs.h" // _PyRuntimeState + + +#define CODE_MAX_WATCHERS 8 +#define CONTEXT_MAX_WATCHERS 8 +#define FUNC_MAX_WATCHERS 8 +#define TYPE_MAX_WATCHERS 8 + + +#ifdef Py_GIL_DISABLED +// This should be prime but otherwise the choice is arbitrary. A larger value +// increases concurrency at the expense of memory. +# define NUM_WEAKREF_LIST_LOCKS 127 +#endif + +typedef int (*_Py_pending_call_func)(void *); + +struct _pending_call { + _Py_pending_call_func func; + void *arg; + int flags; +}; + +#define PENDINGCALLSARRAYSIZE 300 + +struct _pending_calls { + PyThreadState *handling_thread; + PyMutex mutex; + /* Request for running pending calls. */ + int32_t npending; + /* The maximum allowed number of pending calls. + If the queue fills up to this point then _PyEval_AddPendingCall() + will return _Py_ADD_PENDING_FULL. */ + int32_t max; + /* We don't want a flood of pending calls to interrupt any one thread + for too long, so we keep a limit on the number handled per pass. + A value of 0 means there is no limit (other than the maximum + size of the list of pending calls). */ + int32_t maxloop; + struct _pending_call calls[PENDINGCALLSARRAYSIZE]; + int first; + int next; +}; + +typedef enum { + PERF_STATUS_FAILED = -1, // Perf trampoline is in an invalid state + PERF_STATUS_NO_INIT = 0, // Perf trampoline is not initialized + PERF_STATUS_OK = 1, // Perf trampoline is ready to be executed +} perf_status_t; + +#ifdef PY_HAVE_PERF_TRAMPOLINE +struct code_arena_st; + +struct trampoline_api_st { + void* (*init_state)(void); + void (*write_state)(void* state, const void *code_addr, + unsigned int code_size, PyCodeObject* code); + int (*free_state)(void* state); + void *state; + Py_ssize_t code_padding; +}; +#endif + + +struct _ceval_runtime_state { + struct { +#ifdef PY_HAVE_PERF_TRAMPOLINE + perf_status_t status; + int perf_trampoline_type; + Py_ssize_t extra_code_index; + struct code_arena_st *code_arena; + struct trampoline_api_st trampoline_api; + FILE *map_file; + Py_ssize_t persist_after_fork; + _PyFrameEvalFunction prev_eval_frame; + Py_ssize_t trampoline_refcount; + int code_watcher_id; +#else + int _not_used; +#endif + } perf; + /* Pending calls to be made only on the main thread. */ + // The signal machinery falls back on this + // so it must be especially stable and efficient. + // For example, we use a preallocated array + // for the list of pending calls. + struct _pending_calls pending_mainthread; + PyMutex unused_sys_trace_profile_mutex; // kept for ABI compatibility +}; + + +struct _ceval_state { + /* This variable holds the global instrumentation version. When a thread is + running, this value is overlaid onto PyThreadState.eval_breaker so that + changes in the instrumentation version will trigger the eval breaker. */ + uintptr_t instrumentation_version; + int recursion_limit; + struct _gil_runtime_state *gil; + int own_gil; + struct _pending_calls pending; +}; + + +//############### +// runtime atexit + +typedef void (*atexit_callbackfunc)(void); + +struct _atexit_runtime_state { + PyMutex mutex; +#define NEXITFUNCS 32 + atexit_callbackfunc callbacks[NEXITFUNCS]; + int ncallbacks; +}; + + +//################### +// interpreter atexit + +typedef void (*atexit_datacallbackfunc)(void *); + +typedef struct atexit_callback { + atexit_datacallbackfunc func; + void *data; + struct atexit_callback *next; +} atexit_callback; + +struct atexit_state { +#ifdef Py_GIL_DISABLED + PyMutex ll_callbacks_lock; +#endif + atexit_callback *ll_callbacks; + + // XXX The rest of the state could be moved to the atexit module state + // and a low-level callback added for it during module exec. + // For the moment we leave it here. + + // List containing tuples with callback information. + // e.g. [(func, args, kwargs), ...] + PyObject *callbacks; +}; + + +/****** Garbage collector **********/ + +/* GC information is stored BEFORE the object structure. */ +typedef struct { + // Tagged pointer to next object in the list. + // 0 means the object is not tracked + uintptr_t _gc_next; + + // Tagged pointer to previous object in the list. + // Lowest two bits are used for flags documented later. + uintptr_t _gc_prev; +} PyGC_Head; + +#define _PyGC_Head_UNUSED PyGC_Head + +struct gc_generation { + PyGC_Head head; + int threshold; /* collection threshold */ + int count; /* count of allocations or collections of younger + generations */ +}; + +struct gc_collection_stats { + /* number of collected objects */ + Py_ssize_t collected; + /* total number of uncollectable objects (put into gc.garbage) */ + Py_ssize_t uncollectable; +}; + +/* Running stats per generation */ +struct gc_generation_stats { + /* total number of collections */ + Py_ssize_t collections; + /* total number of collected objects */ + Py_ssize_t collected; + /* total number of uncollectable objects (put into gc.garbage) */ + Py_ssize_t uncollectable; +}; + +enum _GCPhase { + GC_PHASE_MARK = 0, + GC_PHASE_COLLECT = 1 +}; + +/* If we change this, we need to change the default value in the + signature of gc.collect. */ +#define NUM_GENERATIONS 3 + +struct _gc_runtime_state { + /* List of objects that still need to be cleaned up, singly linked + * via their gc headers' gc_prev pointers. */ + PyObject *trash_delete_later; + /* Current call-stack depth of tp_dealloc calls. */ + int trash_delete_nesting; + + /* Is automatic collection enabled? */ + int enabled; + int debug; + /* linked lists of container objects */ + struct gc_generation young; + struct gc_generation old[2]; + /* a permanent generation which won't be collected */ + struct gc_generation permanent_generation; + struct gc_generation_stats generation_stats[NUM_GENERATIONS]; + /* true if we are currently running the collector */ + int collecting; + /* list of uncollectable objects */ + PyObject *garbage; + /* a list of callbacks to be invoked when collection is performed */ + PyObject *callbacks; + + Py_ssize_t heap_size; + Py_ssize_t work_to_do; + /* Which of the old spaces is the visited space */ + int visited_space; + int phase; + +#ifdef Py_GIL_DISABLED + /* This is the number of objects that survived the last full + collection. It approximates the number of long lived objects + tracked by the GC. + + (by "full collection", we mean a collection of the oldest + generation). */ + Py_ssize_t long_lived_total; + /* This is the number of objects that survived all "non-full" + collections, and are awaiting to undergo a full collection for + the first time. */ + Py_ssize_t long_lived_pending; + + /* True if gc.freeze() has been used. */ + int freeze_active; + + /* Memory usage of the process (RSS + swap) after last GC. */ + Py_ssize_t last_mem; + + /* This accumulates the new object count whenever collection is deferred + due to the RSS increase condition not being meet. Reset on collection. */ + Py_ssize_t deferred_count; + + /* Mutex held for gc_should_collect_mem_usage(). */ + PyMutex mutex; +#endif +}; + +#include "pycore_gil.h" // struct _gil_runtime_state + +/**** Import ********/ + +struct _import_runtime_state { + /* The builtin modules (defined in config.c). */ + struct _inittab *inittab; + /* The most recent value assigned to a PyModuleDef.m_base.m_index. + This is incremented each time PyModuleDef_Init() is called, + which is just about every time an extension module is imported. + See PyInterpreterState.modules_by_index for more info. */ + Py_ssize_t last_module_index; + struct { + /* A lock to guard the cache. */ + PyMutex mutex; + /* The actual cache of (filename, name, PyModuleDef) for modules. + Only legacy (single-phase init) extension modules are added + and only if they support multiple initialization (m_size >= 0) + or are imported in the main interpreter. + This is initialized lazily in fix_up_extension() in import.c. + Modules are added there and looked up in _imp.find_extension(). */ + struct _Py_hashtable_t *hashtable; + } extensions; + /* Package context -- the full module name for package imports */ + const char * pkgcontext; +}; + +struct _import_state { + /* cached sys.modules dictionary */ + PyObject *modules; + /* This is the list of module objects for all legacy (single-phase init) + extension modules ever loaded in this process (i.e. imported + in this interpreter or in any other). Py_None stands in for + modules that haven't actually been imported in this interpreter. + + A module's index (PyModuleDef.m_base.m_index) is used to look up + the corresponding module object for this interpreter, if any. + (See PyState_FindModule().) When any extension module + is initialized during import, its moduledef gets initialized by + PyModuleDef_Init(), and the first time that happens for each + PyModuleDef, its index gets set to the current value of + a global counter (see _PyRuntimeState.imports.last_module_index). + The entry for that index in this interpreter remains unset until + the module is actually imported here. (Py_None is used as + a placeholder.) Note that multi-phase init modules always get + an index for which there will never be a module set. + + This is initialized lazily in PyState_AddModule(), which is also + where modules get added. */ + PyObject *modules_by_index; + /* importlib module._bootstrap */ + PyObject *importlib; + /* override for config->use_frozen_modules (for tests) + (-1: "off", 1: "on", 0: no override) */ + int override_frozen_modules; + int override_multi_interp_extensions_check; +#ifdef HAVE_DLOPEN + int dlopenflags; +#endif + PyObject *import_func; + /* The global import lock. */ + _PyRecursiveMutex lock; + /* diagnostic info in PyImport_ImportModuleLevelObject() */ + struct { + int import_level; + PyTime_t accumulated; + int header; + } find_and_load; +}; + + + +/********** Interpreter state **************/ + +#include "pycore_object_state.h" // struct _py_object_state +#include "pycore_crossinterp.h" // _PyXI_state_t + + +struct _Py_long_state { + int max_str_digits; +}; + +struct codecs_state { + // A list of callable objects used to search for codecs. + PyObject *search_path; + + // A dict mapping codec names to codecs returned from a callable in + // search_path. + PyObject *search_cache; + + // A dict mapping error handling strategies to functions to implement them. + PyObject *error_registry; + +#ifdef Py_GIL_DISABLED + // Used to safely delete a specific item from search_path. + PyMutex search_path_mutex; +#endif + + // Whether or not the rest of the state is initialized. + int initialized; +}; + +// Support for stop-the-world events. This exists in both the PyRuntime struct +// for global pauses and in each PyInterpreterState for per-interpreter pauses. +struct _stoptheworld_state { + PyMutex mutex; // Serializes stop-the-world attempts. + + // NOTE: The below fields are protected by HEAD_LOCK(runtime), not by the + // above mutex. + bool requested; // Set when a pause is requested. + bool world_stopped; // Set when the world is stopped. + bool is_global; // Set when contained in PyRuntime struct. + + PyEvent stop_event; // Set when thread_countdown reaches zero. + Py_ssize_t thread_countdown; // Number of threads that must pause. + + PyThreadState *requester; // Thread that requested the pause (may be NULL). +}; + +/* Tracks some rare events per-interpreter, used by the optimizer to turn on/off + specific optimizations. */ +typedef struct _rare_events { + /* Setting an object's class, obj.__class__ = ... */ + uint8_t set_class; + /* Setting the bases of a class, cls.__bases__ = ... */ + uint8_t set_bases; + /* Setting the PEP 523 frame eval function, _PyInterpreterState_SetFrameEvalFunc() */ + uint8_t set_eval_frame_func; + /* Modifying the builtins, __builtins__.__dict__[var] = ... */ + uint8_t builtin_dict; + /* Modifying a function, e.g. func.__defaults__ = ..., etc. */ + uint8_t func_modification; +} _rare_events; + +struct +Bigint { + struct Bigint *next; + int k, maxwds, sign, wds; + uint32_t x[1]; +}; + +#if defined(Py_USING_MEMORY_DEBUGGER) || _PY_SHORT_FLOAT_REPR == 0 + +struct _dtoa_state { + int _not_used; +}; + +#else // !Py_USING_MEMORY_DEBUGGER && _PY_SHORT_FLOAT_REPR != 0 + +/* The size of the Bigint freelist */ +#define Bigint_Kmax 7 + +/* The size of the cached powers of 5 array */ +#define Bigint_Pow5size 8 + +#ifndef PRIVATE_MEM +#define PRIVATE_MEM 2304 +#endif +#define Bigint_PREALLOC_SIZE \ + ((PRIVATE_MEM+sizeof(double)-1)/sizeof(double)) + +struct _dtoa_state { + // p5s is an array of powers of 5 of the form: + // 5**(2**(i+2)) for 0 <= i < Bigint_Pow5size + struct Bigint *p5s[Bigint_Pow5size]; + // XXX This should be freed during runtime fini. + struct Bigint *freelist[Bigint_Kmax+1]; + double preallocated[Bigint_PREALLOC_SIZE]; + double *preallocated_next; +}; + +#endif // !Py_USING_MEMORY_DEBUGGER + +struct _py_code_state { + PyMutex mutex; + // Interned constants from code objects. Used by the free-threaded build. + struct _Py_hashtable_t *constants; +}; + +#define FUNC_VERSION_CACHE_SIZE (1<<12) /* Must be a power of 2 */ + +struct _func_version_cache_item { + PyFunctionObject *func; + PyObject *code; +}; + +struct _py_func_state { +#ifdef Py_GIL_DISABLED + // Protects next_version + PyMutex mutex; +#endif + + uint32_t next_version; + // Borrowed references to function and code objects whose + // func_version % FUNC_VERSION_CACHE_SIZE + // once was equal to the index in the table. + // They are cleared when the function or code object is deallocated. + struct _func_version_cache_item func_version_cache[FUNC_VERSION_CACHE_SIZE]; +}; + +#include "pycore_dict_state.h" // struct _Py_dict_state +#include "pycore_exceptions.h" // struct _Py_exc_state + + +/****** type state *********/ + +/* For now we hard-code this to a value for which we are confident + all the static builtin types will fit (for all builds). */ +#define _Py_MAX_MANAGED_STATIC_BUILTIN_TYPES 200 +#define _Py_MAX_MANAGED_STATIC_EXT_TYPES 10 +#define _Py_MAX_MANAGED_STATIC_TYPES \ + (_Py_MAX_MANAGED_STATIC_BUILTIN_TYPES + _Py_MAX_MANAGED_STATIC_EXT_TYPES) + +struct _types_runtime_state { + /* Used to set PyTypeObject.tp_version_tag for core static types. */ + // bpo-42745: next_version_tag remains shared by all interpreters + // because of static types. + unsigned int next_version_tag; + + struct { + struct { + PyTypeObject *type; + int64_t interp_count; + } types[_Py_MAX_MANAGED_STATIC_TYPES]; + } managed_static; +}; + + +// Type attribute lookup cache: speed up attribute and method lookups, +// see _PyType_Lookup(). +struct type_cache_entry { + unsigned int version; // initialized from type->tp_version_tag +#ifdef Py_GIL_DISABLED + _PySeqLock sequence; +#endif + PyObject *name; // reference to exactly a str or None + PyObject *value; // borrowed reference or NULL +}; + +#define MCACHE_SIZE_EXP 12 + +struct type_cache { + struct type_cache_entry hashtable[1 << MCACHE_SIZE_EXP]; +}; + +typedef struct { + PyTypeObject *type; + int isbuiltin; + int readying; + int ready; + // XXX tp_dict can probably be statically allocated, + // instead of dynamically and stored on the interpreter. + PyObject *tp_dict; + PyObject *tp_subclasses; + /* We never clean up weakrefs for static builtin types since + they will effectively never get triggered. However, there + are also some diagnostic uses for the list of weakrefs, + so we still keep it. */ + PyObject *tp_weaklist; +} managed_static_type_state; + +#define TYPE_VERSION_CACHE_SIZE (1<<12) /* Must be a power of 2 */ + +struct types_state { + /* Used to set PyTypeObject.tp_version_tag. + It starts at _Py_MAX_GLOBAL_TYPE_VERSION_TAG + 1, + where all those lower numbers are used for core static types. */ + unsigned int next_version_tag; + + struct type_cache type_cache; + + /* Every static builtin type is initialized for each interpreter + during its own initialization, including for the main interpreter + during global runtime initialization. This is done by calling + _PyStaticType_InitBuiltin(). + + The first time a static builtin type is initialized, all the + normal PyType_Ready() stuff happens. The only difference from + normal is that there are three PyTypeObject fields holding + objects which are stored here (on PyInterpreterState) rather + than in the corresponding PyTypeObject fields. Those are: + tp_dict (cls.__dict__), tp_subclasses (cls.__subclasses__), + and tp_weaklist. + + When a subinterpreter is initialized, each static builtin type + is still initialized, but only the interpreter-specific portion, + namely those three objects. + + Those objects are stored in the PyInterpreterState.types.builtins + array, at the index corresponding to each specific static builtin + type. That index (a size_t value) is stored in the tp_subclasses + field. For static builtin types, we re-purposed the now-unused + tp_subclasses to avoid adding another field to PyTypeObject. + In all other cases tp_subclasses holds a dict like before. + (The field was previously defined as PyObject*, but is now void* + to reflect its dual use.) + + The index for each static builtin type isn't statically assigned. + Instead it is calculated the first time a type is initialized + (by the main interpreter). The index matches the order in which + the type was initialized relative to the others. The actual + value comes from the current value of num_builtins_initialized, + as each type is initialized for the main interpreter. + + num_builtins_initialized is incremented once for each static + builtin type. Once initialization is over for a subinterpreter, + the value will be the same as for all other interpreters. */ + struct { + size_t num_initialized; + managed_static_type_state initialized[_Py_MAX_MANAGED_STATIC_BUILTIN_TYPES]; + } builtins; + /* We apply a similar strategy for managed extension modules. */ + struct { + size_t num_initialized; + size_t next_index; + managed_static_type_state initialized[_Py_MAX_MANAGED_STATIC_EXT_TYPES]; + } for_extensions; + PyMutex mutex; + + // Borrowed references to type objects whose + // tp_version_tag % TYPE_VERSION_CACHE_SIZE + // once was equal to the index in the table. + // They are cleared when the type object is deallocated. + PyTypeObject *type_version_cache[TYPE_VERSION_CACHE_SIZE]; +}; + +struct _warnings_runtime_state { + /* Both 'filters' and 'onceregistry' can be set in warnings.py; + get_warnings_attr() will reset these variables accordingly. */ + PyObject *filters; /* List */ + PyObject *once_registry; /* Dict */ + PyObject *default_action; /* String */ + _PyRecursiveMutex lock; + long filters_version; + PyObject *context; +}; + +struct _Py_mem_interp_free_queue { + int has_work; // true if the queue is not empty + PyMutex mutex; // protects the queue + struct llist_node head; // queue of _mem_work_chunk items +}; + + +/****** Unicode state *********/ + +typedef enum { + _Py_ERROR_UNKNOWN=0, + _Py_ERROR_STRICT, + _Py_ERROR_SURROGATEESCAPE, + _Py_ERROR_REPLACE, + _Py_ERROR_IGNORE, + _Py_ERROR_BACKSLASHREPLACE, + _Py_ERROR_SURROGATEPASS, + _Py_ERROR_XMLCHARREFREPLACE, + _Py_ERROR_OTHER +} _Py_error_handler; + +struct _Py_unicode_runtime_ids { + PyMutex mutex; + // next_index value must be preserved when Py_Initialize()/Py_Finalize() + // is called multiple times: see _PyUnicode_FromId() implementation. + Py_ssize_t next_index; +}; + +struct _Py_unicode_runtime_state { + struct _Py_unicode_runtime_ids ids; +}; + +/* fs_codec.encoding is initialized to NULL. + Later, it is set to a non-NULL string by _PyUnicode_InitEncodings(). */ +struct _Py_unicode_fs_codec { + char *encoding; // Filesystem encoding (encoded to UTF-8) + int utf8; // encoding=="utf-8"? + char *errors; // Filesystem errors (encoded to UTF-8) + _Py_error_handler error_handler; +}; + +struct _Py_unicode_ids { + Py_ssize_t size; + PyObject **array; +}; + +#include "pycore_ucnhash.h" // _PyUnicode_Name_CAPI + +struct _Py_unicode_state { + struct _Py_unicode_fs_codec fs_codec; + + _PyUnicode_Name_CAPI *ucnhash_capi; + + // Unicode identifiers (_Py_Identifier): see _PyUnicode_FromId() + struct _Py_unicode_ids ids; +}; + +// Borrowed references to common callables: +struct callable_cache { + PyObject *isinstance; + PyObject *len; + PyObject *list_append; + PyObject *object__getattribute__; +}; + +/* Length of array of slotdef pointers used to store slots with the + same __name__. There should be at most MAX_EQUIV-1 slotdef entries with + the same __name__, for any __name__. Since that's a static property, it is + appropriate to declare fixed-size arrays for this. */ +#define MAX_EQUIV 10 + +typedef struct wrapperbase pytype_slotdef; + + +struct _Py_interp_cached_objects { +#ifdef Py_GIL_DISABLED + PyMutex interned_mutex; +#endif + PyObject *interned_strings; + + /* object.__reduce__ */ + PyObject *objreduce; + PyObject *type_slots_pname; + pytype_slotdef *type_slots_ptrs[MAX_EQUIV]; + + /* TypeVar and related types */ + PyTypeObject *generic_type; + PyTypeObject *typevar_type; + PyTypeObject *typevartuple_type; + PyTypeObject *paramspec_type; + PyTypeObject *paramspecargs_type; + PyTypeObject *paramspeckwargs_type; + PyTypeObject *constevaluator_type; +}; + +struct _Py_interp_static_objects { + struct { + int _not_used; + // hamt_empty is here instead of global because of its weakreflist. + _PyGC_Head_UNUSED _hamt_empty_gc_not_used; + PyHamtObject hamt_empty; + PyBaseExceptionObject last_resort_memory_error; + } singletons; +}; + +#include "pycore_instruments.h" // PY_MONITORING_TOOL_IDS + + +#ifdef Py_GIL_DISABLED + +// A min-heap of indices +typedef struct _PyIndexHeap { + int32_t *values; + + // Number of items stored in values + Py_ssize_t size; + + // Maximum number of items that can be stored in values + Py_ssize_t capacity; +} _PyIndexHeap; + +// An unbounded pool of indices. Indices are allocated starting from 0. They +// may be released back to the pool once they are no longer in use. +typedef struct _PyIndexPool { + PyMutex mutex; + + // Min heap of indices available for allocation + _PyIndexHeap free_indices; + + // Next index to allocate if no free indices are available + int32_t next_index; + + // Generation counter incremented on thread creation/destruction + // Used for TLBC cache invalidation in remote debugging + uint32_t tlbc_generation; +} _PyIndexPool; + +typedef union _Py_unique_id_entry { + // Points to the next free type id, when part of the freelist + union _Py_unique_id_entry *next; + + // Stores the object when the id is assigned + PyObject *obj; +} _Py_unique_id_entry; + +struct _Py_unique_id_pool { + PyMutex mutex; + + // combined table of object with allocated unique ids and unallocated ids. + _Py_unique_id_entry *table; + + // Next entry to allocate inside 'table' or NULL + _Py_unique_id_entry *freelist; + + // size of 'table' + Py_ssize_t size; +}; + +#endif + + +/* PyInterpreterState holds the global state for one of the runtime's + interpreters. Typically the initial (main) interpreter is the only one. + + The PyInterpreterState typedef is in Include/pytypedefs.h. + */ +struct _is { + + /* This struct contains the eval_breaker, + * which is by far the hottest field in this struct + * and should be placed at the beginning. */ + struct _ceval_state ceval; + + // unused, kept for ABI compatibility + void *_malloced; + + PyInterpreterState *next; + + int64_t id; + Py_ssize_t id_refcount; + int requires_idref; + + long _whence; + + /* Has been initialized to a safe state. + + In order to be effective, this must be set to 0 during or right + after allocation. */ + int _initialized; + /* Has been fully initialized via pylifecycle.c. */ + int _ready; + int finalizing; + + uintptr_t last_restart_version; + struct pythreads { + uint64_t next_unique_id; + /* The linked list of threads, newest first. */ + PyThreadState *head; + _PyThreadStateImpl *preallocated; + /* The thread currently executing in the __main__ module, if any. */ + PyThreadState *main; + /* Used in Modules/_threadmodule.c. */ + Py_ssize_t count; + /* Support for runtime thread stack size tuning. + A value of 0 means using the platform's default stack size + or the size specified by the THREAD_STACK_SIZE macro. */ + /* Used in Python/thread.c. */ + size_t stacksize; + } threads; + + /* Reference to the _PyRuntime global variable. This field exists + to not have to pass runtime in addition to tstate to a function. + Get runtime from tstate: tstate->interp->runtime. */ + _PyRuntimeState *runtime; + + /* Set by Py_EndInterpreter(). + + Use _PyInterpreterState_GetFinalizing() + and _PyInterpreterState_SetFinalizing() + to access it, don't access it directly. */ + PyThreadState* _finalizing; + /* The ID of the OS thread in which we are finalizing. */ + unsigned long _finalizing_id; + + struct _gc_runtime_state gc; + + /* The following fields are here to avoid allocation during init. + The data is exposed through PyInterpreterState pointer fields. + These fields should not be accessed directly outside of init. + + All other PyInterpreterState pointer fields are populated when + needed and default to NULL. + + For now there are some exceptions to that rule, which require + allocation during init. These will be addressed on a case-by-case + basis. Also see _PyRuntimeState regarding the various mutex fields. + */ + + // Dictionary of the sys module + PyObject *sysdict; + + // Dictionary of the builtins module + PyObject *builtins; + + struct _import_state imports; + + /* The per-interpreter GIL, which might not be used. */ + struct _gil_runtime_state _gil; + + uint64_t _code_object_generation; + + /* ---------- IMPORTANT --------------------------- + The fields above this line are declared as early as + possible to facilitate out-of-process observability + tools. */ + + struct codecs_state codecs; + + PyConfig config; + unsigned long feature_flags; + + PyObject *dict; /* Stores per-interpreter state */ + + PyObject *sysdict_copy; + PyObject *builtins_copy; + // Initialized to _PyEval_EvalFrameDefault(). + _PyFrameEvalFunction eval_frame; + + PyFunction_WatchCallback func_watchers[FUNC_MAX_WATCHERS]; + // One bit is set for each non-NULL entry in func_watchers + uint8_t active_func_watchers; + + Py_ssize_t co_extra_user_count; + freefunc co_extra_freefuncs[MAX_CO_EXTRA_USERS]; + + /* cross-interpreter data and utils */ + _PyXI_state_t xi; + +#ifdef HAVE_FORK + PyObject *before_forkers; + PyObject *after_forkers_parent; + PyObject *after_forkers_child; +#endif + + struct _warnings_runtime_state warnings; + struct atexit_state atexit; + struct _stoptheworld_state stoptheworld; + struct _qsbr_shared qsbr; + +#if defined(Py_GIL_DISABLED) + struct _mimalloc_interp_state mimalloc; + struct _brc_state brc; // biased reference counting state + struct _Py_unique_id_pool unique_ids; // object ids for per-thread refcounts + PyMutex weakref_locks[NUM_WEAKREF_LIST_LOCKS]; + _PyIndexPool tlbc_indices; +#endif + // Per-interpreter list of tasks, any lingering tasks from thread + // states gets added here and removed from the corresponding + // thread state's list. + struct llist_node asyncio_tasks_head; + // `asyncio_tasks_lock` is used when tasks are moved + // from thread's list to interpreter's list. + PyMutex asyncio_tasks_lock; + + // Per-interpreter state for the obmalloc allocator. For the main + // interpreter and for all interpreters that don't have their + // own obmalloc state, this points to the static structure in + // obmalloc.c obmalloc_state_main. For other interpreters, it is + // heap allocated by _PyMem_init_obmalloc() and freed when the + // interpreter structure is freed. In the case of a heap allocated + // obmalloc state, it is not safe to hold on to or use memory after + // the interpreter is freed. The obmalloc state corresponding to + // that allocated memory is gone. See free_obmalloc_arenas() for + // more comments. + struct _obmalloc_state *obmalloc; + + PyObject *audit_hooks; + PyType_WatchCallback type_watchers[TYPE_MAX_WATCHERS]; + PyCode_WatchCallback code_watchers[CODE_MAX_WATCHERS]; + PyContext_WatchCallback context_watchers[CONTEXT_MAX_WATCHERS]; + // One bit is set for each non-NULL entry in code_watchers + uint8_t active_code_watchers; + uint8_t active_context_watchers; + + struct _py_object_state object_state; + struct _Py_unicode_state unicode; + struct _Py_long_state long_state; + struct _dtoa_state dtoa; + struct _py_func_state func_state; + struct _py_code_state code_state; + + struct _Py_dict_state dict_state; + struct _Py_exc_state exc_state; + struct _Py_mem_interp_free_queue mem_free_queue; + + struct ast_state ast; + struct types_state types; + struct callable_cache callable_cache; + PyObject *common_consts[NUM_COMMON_CONSTANTS]; + bool jit; + struct _PyExecutorObject *executor_list_head; + struct _PyExecutorObject *executor_deletion_list_head; + int executor_deletion_list_remaining_capacity; + size_t trace_run_counter; + _rare_events rare_events; + PyDict_WatchCallback builtins_dict_watcher; + + _Py_GlobalMonitors monitors; + _PyOnceFlag sys_profile_once_flag; + _PyOnceFlag sys_trace_once_flag; + Py_ssize_t sys_profiling_threads; /* Count of threads with c_profilefunc set */ + Py_ssize_t sys_tracing_threads; /* Count of threads with c_tracefunc set */ + PyObject *monitoring_callables[PY_MONITORING_TOOL_IDS][_PY_MONITORING_EVENTS]; + PyObject *monitoring_tool_names[PY_MONITORING_TOOL_IDS]; + uintptr_t monitoring_tool_versions[PY_MONITORING_TOOL_IDS]; + + struct _Py_interp_cached_objects cached_objects; + struct _Py_interp_static_objects static_objects; + + Py_ssize_t _interactive_src_count; + +#if !defined(Py_GIL_DISABLED) && defined(Py_STACKREF_DEBUG) + uint64_t next_stackref; + _Py_hashtable_t *open_stackrefs_table; +# ifdef Py_STACKREF_CLOSE_DEBUG + _Py_hashtable_t *closed_stackrefs_table; +# endif +#endif + + /* the initial PyInterpreterState.threads.head */ + _PyThreadStateImpl _initial_thread; + // _initial_thread should be the last field of PyInterpreterState. + // See https://github.com/python/cpython/issues/127117. +}; + + +#ifdef __cplusplus +} +#endif +#endif /* Py_INTERNAL_INTERP_STRUCTS_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_interpframe.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_interpframe.h new file mode 100644 index 0000000000000000000000000000000000000000..b5b729f141bab5dd267784a2d56c9485ca59acc9 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_interpframe.h @@ -0,0 +1,406 @@ +#ifndef Py_INTERNAL_INTERP_FRAME_H +#define Py_INTERNAL_INTERP_FRAME_H + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_code.h" // _PyCode_CODE() +#include "pycore_interpframe_structs.h" // _PyInterpreterFrame +#include "pycore_stackref.h" // PyStackRef_AsPyObjectBorrow() +#include "pycore_stats.h" // CALL_STAT_INC() + +#ifdef __cplusplus +extern "C" { +#endif + +#define _PyInterpreterFrame_LASTI(IF) \ + ((int)((IF)->instr_ptr - _PyFrame_GetBytecode((IF)))) + +static inline PyCodeObject *_PyFrame_GetCode(_PyInterpreterFrame *f) { + assert(!PyStackRef_IsNull(f->f_executable)); + PyObject *executable = PyStackRef_AsPyObjectBorrow(f->f_executable); + assert(PyCode_Check(executable)); + return (PyCodeObject *)executable; +} + +// Similar to _PyFrame_GetCode(), but return NULL if the frame is invalid or +// freed. Used by dump_frame() in Python/traceback.c. The function uses +// heuristics to detect freed memory, it's not 100% reliable. +static inline PyCodeObject* +_PyFrame_SafeGetCode(_PyInterpreterFrame *f) +{ + // globals and builtins may be NULL on a legit frame, but it's unlikely. + // It's more likely that it's a sign of an invalid frame. + if (f->f_globals == NULL || f->f_builtins == NULL) { + return NULL; + } + + if (PyStackRef_IsNull(f->f_executable)) { + return NULL; + } + void *ptr; + memcpy(&ptr, &f->f_executable, sizeof(f->f_executable)); + if (_PyMem_IsPtrFreed(ptr)) { + return NULL; + } + PyObject *executable = PyStackRef_AsPyObjectBorrow(f->f_executable); + if (_PyObject_IsFreed(executable)) { + return NULL; + } + if (!PyCode_Check(executable)) { + return NULL; + } + return (PyCodeObject *)executable; +} + +static inline _Py_CODEUNIT * +_PyFrame_GetBytecode(_PyInterpreterFrame *f) +{ +#ifdef Py_GIL_DISABLED + PyCodeObject *co = _PyFrame_GetCode(f); + _PyCodeArray *tlbc = _PyCode_GetTLBCArray(co); + assert(f->tlbc_index >= 0 && f->tlbc_index < tlbc->size); + return (_Py_CODEUNIT *)tlbc->entries[f->tlbc_index]; +#else + return _PyCode_CODE(_PyFrame_GetCode(f)); +#endif +} + +// Similar to PyUnstable_InterpreterFrame_GetLasti(), but return NULL if the +// frame is invalid or freed. Used by dump_frame() in Python/traceback.c. The +// function uses heuristics to detect freed memory, it's not 100% reliable. +static inline int +_PyFrame_SafeGetLasti(struct _PyInterpreterFrame *f) +{ + // Code based on _PyFrame_GetBytecode() but replace _PyFrame_GetCode() + // with _PyFrame_SafeGetCode(). + PyCodeObject *co = _PyFrame_SafeGetCode(f); + if (co == NULL) { + return -1; + } + + _Py_CODEUNIT *bytecode; +#ifdef Py_GIL_DISABLED + _PyCodeArray *tlbc = _PyCode_GetTLBCArray(co); + assert(f->tlbc_index >= 0 && f->tlbc_index < tlbc->size); + bytecode = (_Py_CODEUNIT *)tlbc->entries[f->tlbc_index]; +#else + bytecode = _PyCode_CODE(co); +#endif + + return (int)(f->instr_ptr - bytecode) * sizeof(_Py_CODEUNIT); +} + +static inline PyFunctionObject *_PyFrame_GetFunction(_PyInterpreterFrame *f) { + PyObject *func = PyStackRef_AsPyObjectBorrow(f->f_funcobj); + assert(PyFunction_Check(func)); + return (PyFunctionObject *)func; +} + +static inline _PyStackRef *_PyFrame_Stackbase(_PyInterpreterFrame *f) { + return (f->localsplus + _PyFrame_GetCode(f)->co_nlocalsplus); +} + +static inline _PyStackRef _PyFrame_StackPeek(_PyInterpreterFrame *f) { + assert(f->stackpointer > f->localsplus + _PyFrame_GetCode(f)->co_nlocalsplus); + assert(!PyStackRef_IsNull(f->stackpointer[-1])); + return f->stackpointer[-1]; +} + +static inline _PyStackRef _PyFrame_StackPop(_PyInterpreterFrame *f) { + assert(f->stackpointer > f->localsplus + _PyFrame_GetCode(f)->co_nlocalsplus); + f->stackpointer--; + return *f->stackpointer; +} + +static inline void _PyFrame_StackPush(_PyInterpreterFrame *f, _PyStackRef value) { + *f->stackpointer = value; + f->stackpointer++; +} + +#define FRAME_SPECIALS_SIZE ((int)((sizeof(_PyInterpreterFrame)-1)/sizeof(PyObject *))) + +static inline int +_PyFrame_NumSlotsForCodeObject(PyCodeObject *code) +{ + /* This function needs to remain in sync with the calculation of + * co_framesize in Tools/build/deepfreeze.py */ + assert(code->co_framesize >= FRAME_SPECIALS_SIZE); + return code->co_framesize - FRAME_SPECIALS_SIZE; +} + +static inline void _PyFrame_Copy(_PyInterpreterFrame *src, _PyInterpreterFrame *dest) +{ + dest->f_executable = PyStackRef_MakeHeapSafe(src->f_executable); + // Don't leave a dangling pointer to the old frame when creating generators + // and coroutines: + dest->previous = NULL; + dest->f_funcobj = PyStackRef_MakeHeapSafe(src->f_funcobj); + dest->f_globals = src->f_globals; + dest->f_builtins = src->f_builtins; + dest->f_locals = src->f_locals; + dest->frame_obj = src->frame_obj; + dest->instr_ptr = src->instr_ptr; +#ifdef Py_GIL_DISABLED + dest->tlbc_index = src->tlbc_index; +#endif + assert(src->stackpointer != NULL); + int stacktop = (int)(src->stackpointer - src->localsplus); + assert(stacktop >= 0); + dest->stackpointer = dest->localsplus + stacktop; + // visited is GC bookkeeping for the current stack walk, not frame state. + dest->visited = 0; +#ifdef Py_DEBUG + dest->lltrace = src->lltrace; +#endif + for (int i = 0; i < stacktop; i++) { + dest->localsplus[i] = PyStackRef_MakeHeapSafe(src->localsplus[i]); + } +} + +#ifdef Py_GIL_DISABLED +static inline void +_PyFrame_InitializeTLBC(PyThreadState *tstate, _PyInterpreterFrame *frame, + PyCodeObject *code) +{ + _Py_CODEUNIT *tlbc = _PyCode_GetTLBCFast(tstate, code); + if (tlbc == NULL) { + // No thread-local bytecode exists for this thread yet; use the main + // thread's copy, deferring thread-local bytecode creation to the + // execution of RESUME. + frame->instr_ptr = _PyCode_CODE(code); + frame->tlbc_index = 0; + } + else { + frame->instr_ptr = tlbc; + frame->tlbc_index = ((_PyThreadStateImpl *)tstate)->tlbc_index; + } +} +#endif + +/* Consumes reference to func and locals. + Does not initialize frame->previous, which happens + when frame is linked into the frame stack. + */ +static inline void +_PyFrame_Initialize( + PyThreadState *tstate, _PyInterpreterFrame *frame, _PyStackRef func, + PyObject *locals, PyCodeObject *code, int null_locals_from, _PyInterpreterFrame *previous) +{ + frame->previous = previous; + frame->f_funcobj = func; + frame->f_executable = PyStackRef_FromPyObjectNew(code); + PyFunctionObject *func_obj = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(func); + frame->f_builtins = func_obj->func_builtins; + frame->f_globals = func_obj->func_globals; + frame->f_locals = locals; + frame->stackpointer = frame->localsplus + code->co_nlocalsplus; + frame->frame_obj = NULL; +#ifdef Py_GIL_DISABLED + _PyFrame_InitializeTLBC(tstate, frame, code); +#else + (void)tstate; + frame->instr_ptr = _PyCode_CODE(code); +#endif + frame->return_offset = 0; + frame->owner = FRAME_OWNED_BY_THREAD; + frame->visited = 0; +#ifdef Py_DEBUG + frame->lltrace = 0; +#endif + + for (int i = null_locals_from; i < code->co_nlocalsplus; i++) { + frame->localsplus[i] = PyStackRef_NULL; + } +} + +/* Gets the pointer to the locals array + * that precedes this frame. + */ +static inline _PyStackRef* +_PyFrame_GetLocalsArray(_PyInterpreterFrame *frame) +{ + return frame->localsplus; +} + +// Fetches the stack pointer, and (on debug builds) sets stackpointer to NULL. +// Having stackpointer == NULL makes it easier to catch missing stack pointer +// spills/restores (which could expose invalid values to the GC) using asserts. +static inline _PyStackRef* +_PyFrame_GetStackPointer(_PyInterpreterFrame *frame) +{ + assert(frame->stackpointer != NULL); + _PyStackRef *sp = frame->stackpointer; +#ifndef NDEBUG + frame->stackpointer = NULL; +#endif + return sp; +} + +static inline void +_PyFrame_SetStackPointer(_PyInterpreterFrame *frame, _PyStackRef *stack_pointer) +{ + assert(frame->stackpointer == NULL); + frame->stackpointer = stack_pointer; +} + +/* Determine whether a frame is incomplete. + * A frame is incomplete if it is part way through + * creating cell objects or a generator or coroutine. + * + * Frames on the frame stack are incomplete until the + * first RESUME instruction. + * Frames owned by a generator are always complete. + * + * NOTE: We allow racy accesses to the instruction pointer + * from other threads for sys._current_frames() and similar APIs. + */ +static inline bool _Py_NO_SANITIZE_THREAD +_PyFrame_IsIncomplete(_PyInterpreterFrame *frame) +{ + if (frame->owner >= FRAME_OWNED_BY_INTERPRETER) { + return true; + } + return frame->owner != FRAME_OWNED_BY_GENERATOR && + frame->instr_ptr < _PyFrame_GetBytecode(frame) + + _PyFrame_GetCode(frame)->_co_firsttraceable; +} + +static inline _PyInterpreterFrame * +_PyFrame_GetFirstComplete(_PyInterpreterFrame *frame) +{ + while (frame && _PyFrame_IsIncomplete(frame)) { + frame = frame->previous; + } + return frame; +} + +static inline _PyInterpreterFrame * +_PyThreadState_GetFrame(PyThreadState *tstate) +{ + return _PyFrame_GetFirstComplete(tstate->current_frame); +} + +/* For use by _PyFrame_GetFrameObject + Do not call directly. */ +PyFrameObject * +_PyFrame_MakeAndSetFrameObject(_PyInterpreterFrame *frame); + +/* Gets the PyFrameObject for this frame, lazily + * creating it if necessary. + * Returns a borrowed reference */ +static inline PyFrameObject * +_PyFrame_GetFrameObject(_PyInterpreterFrame *frame) +{ + + assert(!_PyFrame_IsIncomplete(frame)); + PyFrameObject *res = frame->frame_obj; + if (res != NULL) { + return res; + } + return _PyFrame_MakeAndSetFrameObject(frame); +} + +void +_PyFrame_ClearLocals(_PyInterpreterFrame *frame); + +/* Clears all references in the frame. + * If take is non-zero, then the _PyInterpreterFrame frame + * may be transferred to the frame object it references + * instead of being cleared. Either way + * the caller no longer owns the references + * in the frame. + * take should be set to 1 for heap allocated + * frames like the ones in generators and coroutines. + */ +void +_PyFrame_ClearExceptCode(_PyInterpreterFrame * frame); + +int +_PyFrame_Traverse(_PyInterpreterFrame *frame, visitproc visit, void *arg); + +bool +_PyFrame_HasHiddenLocals(_PyInterpreterFrame *frame); + +PyObject * +_PyFrame_GetLocals(_PyInterpreterFrame *frame); + +static inline bool +_PyThreadState_HasStackSpace(PyThreadState *tstate, int size) +{ + assert( + (tstate->datastack_top == NULL && tstate->datastack_limit == NULL) + || + (tstate->datastack_top != NULL && tstate->datastack_limit != NULL) + ); + return tstate->datastack_top != NULL && + size < tstate->datastack_limit - tstate->datastack_top; +} + +extern _PyInterpreterFrame * +_PyThreadState_PushFrame(PyThreadState *tstate, size_t size); + +PyAPI_FUNC(void) _PyThreadState_PopFrame(PyThreadState *tstate, _PyInterpreterFrame *frame); + +/* Pushes a frame without checking for space. + * Must be guarded by _PyThreadState_HasStackSpace() + * Consumes reference to func. */ +static inline _PyInterpreterFrame * +_PyFrame_PushUnchecked(PyThreadState *tstate, _PyStackRef func, int null_locals_from, _PyInterpreterFrame * previous) +{ + CALL_STAT_INC(frames_pushed); + PyFunctionObject *func_obj = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(func); + PyCodeObject *code = (PyCodeObject *)func_obj->func_code; + _PyInterpreterFrame *new_frame = (_PyInterpreterFrame *)tstate->datastack_top; + tstate->datastack_top += code->co_framesize; + assert(tstate->datastack_top < tstate->datastack_limit); + _PyFrame_Initialize(tstate, new_frame, func, NULL, code, null_locals_from, + previous); + return new_frame; +} + +/* Pushes a trampoline frame without checking for space. + * Must be guarded by _PyThreadState_HasStackSpace() */ +static inline _PyInterpreterFrame * +_PyFrame_PushTrampolineUnchecked(PyThreadState *tstate, PyCodeObject *code, int stackdepth, _PyInterpreterFrame * previous) +{ + CALL_STAT_INC(frames_pushed); + _PyInterpreterFrame *frame = (_PyInterpreterFrame *)tstate->datastack_top; + tstate->datastack_top += code->co_framesize; + assert(tstate->datastack_top < tstate->datastack_limit); + frame->previous = previous; + frame->f_funcobj = PyStackRef_None; + frame->f_executable = PyStackRef_FromPyObjectNew(code); +#ifdef Py_DEBUG + frame->f_builtins = NULL; + frame->f_globals = NULL; +#endif + frame->f_locals = NULL; + assert(stackdepth <= code->co_stacksize); + frame->stackpointer = frame->localsplus + code->co_nlocalsplus + stackdepth; + frame->frame_obj = NULL; +#ifdef Py_GIL_DISABLED + _PyFrame_InitializeTLBC(tstate, frame, code); +#else + frame->instr_ptr = _PyCode_CODE(code); +#endif + frame->owner = FRAME_OWNED_BY_THREAD; + frame->visited = 0; +#ifdef Py_DEBUG + frame->lltrace = 0; +#endif + frame->return_offset = 0; + return frame; +} + +PyAPI_FUNC(_PyInterpreterFrame *) +_PyEvalFramePushAndInit(PyThreadState *tstate, _PyStackRef func, + PyObject *locals, _PyStackRef const *args, + size_t argcount, PyObject *kwnames, + _PyInterpreterFrame *previous); + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_INTERP_FRAME_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_interpframe_structs.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_interpframe_structs.h new file mode 100644 index 0000000000000000000000000000000000000000..835b8e58194863fb4e05e20421b4c4de1161d9a0 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_interpframe_structs.h @@ -0,0 +1,95 @@ +/* Structures used by pycore_debug_offsets.h. + * + * See InternalDocs/frames.md for an explanation of the frame stack + * including explanation of the PyFrameObject and _PyInterpreterFrame + * structs. + */ + +#ifndef Py_INTERNAL_INTERP_FRAME_STRUCTS_H +#define Py_INTERNAL_INTERP_FRAME_STRUCTS_H + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_structs.h" // _PyStackRef +#include "pycore_typedefs.h" // _PyInterpreterFrame + +#ifdef __cplusplus +extern "C" { +#endif + +enum _frameowner { + FRAME_OWNED_BY_THREAD = 0, + FRAME_OWNED_BY_GENERATOR = 1, + FRAME_OWNED_BY_FRAME_OBJECT = 2, + FRAME_OWNED_BY_INTERPRETER = 3, + FRAME_OWNED_BY_CSTACK = 4, +}; + +struct _PyInterpreterFrame { + _PyStackRef f_executable; /* Deferred or strong reference (code object or None) */ + struct _PyInterpreterFrame *previous; + _PyStackRef f_funcobj; /* Deferred or strong reference. Only valid if not on C stack */ + PyObject *f_globals; /* Borrowed reference. Only valid if not on C stack */ + PyObject *f_builtins; /* Borrowed reference. Only valid if not on C stack */ + PyObject *f_locals; /* Strong reference, may be NULL. Only valid if not on C stack */ + PyFrameObject *frame_obj; /* Strong reference, may be NULL. Only valid if not on C stack */ + _Py_CODEUNIT *instr_ptr; /* Instruction currently executing (or about to begin) */ + _PyStackRef *stackpointer; +#ifdef Py_GIL_DISABLED + /* Index of thread-local bytecode containing instr_ptr. */ + int32_t tlbc_index; +#endif + uint16_t return_offset; /* Only relevant during a function call */ + char owner; +#ifdef Py_DEBUG + uint8_t visited:1; + uint8_t lltrace:7; +#else + uint8_t visited; +#endif + /* Locals and stack */ + _PyStackRef localsplus[1]; +}; + + +/* _PyGenObject_HEAD defines the initial segment of generator + and coroutine objects. */ +#define _PyGenObject_HEAD(prefix) \ + PyObject_HEAD \ + /* List of weak reference. */ \ + PyObject *prefix##_weakreflist; \ + /* Name of the generator. */ \ + PyObject *prefix##_name; \ + /* Qualified name of the generator. */ \ + PyObject *prefix##_qualname; \ + _PyErr_StackItem prefix##_exc_state; \ + PyObject *prefix##_origin_or_finalizer; \ + char prefix##_hooks_inited; \ + char prefix##_closed; \ + char prefix##_running_async; \ + /* The frame */ \ + int8_t prefix##_frame_state; \ + _PyInterpreterFrame prefix##_iframe; \ + +struct _PyGenObject { + /* The gi_ prefix is intended to remind of generator-iterator. */ + _PyGenObject_HEAD(gi) +}; + +struct _PyCoroObject { + _PyGenObject_HEAD(cr) +}; + +struct _PyAsyncGenObject { + _PyGenObject_HEAD(ag) +}; + +#undef _PyGenObject_HEAD + + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_INTERP_FRAME_STRUCTS_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_interpolation.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_interpolation.h new file mode 100644 index 0000000000000000000000000000000000000000..dd610c1609c209c63911831a466dc50b267f60e8 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_interpolation.h @@ -0,0 +1,26 @@ +#ifndef Py_INTERNAL_INTERPOLATION_H +#define Py_INTERNAL_INTERPOLATION_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +extern PyTypeObject _PyInterpolation_Type; + +#define _PyInterpolation_CheckExact(op) Py_IS_TYPE((op), &_PyInterpolation_Type) + +PyAPI_FUNC(PyObject *) _PyInterpolation_Build(PyObject *value, PyObject *str, + int conversion, PyObject *format_spec); + +extern PyStatus _PyInterpolation_InitTypes(PyInterpreterState *interp); +extern PyObject *_PyInterpolation_GetValueRef(PyObject *interpolation); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_intrinsics.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_intrinsics.h new file mode 100644 index 0000000000000000000000000000000000000000..39c2a30f6e979de3e4521393c53b198a07a585ab --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_intrinsics.h @@ -0,0 +1,51 @@ +#ifndef Py_INTERNAL_INTRINSIC_H +#define Py_INTERNAL_INTRINSIC_H + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* Unary Functions: */ +#define INTRINSIC_1_INVALID 0 +#define INTRINSIC_PRINT 1 +#define INTRINSIC_IMPORT_STAR 2 +#define INTRINSIC_STOPITERATION_ERROR 3 +#define INTRINSIC_ASYNC_GEN_WRAP 4 +#define INTRINSIC_UNARY_POSITIVE 5 +#define INTRINSIC_LIST_TO_TUPLE 6 +#define INTRINSIC_TYPEVAR 7 +#define INTRINSIC_PARAMSPEC 8 +#define INTRINSIC_TYPEVARTUPLE 9 +#define INTRINSIC_SUBSCRIPT_GENERIC 10 +#define INTRINSIC_TYPEALIAS 11 + +#define MAX_INTRINSIC_1 11 + + +/* Binary Functions: */ +#define INTRINSIC_2_INVALID 0 +#define INTRINSIC_PREP_RERAISE_STAR 1 +#define INTRINSIC_TYPEVAR_WITH_BOUND 2 +#define INTRINSIC_TYPEVAR_WITH_CONSTRAINTS 3 +#define INTRINSIC_SET_FUNCTION_TYPE_PARAMS 4 +#define INTRINSIC_SET_TYPEPARAM_DEFAULT 5 + +#define MAX_INTRINSIC_2 5 + +typedef PyObject *(*intrinsic_func1)(PyThreadState* tstate, PyObject *value); +typedef PyObject *(*intrinsic_func2)(PyThreadState* tstate, PyObject *value1, PyObject *value2); + +typedef struct { + intrinsic_func1 func; + const char *name; +} intrinsic_func1_info; + +typedef struct { + intrinsic_func2 func; + const char *name; +} intrinsic_func2_info; + +PyAPI_DATA(const intrinsic_func1_info) _PyIntrinsics_UnaryFunctions[]; +PyAPI_DATA(const intrinsic_func2_info) _PyIntrinsics_BinaryFunctions[]; + +#endif // !Py_INTERNAL_INTRINSIC_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_jit.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_jit.h new file mode 100644 index 0000000000000000000000000000000000000000..8a88cbf607ba4bcc8a8beff9ea98238ded4b6d66 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_jit.h @@ -0,0 +1,29 @@ +#ifndef Py_INTERNAL_JIT_H +#define Py_INTERNAL_JIT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "pycore_interp.h" +#include "pycore_optimizer.h" +#include "pycore_stackref.h" + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#ifdef _Py_JIT + +typedef _Py_CODEUNIT *(*jit_func)(_PyInterpreterFrame *frame, _PyStackRef *stack_pointer, PyThreadState *tstate); + +int _PyJIT_Compile(_PyExecutorObject *executor, const _PyUOpInstruction *trace, size_t length); +void _PyJIT_Free(_PyExecutorObject *executor); + +#endif // _Py_JIT + +#ifdef __cplusplus +} +#endif + +#endif // !Py_INTERNAL_JIT_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_list.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_list.h new file mode 100644 index 0000000000000000000000000000000000000000..ffbcebdb7dfb50dd1f33c034523ef88f6e829b00 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_list.h @@ -0,0 +1,81 @@ +#ifndef Py_INTERNAL_LIST_H +#define Py_INTERNAL_LIST_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#ifdef Py_GIL_DISABLED +#include "pycore_stackref.h" +#endif + +PyAPI_FUNC(PyObject*) _PyList_Extend(PyListObject *, PyObject *); +PyAPI_FUNC(PyObject) *_PyList_SliceSubscript(PyObject*, PyObject*); +extern void _PyList_DebugMallocStats(FILE *out); +// _PyList_GetItemRef should be used only when the object is known as a list +// because it doesn't raise TypeError when the object is not a list, whereas PyList_GetItemRef does. +extern PyObject* _PyList_GetItemRef(PyListObject *, Py_ssize_t i); + + +#ifdef Py_GIL_DISABLED +// Returns -1 in case of races with other threads. +extern int _PyList_GetItemRefNoLock(PyListObject *, Py_ssize_t, _PyStackRef *); +#endif + +#define _PyList_ITEMS(op) _Py_RVALUE(_PyList_CAST(op)->ob_item) + +PyAPI_FUNC(int) +_PyList_AppendTakeRefListResize(PyListObject *self, PyObject *newitem); + +// In free-threaded build: self should be locked by the caller, if it should be thread-safe. +static inline int +_PyList_AppendTakeRef(PyListObject *self, PyObject *newitem) +{ + assert(self != NULL && newitem != NULL); + assert(PyList_Check(self)); + Py_ssize_t len = Py_SIZE(self); + Py_ssize_t allocated = self->allocated; + assert((size_t)len + 1 < PY_SSIZE_T_MAX); + if (allocated > len) { +#ifdef Py_GIL_DISABLED + _Py_atomic_store_ptr_release(&self->ob_item[len], newitem); +#else + PyList_SET_ITEM(self, len, newitem); +#endif + Py_SET_SIZE(self, len + 1); + return 0; + } + return _PyList_AppendTakeRefListResize(self, newitem); +} + +// Repeat the bytes of a buffer in place +static inline void +_Py_memory_repeat(char* dest, Py_ssize_t len_dest, Py_ssize_t len_src) +{ + assert(len_src > 0); + Py_ssize_t copied = len_src; + while (copied < len_dest) { + Py_ssize_t bytes_to_copy = Py_MIN(copied, len_dest - copied); + memcpy(dest + copied, dest, (size_t)bytes_to_copy); + copied += bytes_to_copy; + } +} + +typedef struct { + PyObject_HEAD + Py_ssize_t it_index; + PyListObject *it_seq; /* Set to NULL when iterator is exhausted */ +} _PyListIterObject; + +union _PyStackRef; + +PyAPI_FUNC(PyObject *)_PyList_FromStackRefStealOnSuccess(const union _PyStackRef *src, Py_ssize_t n); +PyAPI_FUNC(PyObject *)_PyList_AsTupleAndClear(PyListObject *v); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_LIST_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_llist.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_llist.h new file mode 100644 index 0000000000000000000000000000000000000000..f629902fda9ff181f434b7b8e8df39fd71aa50ef --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_llist.h @@ -0,0 +1,106 @@ +// A doubly-linked list that can be embedded in a struct. +// +// Usage: +// struct llist_node head = LLIST_INIT(head); +// typedef struct { +// ... +// struct llist_node node; +// ... +// } MyObj; +// +// llist_insert_tail(&head, &obj->node); +// llist_remove(&obj->node); +// +// struct llist_node *node; +// llist_for_each(node, &head) { +// MyObj *obj = llist_data(node, MyObj, node); +// ... +// } +// + +#ifndef Py_INTERNAL_LLIST_H +#define Py_INTERNAL_LLIST_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "Py_BUILD_CORE must be defined to include this header" +#endif + +struct llist_node { + struct llist_node *next; + struct llist_node *prev; +}; + +// Get the struct containing a node. +#define llist_data(node, type, member) (_Py_CONTAINER_OF(node, type, member)) + +// Iterate over a list. +#define llist_for_each(node, head) \ + for (node = (head)->next; node != (head); node = node->next) + +// Iterate over a list, but allow removal of the current node. +#define llist_for_each_safe(node, head) \ + for (struct llist_node *_next = (node = (head)->next, node->next); \ + node != (head); node = _next, _next = node->next) + +#define LLIST_INIT(head) { &head, &head } + +static inline void +llist_init(struct llist_node *head) +{ + head->next = head; + head->prev = head; +} + +// Returns 1 if the list is empty, 0 otherwise. +static inline int +llist_empty(struct llist_node *head) +{ + return head->next == head; +} + +// Appends to the tail of the list. +static inline void +llist_insert_tail(struct llist_node *head, struct llist_node *node) +{ + node->prev = head->prev; + node->next = head; + head->prev->next = node; + head->prev = node; +} + +// Remove a node from the list. +static inline void +llist_remove(struct llist_node *node) +{ + struct llist_node *prev = node->prev; + struct llist_node *next = node->next; + prev->next = next; + next->prev = prev; + node->prev = NULL; + node->next = NULL; +} + +// Append all nodes from head2 onto head1. head2 is left empty. +static inline void +llist_concat(struct llist_node *head1, struct llist_node *head2) +{ + if (!llist_empty(head2)) { + head1->prev->next = head2->next; + head2->next->prev = head1->prev; + + head1->prev = head2->prev; + head2->prev->next = head1; + llist_init(head2); + } +} + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_LLIST_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_lock.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_lock.h new file mode 100644 index 0000000000000000000000000000000000000000..9b071573ad3c74959f1c8bd53f8fbe49297e8189 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_lock.h @@ -0,0 +1,236 @@ +// Lightweight locks and other synchronization mechanisms. +// +// These implementations are based on WebKit's WTF::Lock. See +// https://webkit.org/blog/6161/locking-in-webkit/ for a description of the +// design. +#ifndef Py_INTERNAL_LOCK_H +#define Py_INTERNAL_LOCK_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +//_Py_UNLOCKED is defined as 0 and _Py_LOCKED as 1 in Include/cpython/lock.h +#define _Py_HAS_PARKED 2 +#define _Py_ONCE_INITIALIZED 4 + +static inline int +PyMutex_LockFast(PyMutex *m) +{ + uint8_t expected = _Py_UNLOCKED; + uint8_t *lock_bits = &m->_bits; + return _Py_atomic_compare_exchange_uint8(lock_bits, &expected, _Py_LOCKED); +} + +// Re-initializes the mutex after a fork to the unlocked state. +static inline void +_PyMutex_at_fork_reinit(PyMutex *m) +{ + memset(m, 0, sizeof(*m)); +} + +typedef enum _PyLockFlags { + // Do not detach/release the GIL when waiting on the lock. + _Py_LOCK_DONT_DETACH = 0, + + // Detach/release the GIL while waiting on the lock. + _PY_LOCK_DETACH = 1, + + // Handle signals if interrupted while waiting on the lock. + _PY_LOCK_HANDLE_SIGNALS = 2, +} _PyLockFlags; + +// Lock a mutex with an optional timeout and additional options. See +// _PyLockFlags for details. +extern PyAPI_FUNC(PyLockStatus) +_PyMutex_LockTimed(PyMutex *m, PyTime_t timeout_ns, _PyLockFlags flags); + +// Lock a mutex with additional options. See _PyLockFlags for details. +static inline void +PyMutex_LockFlags(PyMutex *m, _PyLockFlags flags) +{ + uint8_t expected = _Py_UNLOCKED; + if (!_Py_atomic_compare_exchange_uint8(&m->_bits, &expected, _Py_LOCKED)) { + _PyMutex_LockTimed(m, -1, flags); + } +} + +// Unlock a mutex, returns -1 if the mutex is not locked (used for improved +// error messages) otherwise returns 0. +extern int _PyMutex_TryUnlock(PyMutex *m); + + +// PyEvent is a one-time event notification +typedef struct { + uint8_t v; +} PyEvent; + +// Check if the event is set without blocking. Returns 1 if the event is set or +// 0 otherwise. +PyAPI_FUNC(int) _PyEvent_IsSet(PyEvent *evt); + +// Set the event and notify any waiting threads. +// Export for '_testinternalcapi' shared extension +PyAPI_FUNC(void) _PyEvent_Notify(PyEvent *evt); + +// Wait for the event to be set. If the event is already set, then this returns +// immediately. +PyAPI_FUNC(void) PyEvent_Wait(PyEvent *evt); + +// Wait for the event to be set, or until the timeout expires. If the event is +// already set, then this returns immediately. Returns 1 if the event was set, +// and 0 if the timeout expired or thread was interrupted. If `detach` is +// true, then the thread will detach/release the GIL while waiting. +PyAPI_FUNC(int) +PyEvent_WaitTimed(PyEvent *evt, PyTime_t timeout_ns, int detach); + +// _PyRawMutex implements a word-sized mutex that that does not depend on the +// parking lot API, and therefore can be used in the parking lot +// implementation. +// +// The mutex uses a packed representation: the least significant bit is used to +// indicate whether the mutex is locked or not. The remaining bits are either +// zero or a pointer to a `struct raw_mutex_entry` (see lock.c). +typedef struct { + uintptr_t v; +} _PyRawMutex; + +// Slow paths for lock/unlock +extern void _PyRawMutex_LockSlow(_PyRawMutex *m); +extern void _PyRawMutex_UnlockSlow(_PyRawMutex *m); + +static inline void +_PyRawMutex_Lock(_PyRawMutex *m) +{ + uintptr_t unlocked = _Py_UNLOCKED; + if (_Py_atomic_compare_exchange_uintptr(&m->v, &unlocked, _Py_LOCKED)) { + return; + } + _PyRawMutex_LockSlow(m); +} + +static inline void +_PyRawMutex_Unlock(_PyRawMutex *m) +{ + uintptr_t locked = _Py_LOCKED; + if (_Py_atomic_compare_exchange_uintptr(&m->v, &locked, _Py_UNLOCKED)) { + return; + } + _PyRawMutex_UnlockSlow(m); +} + +// Type signature for one-time initialization functions. The function should +// return 0 on success and -1 on failure. +typedef int _Py_once_fn_t(void *arg); + +// (private) slow path for one time initialization +PyAPI_FUNC(int) +_PyOnceFlag_CallOnceSlow(_PyOnceFlag *flag, _Py_once_fn_t *fn, void *arg); + +// Calls `fn` once using `flag`. The `arg` is passed to the call to `fn`. +// +// Returns 0 on success and -1 on failure. +// +// If `fn` returns 0 (success), then subsequent calls immediately return 0. +// If `fn` returns -1 (failure), then subsequent calls will retry the call. +static inline int +_PyOnceFlag_CallOnce(_PyOnceFlag *flag, _Py_once_fn_t *fn, void *arg) +{ + if (_Py_atomic_load_uint8(&flag->v) == _Py_ONCE_INITIALIZED) { + return 0; + } + return _PyOnceFlag_CallOnceSlow(flag, fn, arg); +} + +// A recursive mutex. The mutex should zero-initialized. +typedef struct { + PyMutex mutex; + unsigned long long thread; // i.e., PyThread_get_thread_ident_ex() + size_t level; +} _PyRecursiveMutex; + +PyAPI_FUNC(int) _PyRecursiveMutex_IsLockedByCurrentThread(_PyRecursiveMutex *m); +PyAPI_FUNC(void) _PyRecursiveMutex_Lock(_PyRecursiveMutex *m); +extern PyLockStatus _PyRecursiveMutex_LockTimed(_PyRecursiveMutex *m, PyTime_t timeout, _PyLockFlags flags); +PyAPI_FUNC(void) _PyRecursiveMutex_Unlock(_PyRecursiveMutex *m); +extern int _PyRecursiveMutex_TryUnlock(_PyRecursiveMutex *m); + +// A readers-writer (RW) lock. The lock supports multiple concurrent readers or +// a single writer. The lock is write-preferring: if a writer is waiting while +// the lock is read-locked then, new readers will be blocked. This avoids +// starvation of writers. +// +// In C++, the equivalent synchronization primitive is std::shared_mutex +// with shared ("read") and exclusive ("write") locking. +// +// The two least significant bits are used to indicate if the lock is +// write-locked and if there are parked threads (either readers or writers) +// waiting to acquire the lock. The remaining bits are used to indicate the +// number of readers holding the lock. +// +// 0b000..00000: unlocked +// 0bnnn..nnn00: nnn..nnn readers holding the lock +// 0bnnn..nnn10: nnn..nnn readers holding the lock and a writer is waiting +// 0b00000..010: unlocked with awoken writer about to acquire lock +// 0b00000..001: write-locked +// 0b00000..011: write-locked and readers or other writers are waiting +// +// Note that reader_count must be zero if the lock is held by a writer, and +// vice versa. The lock can only be held by readers or a writer, but not both. +// +// The design is optimized for simplicity of the implementation. The lock is +// not fair: if fairness is desired, use an additional PyMutex to serialize +// writers. The lock is also not reentrant. +typedef struct { + uintptr_t bits; +} _PyRWMutex; + +// Read lock (i.e., shared lock) +PyAPI_FUNC(void) _PyRWMutex_RLock(_PyRWMutex *rwmutex); +PyAPI_FUNC(void) _PyRWMutex_RUnlock(_PyRWMutex *rwmutex); + +// Write lock (i.e., exclusive lock) +PyAPI_FUNC(void) _PyRWMutex_Lock(_PyRWMutex *rwmutex); +PyAPI_FUNC(void) _PyRWMutex_Unlock(_PyRWMutex *rwmutex); + +// Similar to linux seqlock: https://en.wikipedia.org/wiki/Seqlock +// We use a sequence number to lock the writer, an even sequence means we're unlocked, an odd +// sequence means we're locked. Readers will read the sequence before attempting to read the +// underlying data and then read the sequence number again after reading the data. If the +// sequence has not changed the data is valid. +// +// Differs a little bit in that we use CAS on sequence as the lock, instead of a separate spin lock. +// The writer can also detect that the undelering data has not changed and abandon the write +// and restore the previous sequence. +typedef struct { + uint32_t sequence; +} _PySeqLock; + +// Lock the sequence lock for the writer +PyAPI_FUNC(void) _PySeqLock_LockWrite(_PySeqLock *seqlock); + +// Unlock the sequence lock and move to the next sequence number. +PyAPI_FUNC(void) _PySeqLock_UnlockWrite(_PySeqLock *seqlock); + +// Abandon the current update indicating that no mutations have occurred +// and restore the previous sequence value. +PyAPI_FUNC(void) _PySeqLock_AbandonWrite(_PySeqLock *seqlock); + +// Begin a read operation and return the current sequence number. +PyAPI_FUNC(uint32_t) _PySeqLock_BeginRead(_PySeqLock *seqlock); + +// End the read operation and confirm that the sequence number has not changed. +// Returns 1 if the read was successful or 0 if the read should be retried. +PyAPI_FUNC(int) _PySeqLock_EndRead(_PySeqLock *seqlock, uint32_t previous); + +// Check if the lock was held during a fork and clear the lock. Returns 1 +// if the lock was held and any associated data should be cleared. +PyAPI_FUNC(int) _PySeqLock_AfterFork(_PySeqLock *seqlock); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_LOCK_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_long.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_long.h new file mode 100644 index 0000000000000000000000000000000000000000..36d6d7d702b4d0d68271a73325e3225bda2beca2 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_long.h @@ -0,0 +1,336 @@ +#ifndef Py_INTERNAL_LONG_H +#define Py_INTERNAL_LONG_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_bytesobject.h" // _PyBytesWriter +#include "pycore_runtime.h" // _Py_SINGLETON() + +/* + * Default int base conversion size limitation: Denial of Service prevention. + * + * Chosen such that this isn't wildly slow on modern hardware and so that + * everyone's existing deployed numpy test suite passes before + * https://github.com/numpy/numpy/issues/22098 is widely available. + * + * $ python -m timeit -s 's = "1"*4300' 'int(s)' + * 2000 loops, best of 5: 125 usec per loop + * $ python -m timeit -s 's = "1"*4300; v = int(s)' 'str(v)' + * 1000 loops, best of 5: 311 usec per loop + * (zen2 cloud VM) + * + * 4300 decimal digits fits a ~14284 bit number. + */ +#define _PY_LONG_DEFAULT_MAX_STR_DIGITS 4300 +/* + * Threshold for max digits check. For performance reasons int() and + * int.__str__() don't checks values that are smaller than this + * threshold. Acts as a guaranteed minimum size limit for bignums that + * applications can expect from CPython. + * + * % python -m timeit -s 's = "1"*640; v = int(s)' 'str(int(s))' + * 20000 loops, best of 5: 12 usec per loop + * + * "640 digits should be enough for anyone." - gps + * fits a ~2126 bit decimal number. + */ +#define _PY_LONG_MAX_STR_DIGITS_THRESHOLD 640 + +#if ((_PY_LONG_DEFAULT_MAX_STR_DIGITS != 0) && \ + (_PY_LONG_DEFAULT_MAX_STR_DIGITS < _PY_LONG_MAX_STR_DIGITS_THRESHOLD)) +# error "_PY_LONG_DEFAULT_MAX_STR_DIGITS smaller than threshold." +#endif + +/* runtime lifecycle */ + +extern PyStatus _PyLong_InitTypes(PyInterpreterState *); +extern void _PyLong_FiniTypes(PyInterpreterState *interp); + + +/* other API */ + +PyAPI_FUNC(void) _PyLong_ExactDealloc(PyObject *self); + +#define _PyLong_SMALL_INTS _Py_SINGLETON(small_ints) + +// _PyLong_GetZero() and _PyLong_GetOne() must always be available +// _PyLong_FromUnsignedChar must always be available +#if _PY_NSMALLPOSINTS < 257 +# error "_PY_NSMALLPOSINTS must be greater than or equal to 257" +#endif + +#define _PY_IS_SMALL_INT(val) \ + (-_PY_NSMALLNEGINTS <= (val) && (val) < _PY_NSMALLPOSINTS) + +// Return a reference to the immortal zero singleton. +// The function cannot return NULL. +static inline PyObject* _PyLong_GetZero(void) +{ return (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS]; } + +// Return a reference to the immortal one singleton. +// The function cannot return NULL. +static inline PyObject* _PyLong_GetOne(void) +{ return (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS+1]; } + +static inline PyObject* _PyLong_FromUnsignedChar(unsigned char i) +{ + return (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS+i]; +} + +// _PyLong_Frexp returns a double x and an exponent e such that the +// true value is approximately equal to x * 2**e. x is +// 0.0 if and only if the input is 0 (in which case, e and x are both +// zeroes); otherwise, 0.5 <= abs(x) < 1.0. +// Always successful. +// +// Export for 'math' shared extension +PyAPI_DATA(double) _PyLong_Frexp(PyLongObject *a, int64_t *e); + +extern PyObject* _PyLong_FromBytes(const char *, Py_ssize_t, int); + +// _PyLong_DivmodNear. Given integers a and b, compute the nearest +// integer q to the exact quotient a / b, rounding to the nearest even integer +// in the case of a tie. Return (q, r), where r = a - q*b. The remainder r +// will satisfy abs(r) <= abs(b)/2, with equality possible only if q is +// even. +// +// Export for '_datetime' shared extension. +PyAPI_DATA(PyObject*) _PyLong_DivmodNear(PyObject *, PyObject *); + +// _PyLong_Format: Convert the long to a string object with given base, +// appending a base prefix of 0[box] if base is 2, 8 or 16. +// Export for '_tkinter' shared extension. +PyAPI_DATA(PyObject*) _PyLong_Format(PyObject *obj, int base); + +// Export for 'math' shared extension +PyAPI_DATA(PyObject*) _PyLong_Rshift(PyObject *, int64_t); + +// Export for 'math' shared extension +PyAPI_DATA(PyObject*) _PyLong_Lshift(PyObject *, int64_t); + +PyAPI_FUNC(PyObject*) _PyLong_Add(PyLongObject *left, PyLongObject *right); +PyAPI_FUNC(PyObject*) _PyLong_Multiply(PyLongObject *left, PyLongObject *right); +PyAPI_FUNC(PyObject*) _PyLong_Subtract(PyLongObject *left, PyLongObject *right); + +// Export for 'binascii' shared extension. +PyAPI_DATA(unsigned char) _PyLong_DigitValue[256]; + +/* Format the object based on the format_spec, as defined in PEP 3101 + (Advanced String Formatting). */ +extern int _PyLong_FormatAdvancedWriter( + _PyUnicodeWriter *writer, + PyObject *obj, + PyObject *format_spec, + Py_ssize_t start, + Py_ssize_t end); + +extern int _PyLong_FormatWriter( + _PyUnicodeWriter *writer, + PyObject *obj, + int base, + int alternate); + +extern char* _PyLong_FormatBytesWriter( + _PyBytesWriter *writer, + char *str, + PyObject *obj, + int base, + int alternate); + +// Argument converters used by Argument Clinic + +// Export for 'select' shared extension (Argument Clinic code) +PyAPI_FUNC(int) _PyLong_UnsignedShort_Converter(PyObject *, void *); + +// Export for '_testclinic' shared extension (Argument Clinic code) +PyAPI_FUNC(int) _PyLong_UnsignedInt_Converter(PyObject *, void *); + +// Export for '_blake2' shared extension (Argument Clinic code) +PyAPI_FUNC(int) _PyLong_UnsignedLong_Converter(PyObject *, void *); + +// Export for '_blake2' shared extension (Argument Clinic code) +PyAPI_FUNC(int) _PyLong_UnsignedLongLong_Converter(PyObject *, void *); + +// Export for '_testclinic' shared extension (Argument Clinic code) +PyAPI_FUNC(int) _PyLong_Size_t_Converter(PyObject *, void *); + +PyAPI_FUNC(int) _PyLong_UInt8_Converter(PyObject *, void *); +PyAPI_FUNC(int) _PyLong_UInt16_Converter(PyObject *, void *); +PyAPI_FUNC(int) _PyLong_UInt32_Converter(PyObject *, void *); +PyAPI_FUNC(int) _PyLong_UInt64_Converter(PyObject *, void *); + +/* Long value tag bits: + * 0-1: Sign bits value = (1-sign), ie. negative=2, positive=0, zero=1. + * 2: Set to 1 for the small ints + * 3+ Unsigned digit count + */ +#define SIGN_MASK 3 +#define SIGN_ZERO 1 +#define SIGN_NEGATIVE 2 +#define NON_SIZE_BITS 3 +#define IMMORTALITY_BIT_MASK (1 << 2) + +/* The functions _PyLong_IsCompact and _PyLong_CompactValue are defined + * in Include/cpython/longobject.h, since they need to be inline. + * + * "Compact" values have at least one bit to spare, + * so that addition and subtraction can be performed on the values + * without risk of overflow. + * + * The inline functions need tag bits. + * For readability, rather than do `#define SIGN_MASK _PyLong_SIGN_MASK` + * we define them to the numbers in both places and then assert that + * they're the same. + */ +#if SIGN_MASK != _PyLong_SIGN_MASK +# error "SIGN_MASK does not match _PyLong_SIGN_MASK" +#endif +#if NON_SIZE_BITS != _PyLong_NON_SIZE_BITS +# error "NON_SIZE_BITS does not match _PyLong_NON_SIZE_BITS" +#endif + +/* All *compact" values are guaranteed to fit into + * a Py_ssize_t with at least one bit to spare. + * In other words, for 64 bit machines, compact + * will be signed 63 (or fewer) bit values + */ + +/* Return 1 if the argument is compact int */ +static inline int +_PyLong_IsNonNegativeCompact(const PyLongObject* op) { + assert(PyLong_Check(op)); + return ((op->long_value.lv_tag & ~IMMORTALITY_BIT_MASK) <= (1 << NON_SIZE_BITS)); +} + + +static inline int +_PyLong_BothAreCompact(const PyLongObject* a, const PyLongObject* b) { + assert(PyLong_Check(a)); + assert(PyLong_Check(b)); + return (a->long_value.lv_tag | b->long_value.lv_tag) < (2 << NON_SIZE_BITS); +} + +static inline bool +_PyLong_IsZero(const PyLongObject *op) +{ + return (op->long_value.lv_tag & SIGN_MASK) == SIGN_ZERO; +} + +static inline bool +_PyLong_IsNegative(const PyLongObject *op) +{ + return (op->long_value.lv_tag & SIGN_MASK) == SIGN_NEGATIVE; +} + +static inline bool +_PyLong_IsPositive(const PyLongObject *op) +{ + return (op->long_value.lv_tag & SIGN_MASK) == 0; +} + +/* Return true if the argument is a small int */ +static inline bool +_PyLong_IsSmallInt(const PyLongObject *op) +{ + assert(PyLong_Check(op)); + bool is_small_int = (op->long_value.lv_tag & IMMORTALITY_BIT_MASK) != 0; + assert(PyLong_CheckExact(op) || (!is_small_int)); + assert(_Py_IsImmortal(op) || (!is_small_int)); + assert((_PyLong_IsCompact(op) + && _PY_IS_SMALL_INT(_PyLong_CompactValue(op))) + || (!is_small_int)); + return is_small_int; +} + +static inline Py_ssize_t +_PyLong_DigitCount(const PyLongObject *op) +{ + assert(PyLong_Check(op)); + return (Py_ssize_t)(op->long_value.lv_tag >> NON_SIZE_BITS); +} + +/* Equivalent to _PyLong_DigitCount(op) * _PyLong_NonCompactSign(op) */ +static inline Py_ssize_t +_PyLong_SignedDigitCount(const PyLongObject *op) +{ + assert(PyLong_Check(op)); + Py_ssize_t sign = 1 - (op->long_value.lv_tag & SIGN_MASK); + return sign * (Py_ssize_t)(op->long_value.lv_tag >> NON_SIZE_BITS); +} + +static inline int +_PyLong_CompactSign(const PyLongObject *op) +{ + assert(PyLong_Check(op)); + assert(_PyLong_IsCompact((PyLongObject *)op)); + return 1 - (op->long_value.lv_tag & SIGN_MASK); +} + +static inline int +_PyLong_NonCompactSign(const PyLongObject *op) +{ + assert(PyLong_Check(op)); + assert(!_PyLong_IsCompact((PyLongObject *)op)); + return 1 - (op->long_value.lv_tag & SIGN_MASK); +} + +/* Do a and b have the same sign? */ +static inline int +_PyLong_SameSign(const PyLongObject *a, const PyLongObject *b) +{ + return (a->long_value.lv_tag & SIGN_MASK) == (b->long_value.lv_tag & SIGN_MASK); +} + +#define TAG_FROM_SIGN_AND_SIZE(sign, size) \ + ((uintptr_t)(1 - (sign)) | ((uintptr_t)(size) << NON_SIZE_BITS)) + +static inline void +_PyLong_SetSignAndDigitCount(PyLongObject *op, int sign, Py_ssize_t size) +{ + assert(size >= 0); + assert(-1 <= sign && sign <= 1); + assert(sign != 0 || size == 0); + op->long_value.lv_tag = TAG_FROM_SIGN_AND_SIZE(sign, size); +} + +static inline void +_PyLong_SetDigitCount(PyLongObject *op, Py_ssize_t size) +{ + assert(size >= 0); + op->long_value.lv_tag = (((size_t)size) << NON_SIZE_BITS) | (op->long_value.lv_tag & SIGN_MASK); +} + +#define NON_SIZE_MASK ~(uintptr_t)((1 << NON_SIZE_BITS) - 1) + +static inline void +_PyLong_FlipSign(PyLongObject *op) +{ + assert(!_PyLong_IsSmallInt(op)); + unsigned int flipped_sign = 2 - (op->long_value.lv_tag & SIGN_MASK); + op->long_value.lv_tag &= NON_SIZE_MASK; + op->long_value.lv_tag |= flipped_sign; +} + +#define _PyLong_DIGIT_INIT(val) \ + { \ + .ob_base = _PyObject_HEAD_INIT(&PyLong_Type), \ + .long_value = { \ + .lv_tag = TAG_FROM_SIGN_AND_SIZE( \ + (val) == 0 ? 0 : ((val) < 0 ? -1 : 1), \ + (val) == 0 ? 0 : 1) | IMMORTALITY_BIT_MASK, \ + { ((val) >= 0 ? (val) : -(val)) }, \ + } \ + } + +#define _PyLong_FALSE_TAG TAG_FROM_SIGN_AND_SIZE(0, 0) +#define _PyLong_TRUE_TAG TAG_FROM_SIGN_AND_SIZE(1, 1) + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_LONG_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_magic_number.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_magic_number.h new file mode 100644 index 0000000000000000000000000000000000000000..f31951057121d92a33a7f5a3d4a99fb66fa0e6da --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_magic_number.h @@ -0,0 +1,305 @@ +#ifndef Py_INTERNAL_MAGIC_NUMBER_H +#define Py_INTERNAL_MAGIC_NUMBER_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* + +Magic number to reject .pyc files generated by other Python versions. +It should change for each incompatible change to the bytecode. + +PYC_MAGIC_NUMBER must change whenever the bytecode emitted by the compiler may +no longer be understood by older implementations of the eval loop (usually due +to the addition of new opcodes). + +The value of CR and LF is incorporated so if you ever read or write +a .pyc file in text mode the magic number will be wrong; also, the +Apple MPW compiler swaps their values, botching string constants. + +There were a variety of old schemes for setting the magic number. Starting with +Python 3.11, Python 3.n starts with magic number 2900+50n. Within each minor +version, the magic number is incremented by 1 each time the file format changes. + +Known values: + Python 1.5: 20121 + Python 1.5.1: 20121 + Python 1.5.2: 20121 + Python 1.6: 50428 + Python 2.0: 50823 + Python 2.0.1: 50823 + Python 2.1: 60202 + Python 2.1.1: 60202 + Python 2.1.2: 60202 + Python 2.2: 60717 + Python 2.3a0: 62011 + Python 2.3a0: 62021 + Python 2.3a0: 62011 (!) + Python 2.4a0: 62041 + Python 2.4a3: 62051 + Python 2.4b1: 62061 + Python 2.5a0: 62071 + Python 2.5a0: 62081 (ast-branch) + Python 2.5a0: 62091 (with) + Python 2.5a0: 62092 (changed WITH_CLEANUP opcode) + Python 2.5b3: 62101 (fix wrong code: for x, in ...) + Python 2.5b3: 62111 (fix wrong code: x += yield) + Python 2.5c1: 62121 (fix wrong lnotab with for loops and + storing constants that should have been removed) + Python 2.5c2: 62131 (fix wrong code: for x, in ... in listcomp/genexp) + Python 2.6a0: 62151 (peephole optimizations and STORE_MAP opcode) + Python 2.6a1: 62161 (WITH_CLEANUP optimization) + Python 2.7a0: 62171 (optimize list comprehensions/change LIST_APPEND) + Python 2.7a0: 62181 (optimize conditional branches: + introduce POP_JUMP_IF_FALSE and POP_JUMP_IF_TRUE) + Python 2.7a0 62191 (introduce SETUP_WITH) + Python 2.7a0 62201 (introduce BUILD_SET) + Python 2.7a0 62211 (introduce MAP_ADD and SET_ADD) + Python 3000: 3000 + 3010 (removed UNARY_CONVERT) + 3020 (added BUILD_SET) + 3030 (added keyword-only parameters) + 3040 (added signature annotations) + 3050 (print becomes a function) + 3060 (PEP 3115 metaclass syntax) + 3061 (string literals become unicode) + 3071 (PEP 3109 raise changes) + 3081 (PEP 3137 make __file__ and __name__ unicode) + 3091 (kill str8 interning) + 3101 (merge from 2.6a0, see 62151) + 3103 (__file__ points to source file) + Python 3.0a4: 3111 (WITH_CLEANUP optimization). + Python 3.0b1: 3131 (lexical exception stacking, including POP_EXCEPT + #3021) + Python 3.1a1: 3141 (optimize list, set and dict comprehensions: + change LIST_APPEND and SET_ADD, add MAP_ADD #2183) + Python 3.1a1: 3151 (optimize conditional branches: + introduce POP_JUMP_IF_FALSE and POP_JUMP_IF_TRUE + #4715) + Python 3.2a1: 3160 (add SETUP_WITH #6101) + Python 3.2a2: 3170 (add DUP_TOP_TWO, remove DUP_TOPX and ROT_FOUR #9225) + Python 3.2a3 3180 (add DELETE_DEREF #4617) + Python 3.3a1 3190 (__class__ super closure changed) + Python 3.3a1 3200 (PEP 3155 __qualname__ added #13448) + Python 3.3a1 3210 (added size modulo 2**32 to the pyc header #13645) + Python 3.3a2 3220 (changed PEP 380 implementation #14230) + Python 3.3a4 3230 (revert changes to implicit __class__ closure #14857) + Python 3.4a1 3250 (evaluate positional default arguments before + keyword-only defaults #16967) + Python 3.4a1 3260 (add LOAD_CLASSDEREF; allow locals of class to override + free vars #17853) + Python 3.4a1 3270 (various tweaks to the __class__ closure #12370) + Python 3.4a1 3280 (remove implicit class argument) + Python 3.4a4 3290 (changes to __qualname__ computation #19301) + Python 3.4a4 3300 (more changes to __qualname__ computation #19301) + Python 3.4rc2 3310 (alter __qualname__ computation #20625) + Python 3.5a1 3320 (PEP 465: Matrix multiplication operator #21176) + Python 3.5b1 3330 (PEP 448: Additional Unpacking Generalizations #2292) + Python 3.5b2 3340 (fix dictionary display evaluation order #11205) + Python 3.5b3 3350 (add GET_YIELD_FROM_ITER opcode #24400) + Python 3.5.2 3351 (fix BUILD_MAP_UNPACK_WITH_CALL opcode #27286) + Python 3.6a0 3360 (add FORMAT_VALUE opcode #25483) + Python 3.6a1 3361 (lineno delta of code.co_lnotab becomes signed #26107) + Python 3.6a2 3370 (16 bit wordcode #26647) + Python 3.6a2 3371 (add BUILD_CONST_KEY_MAP opcode #27140) + Python 3.6a2 3372 (MAKE_FUNCTION simplification, remove MAKE_CLOSURE + #27095) + Python 3.6b1 3373 (add BUILD_STRING opcode #27078) + Python 3.6b1 3375 (add SETUP_ANNOTATIONS and STORE_ANNOTATION opcodes + #27985) + Python 3.6b1 3376 (simplify CALL_FUNCTIONs & BUILD_MAP_UNPACK_WITH_CALL + #27213) + Python 3.6b1 3377 (set __class__ cell from type.__new__ #23722) + Python 3.6b2 3378 (add BUILD_TUPLE_UNPACK_WITH_CALL #28257) + Python 3.6rc1 3379 (more thorough __class__ validation #23722) + Python 3.7a1 3390 (add LOAD_METHOD and CALL_METHOD opcodes #26110) + Python 3.7a2 3391 (update GET_AITER #31709) + Python 3.7a4 3392 (PEP 552: Deterministic pycs #31650) + Python 3.7b1 3393 (remove STORE_ANNOTATION opcode #32550) + Python 3.7b5 3394 (restored docstring as the first stmt in the body; + this might affected the first line number #32911) + Python 3.8a1 3400 (move frame block handling to compiler #17611) + Python 3.8a1 3401 (add END_ASYNC_FOR #33041) + Python 3.8a1 3410 (PEP570 Python Positional-Only Parameters #36540) + Python 3.8b2 3411 (Reverse evaluation order of key: value in dict + comprehensions #35224) + Python 3.8b2 3412 (Swap the position of positional args and positional + only args in ast.arguments #37593) + Python 3.8b4 3413 (Fix "break" and "continue" in "finally" #37830) + Python 3.9a0 3420 (add LOAD_ASSERTION_ERROR #34880) + Python 3.9a0 3421 (simplified bytecode for with blocks #32949) + Python 3.9a0 3422 (remove BEGIN_FINALLY, END_FINALLY, CALL_FINALLY, POP_FINALLY bytecodes #33387) + Python 3.9a2 3423 (add IS_OP, CONTAINS_OP and JUMP_IF_NOT_EXC_MATCH bytecodes #39156) + Python 3.9a2 3424 (simplify bytecodes for *value unpacking) + Python 3.9a2 3425 (simplify bytecodes for **value unpacking) + Python 3.10a1 3430 (Make 'annotations' future by default) + Python 3.10a1 3431 (New line number table format -- PEP 626) + Python 3.10a2 3432 (Function annotation for MAKE_FUNCTION is changed from dict to tuple bpo-42202) + Python 3.10a2 3433 (RERAISE restores f_lasti if oparg != 0) + Python 3.10a6 3434 (PEP 634: Structural Pattern Matching) + Python 3.10a7 3435 Use instruction offsets (as opposed to byte offsets). + Python 3.10b1 3436 (Add GEN_START bytecode #43683) + Python 3.10b1 3437 (Undo making 'annotations' future by default - We like to dance among core devs!) + Python 3.10b1 3438 Safer line number table handling. + Python 3.10b1 3439 (Add ROT_N) + Python 3.11a1 3450 Use exception table for unwinding ("zero cost" exception handling) + Python 3.11a1 3451 (Add CALL_METHOD_KW) + Python 3.11a1 3452 (drop nlocals from marshaled code objects) + Python 3.11a1 3453 (add co_fastlocalnames and co_fastlocalkinds) + Python 3.11a1 3454 (compute cell offsets relative to locals bpo-43693) + Python 3.11a1 3455 (add MAKE_CELL bpo-43693) + Python 3.11a1 3456 (interleave cell args bpo-43693) + Python 3.11a1 3457 (Change localsplus to a bytes object bpo-43693) + Python 3.11a1 3458 (imported objects now don't use LOAD_METHOD/CALL_METHOD) + Python 3.11a1 3459 (PEP 657: add end line numbers and column offsets for instructions) + Python 3.11a1 3460 (Add co_qualname field to PyCodeObject bpo-44530) + Python 3.11a1 3461 (JUMP_ABSOLUTE must jump backwards) + Python 3.11a2 3462 (bpo-44511: remove COPY_DICT_WITHOUT_KEYS, change + MATCH_CLASS and MATCH_KEYS, and add COPY) + Python 3.11a3 3463 (bpo-45711: JUMP_IF_NOT_EXC_MATCH no longer pops the + active exception) + Python 3.11a3 3464 (bpo-45636: Merge numeric BINARY_*INPLACE_* into + BINARY_OP) + Python 3.11a3 3465 (Add COPY_FREE_VARS opcode) + Python 3.11a4 3466 (bpo-45292: PEP-654 except*) + Python 3.11a4 3467 (Change CALL_xxx opcodes) + Python 3.11a4 3468 (Add SEND opcode) + Python 3.11a4 3469 (bpo-45711: remove type, traceback from exc_info) + Python 3.11a4 3470 (bpo-46221: PREP_RERAISE_STAR no longer pushes lasti) + Python 3.11a4 3471 (bpo-46202: remove pop POP_EXCEPT_AND_RERAISE) + Python 3.11a4 3472 (bpo-46009: replace GEN_START with POP_TOP) + Python 3.11a4 3473 (Add POP_JUMP_IF_NOT_NONE/POP_JUMP_IF_NONE opcodes) + Python 3.11a4 3474 (Add RESUME opcode) + Python 3.11a5 3475 (Add RETURN_GENERATOR opcode) + Python 3.11a5 3476 (Add ASYNC_GEN_WRAP opcode) + Python 3.11a5 3477 (Replace DUP_TOP/DUP_TOP_TWO with COPY and + ROT_TWO/ROT_THREE/ROT_FOUR/ROT_N with SWAP) + Python 3.11a5 3478 (New CALL opcodes) + Python 3.11a5 3479 (Add PUSH_NULL opcode) + Python 3.11a5 3480 (New CALL opcodes, second iteration) + Python 3.11a5 3481 (Use inline cache for BINARY_OP) + Python 3.11a5 3482 (Use inline caching for UNPACK_SEQUENCE and LOAD_GLOBAL) + Python 3.11a5 3483 (Use inline caching for COMPARE_OP and BINARY_SUBSCR) + Python 3.11a5 3484 (Use inline caching for LOAD_ATTR, LOAD_METHOD, and + STORE_ATTR) + Python 3.11a5 3485 (Add an oparg to GET_AWAITABLE) + Python 3.11a6 3486 (Use inline caching for PRECALL and CALL) + Python 3.11a6 3487 (Remove the adaptive "oparg counter" mechanism) + Python 3.11a6 3488 (LOAD_GLOBAL can push additional NULL) + Python 3.11a6 3489 (Add JUMP_BACKWARD, remove JUMP_ABSOLUTE) + Python 3.11a6 3490 (remove JUMP_IF_NOT_EXC_MATCH, add CHECK_EXC_MATCH) + Python 3.11a6 3491 (remove JUMP_IF_NOT_EG_MATCH, add CHECK_EG_MATCH, + add JUMP_BACKWARD_NO_INTERRUPT, make JUMP_NO_INTERRUPT virtual) + Python 3.11a7 3492 (make POP_JUMP_IF_NONE/NOT_NONE/TRUE/FALSE relative) + Python 3.11a7 3493 (Make JUMP_IF_TRUE_OR_POP/JUMP_IF_FALSE_OR_POP relative) + Python 3.11a7 3494 (New location info table) + Python 3.11b4 3495 (Set line number of module's RESUME instr to 0 per PEP 626) + Python 3.12a1 3500 (Remove PRECALL opcode) + Python 3.12a1 3501 (YIELD_VALUE oparg == stack_depth) + Python 3.12a1 3502 (LOAD_FAST_CHECK, no NULL-check in LOAD_FAST) + Python 3.12a1 3503 (Shrink LOAD_METHOD cache) + Python 3.12a1 3504 (Merge LOAD_METHOD back into LOAD_ATTR) + Python 3.12a1 3505 (Specialization/Cache for FOR_ITER) + Python 3.12a1 3506 (Add BINARY_SLICE and STORE_SLICE instructions) + Python 3.12a1 3507 (Set lineno of module's RESUME to 0) + Python 3.12a1 3508 (Add CLEANUP_THROW) + Python 3.12a1 3509 (Conditional jumps only jump forward) + Python 3.12a2 3510 (FOR_ITER leaves iterator on the stack) + Python 3.12a2 3511 (Add STOPITERATION_ERROR instruction) + Python 3.12a2 3512 (Remove all unused consts from code objects) + Python 3.12a4 3513 (Add CALL_INTRINSIC_1 instruction, removed STOPITERATION_ERROR, PRINT_EXPR, IMPORT_STAR) + Python 3.12a4 3514 (Remove ASYNC_GEN_WRAP, LIST_TO_TUPLE, and UNARY_POSITIVE) + Python 3.12a5 3515 (Embed jump mask in COMPARE_OP oparg) + Python 3.12a5 3516 (Add COMPARE_AND_BRANCH instruction) + Python 3.12a5 3517 (Change YIELD_VALUE oparg to exception block depth) + Python 3.12a6 3518 (Add RETURN_CONST instruction) + Python 3.12a6 3519 (Modify SEND instruction) + Python 3.12a6 3520 (Remove PREP_RERAISE_STAR, add CALL_INTRINSIC_2) + Python 3.12a7 3521 (Shrink the LOAD_GLOBAL caches) + Python 3.12a7 3522 (Removed JUMP_IF_FALSE_OR_POP/JUMP_IF_TRUE_OR_POP) + Python 3.12a7 3523 (Convert COMPARE_AND_BRANCH back to COMPARE_OP) + Python 3.12a7 3524 (Shrink the BINARY_SUBSCR caches) + Python 3.12b1 3525 (Shrink the CALL caches) + Python 3.12b1 3526 (Add instrumentation support) + Python 3.12b1 3527 (Add LOAD_SUPER_ATTR) + Python 3.12b1 3528 (Add LOAD_SUPER_ATTR_METHOD specialization) + Python 3.12b1 3529 (Inline list/dict/set comprehensions) + Python 3.12b1 3530 (Shrink the LOAD_SUPER_ATTR caches) + Python 3.12b1 3531 (Add PEP 695 changes) + Python 3.13a1 3550 (Plugin optimizer support) + Python 3.13a1 3551 (Compact superinstructions) + Python 3.13a1 3552 (Remove LOAD_FAST__LOAD_CONST and LOAD_CONST__LOAD_FAST) + Python 3.13a1 3553 (Add SET_FUNCTION_ATTRIBUTE) + Python 3.13a1 3554 (more efficient bytecodes for f-strings) + Python 3.13a1 3555 (generate specialized opcodes metadata from bytecodes.c) + Python 3.13a1 3556 (Convert LOAD_CLOSURE to a pseudo-op) + Python 3.13a1 3557 (Make the conversion to boolean in jumps explicit) + Python 3.13a1 3558 (Reorder the stack items for CALL) + Python 3.13a1 3559 (Generate opcode IDs from bytecodes.c) + Python 3.13a1 3560 (Add RESUME_CHECK instruction) + Python 3.13a1 3561 (Add cache entry to branch instructions) + Python 3.13a1 3562 (Assign opcode IDs for internal ops in separate range) + Python 3.13a1 3563 (Add CALL_KW and remove KW_NAMES) + Python 3.13a1 3564 (Removed oparg from YIELD_VALUE, changed oparg values of RESUME) + Python 3.13a1 3565 (Oparg of YIELD_VALUE indicates whether it is in a yield-from) + Python 3.13a1 3566 (Emit JUMP_NO_INTERRUPT instead of JUMP for non-loop no-lineno cases) + Python 3.13a1 3567 (Reimplement line number propagation by the compiler) + Python 3.13a1 3568 (Change semantics of END_FOR) + Python 3.13a5 3569 (Specialize CONTAINS_OP) + Python 3.13a6 3570 (Add __firstlineno__ class attribute) + Python 3.13b1 3571 (Fix miscompilation of private names in generic classes) + Python 3.14a1 3600 (Add LOAD_COMMON_CONSTANT) + Python 3.14a1 3601 (Fix miscompilation of private names in generic classes) + Python 3.14a1 3602 (Add LOAD_SPECIAL. Remove BEFORE_WITH and BEFORE_ASYNC_WITH) + Python 3.14a1 3603 (Remove BUILD_CONST_KEY_MAP) + Python 3.14a1 3604 (Do not duplicate test at end of while statements) + Python 3.14a1 3605 (Move ENTER_EXECUTOR to opcode 255) + Python 3.14a1 3606 (Specialize CALL_KW) + Python 3.14a1 3607 (Add pseudo instructions JUMP_IF_TRUE/FALSE) + Python 3.14a1 3608 (Add support for slices) + Python 3.14a2 3609 (Add LOAD_SMALL_INT and LOAD_CONST_IMMORTAL instructions, remove RETURN_CONST) + Python 3.14a4 3610 (Add VALUE_WITH_FAKE_GLOBALS format to annotationlib) + Python 3.14a4 3611 (Add NOT_TAKEN instruction) + Python 3.14a4 3612 (Add POP_ITER and INSTRUMENTED_POP_ITER) + Python 3.14a4 3613 (Add LOAD_CONST_MORTAL instruction) + Python 3.14a5 3614 (Add BINARY_OP_EXTEND) + Python 3.14a5 3615 (CALL_FUNCTION_EX always take a kwargs argument) + Python 3.14a5 3616 (Remove BINARY_SUBSCR and family. Make them BINARY_OPs) + Python 3.14a6 3617 (Branch monitoring for async for loops) + Python 3.14a6 3618 (Add oparg to END_ASYNC_FOR) + Python 3.14a6 3619 (Renumber RESUME opcode from 149 to 128) + Python 3.14a6 3620 (Optimize bytecode for all/any/tuple called on a genexp) + Python 3.14a7 3621 (Optimize LOAD_FAST opcodes into LOAD_FAST_BORROW) + Python 3.14a7 3622 (Store annotations in different class dict keys) + Python 3.14a7 3623 (Add BUILD_INTERPOLATION & BUILD_TEMPLATE opcodes) + Python 3.14b1 3624 (Don't optimize LOAD_FAST when local is killed by DELETE_FAST) + Python 3.14b3 3625 (Fix handling of opcodes that may leave operands on the stack when optimizing LOAD_FAST) + Python 3.14rc2 3626 (Fix missing exception handlers in logical expression) + Python 3.14rc3 3627 (Fix miscompilation of some module-level annotations) + + Python 3.15 will start with 3650 + + Please don't copy-paste the same pre-release tag for new entries above!!! + You should always use the *upcoming* tag. For example, if 3.12a6 came out + a week ago, I should put "Python 3.12a7" next to my new magic number. + +Whenever PYC_MAGIC_NUMBER is changed, the ranges in the magic_values array in +PC/launcher.c must also be updated. + +*/ + +#define PYC_MAGIC_NUMBER 3627 +/* This is equivalent to converting PYC_MAGIC_NUMBER to 2 bytes + (little-endian) and then appending b'\r\n'. */ +#define PYC_MAGIC_NUMBER_TOKEN \ + ((uint32_t)PYC_MAGIC_NUMBER | ((uint32_t)'\r' << 16) | ((uint32_t)'\n' << 24)) + + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_MAGIC_NUMBER_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_memoryobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_memoryobject.h new file mode 100644 index 0000000000000000000000000000000000000000..62e204fcbf65339d252793e0ffd1e54b9f860ce3 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_memoryobject.h @@ -0,0 +1,20 @@ +#ifndef Py_INTERNAL_MEMORYOBJECT_H +#define Py_INTERNAL_MEMORYOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +extern PyTypeObject _PyManagedBuffer_Type; + +PyObject * +_PyMemoryView_FromBufferProc(PyObject *v, int flags, + getbufferproc bufferproc); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_MEMORYOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_mimalloc.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_mimalloc.h new file mode 100644 index 0000000000000000000000000000000000000000..d870d01beb702c060b7b81ff325a2900bc4d9012 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_mimalloc.h @@ -0,0 +1,69 @@ +#ifndef Py_INTERNAL_MIMALLOC_H +#define Py_INTERNAL_MIMALLOC_H + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#if defined(MIMALLOC_H) || defined(MIMALLOC_TYPES_H) +# error "pycore_mimalloc.h must be included before mimalloc.h" +#endif + +typedef enum { + _Py_MIMALLOC_HEAP_MEM = 0, // PyMem_Malloc() and friends + _Py_MIMALLOC_HEAP_OBJECT = 1, // non-GC objects + _Py_MIMALLOC_HEAP_GC = 2, // GC objects without pre-header + _Py_MIMALLOC_HEAP_GC_PRE = 3, // GC objects with pre-header + _Py_MIMALLOC_HEAP_COUNT +} _Py_mimalloc_heap_id; + +#include "pycore_pymem.h" + +#ifdef WITH_MIMALLOC +# ifdef Py_GIL_DISABLED +# define MI_PRIM_THREAD_ID _Py_ThreadId +# endif +# define MI_DEBUG_UNINIT PYMEM_CLEANBYTE +# define MI_DEBUG_FREED PYMEM_DEADBYTE +# define MI_DEBUG_PADDING PYMEM_FORBIDDENBYTE +#ifdef Py_DEBUG +# define MI_DEBUG 2 +#else +# define MI_DEBUG 0 +#endif + +#ifdef _Py_THREAD_SANITIZER +# define MI_TSAN 1 +#endif + +#ifdef __cplusplus +extern "C++" { +#endif + +#include "mimalloc/mimalloc.h" +#include "mimalloc/mimalloc/types.h" +#include "mimalloc/mimalloc/internal.h" + +#ifdef __cplusplus +} +#endif + +#endif + +#ifdef Py_GIL_DISABLED +struct _mimalloc_interp_state { + // When exiting, threads place any segments with live blocks in this + // shared pool for other threads to claim and reuse. + mi_abandoned_pool_t abandoned_pool; +}; + +struct _mimalloc_thread_state { + mi_heap_t *current_object_heap; + mi_heap_t heaps[_Py_MIMALLOC_HEAP_COUNT]; + mi_tld_t tld; + int initialized; + struct llist_node page_list; +}; +#endif + +#endif // Py_INTERNAL_MIMALLOC_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_modsupport.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_modsupport.h new file mode 100644 index 0000000000000000000000000000000000000000..614e9f93751834253f636f958ff0f93a940ae84f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_modsupport.h @@ -0,0 +1,99 @@ +#ifndef Py_INTERNAL_MODSUPPORT_H +#define Py_INTERNAL_MODSUPPORT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + + +extern int _PyArg_NoKwnames(const char *funcname, PyObject *kwnames); +#define _PyArg_NoKwnames(funcname, kwnames) \ + ((kwnames) == NULL || _PyArg_NoKwnames((funcname), (kwnames))) + +// Export for '_bz2' shared extension +PyAPI_FUNC(int) _PyArg_NoPositional(const char *funcname, PyObject *args); +#define _PyArg_NoPositional(funcname, args) \ + ((args) == NULL || _PyArg_NoPositional((funcname), (args))) + +// Export for '_asyncio' shared extension +PyAPI_FUNC(int) _PyArg_NoKeywords(const char *funcname, PyObject *kwargs); +#define _PyArg_NoKeywords(funcname, kwargs) \ + ((kwargs) == NULL || _PyArg_NoKeywords((funcname), (kwargs))) + +// Export for 'zlib' shared extension +PyAPI_FUNC(int) _PyArg_CheckPositional(const char *, Py_ssize_t, + Py_ssize_t, Py_ssize_t); +#define _Py_ANY_VARARGS(n) ((n) == PY_SSIZE_T_MAX) +#define _PyArg_CheckPositional(funcname, nargs, min, max) \ + ((!_Py_ANY_VARARGS(max) && (min) <= (nargs) && (nargs) <= (max)) \ + || _PyArg_CheckPositional((funcname), (nargs), (min), (max))) + +extern PyObject ** _Py_VaBuildStack( + PyObject **small_stack, + Py_ssize_t small_stack_len, + const char *format, + va_list va, + Py_ssize_t *p_nargs); + +extern PyObject* _PyModule_CreateInitialized(PyModuleDef*, int apiver); + +// Export for '_curses' shared extension +PyAPI_FUNC(int) _PyArg_ParseStack( + PyObject *const *args, + Py_ssize_t nargs, + const char *format, + ...); + +extern int _PyArg_UnpackStack( + PyObject *const *args, + Py_ssize_t nargs, + const char *name, + Py_ssize_t min, + Py_ssize_t max, + ...); + +// Export for '_heapq' shared extension +PyAPI_FUNC(void) _PyArg_BadArgument( + const char *fname, + const char *displayname, + const char *expected, + PyObject *arg); + +// --- _PyArg_Parser API --------------------------------------------------- + +// Export for '_dbm' shared extension +PyAPI_FUNC(int) _PyArg_ParseStackAndKeywords( + PyObject *const *args, + Py_ssize_t nargs, + PyObject *kwnames, + struct _PyArg_Parser *, + ...); + +// Export for 'math' shared extension +PyAPI_FUNC(PyObject * const *) _PyArg_UnpackKeywords( + PyObject *const *args, + Py_ssize_t nargs, + PyObject *kwargs, + PyObject *kwnames, + struct _PyArg_Parser *parser, + int minpos, + int maxpos, + int minkw, + int varpos, + PyObject **buf); +#define _PyArg_UnpackKeywords(args, nargs, kwargs, kwnames, parser, minpos, maxpos, minkw, varpos, buf) \ + (((minkw) == 0 && (kwargs) == NULL && (kwnames) == NULL && \ + (minpos) <= (nargs) && ((varpos) || (nargs) <= (maxpos)) && (args) != NULL) ? \ + (args) : \ + _PyArg_UnpackKeywords((args), (nargs), (kwargs), (kwnames), (parser), \ + (minpos), (maxpos), (minkw), (varpos), (buf))) + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_MODSUPPORT_H + diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_moduleobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_moduleobject.h new file mode 100644 index 0000000000000000000000000000000000000000..b170d7bce702c62f53b5677c1cfb975e4919e4df --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_moduleobject.h @@ -0,0 +1,62 @@ +#ifndef Py_INTERNAL_MODULEOBJECT_H +#define Py_INTERNAL_MODULEOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +extern void _PyModule_Clear(PyObject *); +extern void _PyModule_ClearDict(PyObject *); +extern int _PyModuleSpec_IsInitializing(PyObject *); +extern int _PyModuleSpec_GetFileOrigin(PyObject *, PyObject **); +extern int _PyModule_IsPossiblyShadowing(PyObject *); + +extern int _PyModule_IsExtension(PyObject *obj); + +typedef struct { + PyObject_HEAD + PyObject *md_dict; + PyModuleDef *md_def; + void *md_state; + PyObject *md_weaklist; + // for logging purposes after md_dict is cleared + PyObject *md_name; +#ifdef Py_GIL_DISABLED + void *md_gil; +#endif +} PyModuleObject; + +static inline PyModuleDef* _PyModule_GetDef(PyObject *mod) { + assert(PyModule_Check(mod)); + return ((PyModuleObject *)mod)->md_def; +} + +static inline void* _PyModule_GetState(PyObject* mod) { + assert(PyModule_Check(mod)); + return ((PyModuleObject *)mod)->md_state; +} + +static inline PyObject* _PyModule_GetDict(PyObject *mod) { + assert(PyModule_Check(mod)); + PyObject *dict = ((PyModuleObject *)mod) -> md_dict; + // _PyModule_GetDict(mod) must not be used after calling module_clear(mod) + assert(dict != NULL); + return dict; // borrowed reference +} + +extern PyObject * _PyModule_GetFilenameObject(PyObject *); +extern Py_ssize_t _PyModule_GetFilenameUTF8( + PyObject *module, + char *buffer, + Py_ssize_t maxlen); + +PyObject* _Py_module_getattro_impl(PyModuleObject *m, PyObject *name, int suppress); +PyObject* _Py_module_getattro(PyObject *m, PyObject *name); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_MODULEOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_namespace.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_namespace.h new file mode 100644 index 0000000000000000000000000000000000000000..f165cf15319a599b1aab816a6a7bca128159a6a9 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_namespace.h @@ -0,0 +1,21 @@ +// Simple namespace object interface + +#ifndef Py_INTERNAL_NAMESPACE_H +#define Py_INTERNAL_NAMESPACE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +extern PyTypeObject _PyNamespace_Type; + +// Export for '_testmultiphase' shared extension +PyAPI_FUNC(PyObject*) _PyNamespace_New(PyObject *kwds); + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_NAMESPACE_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_object.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_object.h new file mode 100644 index 0000000000000000000000000000000000000000..ca44b2c10998a92d09d2ae54f2cf77e4dc3e6473 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_object.h @@ -0,0 +1,1032 @@ +#ifndef Py_INTERNAL_OBJECT_H +#define Py_INTERNAL_OBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_emscripten_trampoline.h" // _PyCFunction_TrampolineCall() +#include "pycore_gc.h" // _PyObject_GC_TRACK() +#include "pycore_pyatomic_ft_wrappers.h" // FT_ATOMIC_LOAD_PTR_ACQUIRE() +#include "pycore_pystate.h" // _PyInterpreterState_GET() +#include "pycore_runtime.h" // _PyRuntime +#include "pycore_typeobject.h" // _PyStaticType_GetState() +#include "pycore_uniqueid.h" // _PyObject_ThreadIncrefSlow() + +#include // bool + + +// This value is added to `ob_ref_shared` for objects that use deferred +// reference counting so that they are not immediately deallocated when the +// non-deferred reference count drops to zero. +// +// The value is half the maximum shared refcount because the low two bits of +// `ob_ref_shared` are used for flags. +#define _Py_REF_DEFERRED (PY_SSIZE_T_MAX / 8) + +/* For backwards compatibility -- Do not use this */ +#define _Py_IsImmortalLoose(op) _Py_IsImmortal + + +/* Check if an object is consistent. For example, ensure that the reference + counter is greater than or equal to 1, and ensure that ob_type is not NULL. + + Call _PyObject_AssertFailed() if the object is inconsistent. + + If check_content is zero, only check header fields: reduce the overhead. + + The function always return 1. The return value is just here to be able to + write: + + assert(_PyObject_CheckConsistency(obj, 1)); */ +extern int _PyObject_CheckConsistency(PyObject *op, int check_content); + +extern void _PyDebugAllocatorStats(FILE *out, const char *block_name, + int num_blocks, size_t sizeof_block); + +extern void _PyObject_DebugTypeStats(FILE *out); + +#ifdef Py_TRACE_REFS +// Forget a reference registered by _Py_NewReference(). Function called by +// _Py_Dealloc(). +// +// On a free list, the function can be used before modifying an object to +// remove the object from traced objects. Then _Py_NewReference() or +// _Py_NewReferenceNoTotal() should be called again on the object to trace +// it again. +extern void _Py_ForgetReference(PyObject *); +#endif + +// Export for shared _testinternalcapi extension +PyAPI_FUNC(int) _PyObject_IsFreed(PyObject *); + +/* We need to maintain an internal copy of Py{Var}Object_HEAD_INIT to avoid + designated initializer conflicts in C++20. If we use the definition in + object.h, we will be mixing designated and non-designated initializers in + pycore objects which is forbiddent in C++20. However, if we then use + designated initializers in object.h then Extensions without designated break. + Furthermore, we can't use designated initializers in Extensions since these + are not supported pre-C++20. Thus, keeping an internal copy here is the most + backwards compatible solution */ +#if defined(Py_GIL_DISABLED) +#define _PyObject_HEAD_INIT(type) \ + { \ + .ob_ref_local = _Py_IMMORTAL_REFCNT_LOCAL, \ + .ob_flags = _Py_STATICALLY_ALLOCATED_FLAG, \ + .ob_gc_bits = _PyGC_BITS_DEFERRED, \ + .ob_type = (type) \ + } +#else +#if SIZEOF_VOID_P > 4 +#define _PyObject_HEAD_INIT(type) \ + { \ + .ob_refcnt = _Py_IMMORTAL_INITIAL_REFCNT, \ + .ob_flags = _Py_STATIC_FLAG_BITS, \ + .ob_type = (type) \ + } +#else +#define _PyObject_HEAD_INIT(type) \ + { \ + .ob_refcnt = _Py_STATIC_IMMORTAL_INITIAL_REFCNT, \ + .ob_type = (type) \ + } +#endif +#endif +#define _PyVarObject_HEAD_INIT(type, size) \ + { \ + .ob_base = _PyObject_HEAD_INIT(type), \ + .ob_size = size \ + } + +PyAPI_FUNC(void) _Py_NO_RETURN _Py_FatalRefcountErrorFunc( + const char *func, + const char *message); + +#define _Py_FatalRefcountError(message) \ + _Py_FatalRefcountErrorFunc(__func__, (message)) + +#define _PyReftracerTrack(obj, operation) \ + do { \ + struct _reftracer_runtime_state *tracer = &_PyRuntime.ref_tracer; \ + if (tracer->tracer_func != NULL) { \ + void *data = tracer->tracer_data; \ + tracer->tracer_func((obj), (operation), data); \ + } \ + } while(0) + +#ifdef Py_REF_DEBUG +/* The symbol is only exposed in the API for the sake of extensions + built against the pre-3.12 stable ABI. */ +PyAPI_DATA(Py_ssize_t) _Py_RefTotal; + +extern void _Py_AddRefTotal(PyThreadState *, Py_ssize_t); +extern PyAPI_FUNC(void) _Py_IncRefTotal(PyThreadState *); +extern PyAPI_FUNC(void) _Py_DecRefTotal(PyThreadState *); + +# define _Py_DEC_REFTOTAL(interp) \ + interp->object_state.reftotal-- +#endif + +// Increment reference count by n +static inline void _Py_RefcntAdd(PyObject* op, Py_ssize_t n) +{ + if (_Py_IsImmortal(op)) { + _Py_INCREF_IMMORTAL_STAT_INC(); + return; + } +#ifndef Py_GIL_DISABLED + Py_ssize_t refcnt = _Py_REFCNT(op); + Py_ssize_t new_refcnt = refcnt + n; + if (new_refcnt >= (Py_ssize_t)_Py_IMMORTAL_MINIMUM_REFCNT) { + new_refcnt = _Py_IMMORTAL_INITIAL_REFCNT; + } +# if SIZEOF_VOID_P > 4 + op->ob_refcnt = (PY_UINT32_T)new_refcnt; +# else + op->ob_refcnt = new_refcnt; +# endif +# ifdef Py_REF_DEBUG + _Py_AddRefTotal(_PyThreadState_GET(), new_refcnt - refcnt); +# endif +#else + if (_Py_IsOwnedByCurrentThread(op)) { + uint32_t local = op->ob_ref_local; + Py_ssize_t refcnt = (Py_ssize_t)local + n; +# if PY_SSIZE_T_MAX > UINT32_MAX + if (refcnt > (Py_ssize_t)UINT32_MAX) { + // Make the object immortal if the 32-bit local reference count + // would overflow. + refcnt = _Py_IMMORTAL_REFCNT_LOCAL; + } +# endif + _Py_atomic_store_uint32_relaxed(&op->ob_ref_local, (uint32_t)refcnt); + } + else { + _Py_atomic_add_ssize(&op->ob_ref_shared, (n << _Py_REF_SHARED_SHIFT)); + } +# ifdef Py_REF_DEBUG + _Py_AddRefTotal(_PyThreadState_GET(), n); +# endif +#endif + // Although the ref count was increased by `n` (which may be greater than 1) + // it is only a single increment (i.e. addition) operation, so only 1 refcnt + // increment operation is counted. + _Py_INCREF_STAT_INC(); +} +#define _Py_RefcntAdd(op, n) _Py_RefcntAdd(_PyObject_CAST(op), n) + +// Checks if an object has a single, unique reference. If the caller holds a +// unique reference, it may be able to safely modify the object in-place. +static inline int +_PyObject_IsUniquelyReferenced(PyObject *ob) +{ +#if !defined(Py_GIL_DISABLED) + return Py_REFCNT(ob) == 1; +#else + // NOTE: the entire ob_ref_shared field must be zero, including flags, to + // ensure that other threads cannot concurrently create new references to + // this object. + return (_Py_IsOwnedByCurrentThread(ob) && + _Py_atomic_load_uint32_relaxed(&ob->ob_ref_local) == 1 && + _Py_atomic_load_ssize_relaxed(&ob->ob_ref_shared) == 0); +#endif +} + +PyAPI_FUNC(void) _Py_SetImmortal(PyObject *op); +PyAPI_FUNC(void) _Py_SetImmortalUntracked(PyObject *op); + +// Makes an immortal object mortal again with the specified refcnt. Should only +// be used during runtime finalization. +static inline void _Py_SetMortal(PyObject *op, short refcnt) +{ + if (op) { + assert(_Py_IsImmortal(op)); +#ifdef Py_GIL_DISABLED + op->ob_tid = _Py_UNOWNED_TID; + op->ob_ref_local = 0; + op->ob_ref_shared = _Py_REF_SHARED(refcnt, _Py_REF_MERGED); +#else + op->ob_refcnt = refcnt; +#endif + } +} + +/* _Py_ClearImmortal() should only be used during runtime finalization. */ +static inline void _Py_ClearImmortal(PyObject *op) +{ + if (op) { + _Py_SetMortal(op, 1); + Py_DECREF(op); + } +} +#define _Py_ClearImmortal(op) \ + do { \ + _Py_ClearImmortal(_PyObject_CAST(op)); \ + op = NULL; \ + } while (0) + +#if !defined(Py_GIL_DISABLED) +static inline void +_Py_DECREF_SPECIALIZED(PyObject *op, const destructor destruct) +{ + if (_Py_IsImmortal(op)) { + _Py_DECREF_IMMORTAL_STAT_INC(); + return; + } + _Py_DECREF_STAT_INC(); +#ifdef Py_REF_DEBUG + _Py_DEC_REFTOTAL(PyInterpreterState_Get()); +#endif + if (--op->ob_refcnt != 0) { + assert(op->ob_refcnt > 0); + } + else { +#ifdef Py_TRACE_REFS + _Py_ForgetReference(op); +#endif + _PyReftracerTrack(op, PyRefTracer_DESTROY); + destruct(op); + } +} + +static inline void +_Py_DECREF_NO_DEALLOC(PyObject *op) +{ + if (_Py_IsImmortal(op)) { + _Py_DECREF_IMMORTAL_STAT_INC(); + return; + } + _Py_DECREF_STAT_INC(); +#ifdef Py_REF_DEBUG + _Py_DEC_REFTOTAL(PyInterpreterState_Get()); +#endif + op->ob_refcnt--; +#ifdef Py_DEBUG + if (op->ob_refcnt <= 0) { + _Py_FatalRefcountError("Expected a positive remaining refcount"); + } +#endif +} + +#else +// TODO: implement Py_DECREF specializations for Py_GIL_DISABLED build +static inline void +_Py_DECREF_SPECIALIZED(PyObject *op, const destructor destruct) +{ + Py_DECREF(op); +} + +static inline void +_Py_DECREF_NO_DEALLOC(PyObject *op) +{ + Py_DECREF(op); +} + +static inline int +_Py_REF_IS_MERGED(Py_ssize_t ob_ref_shared) +{ + return (ob_ref_shared & _Py_REF_SHARED_FLAG_MASK) == _Py_REF_MERGED; +} + +static inline int +_Py_REF_IS_QUEUED(Py_ssize_t ob_ref_shared) +{ + return (ob_ref_shared & _Py_REF_SHARED_FLAG_MASK) == _Py_REF_QUEUED; +} + +// Merge the local and shared reference count fields and add `extra` to the +// refcount when merging. +Py_ssize_t _Py_ExplicitMergeRefcount(PyObject *op, Py_ssize_t extra); +#endif // !defined(Py_GIL_DISABLED) + +#ifdef Py_REF_DEBUG +# undef _Py_DEC_REFTOTAL +#endif + + +extern int _PyType_CheckConsistency(PyTypeObject *type); +extern int _PyDict_CheckConsistency(PyObject *mp, int check_content); + +// Fast inlined version of PyType_HasFeature() +static inline int +_PyType_HasFeature(PyTypeObject *type, unsigned long feature) { + return ((FT_ATOMIC_LOAD_ULONG_RELAXED(type->tp_flags) & feature) != 0); +} + +extern void _PyType_InitCache(PyInterpreterState *interp); + +extern PyStatus _PyObject_InitState(PyInterpreterState *interp); +extern void _PyObject_FiniState(PyInterpreterState *interp); +extern bool _PyRefchain_IsTraced(PyInterpreterState *interp, PyObject *obj); + +// Macros used for per-thread reference counting in the free threading build. +// They resolve to normal Py_INCREF/DECREF calls in the default build. +// +// The macros are used for only a few references that would otherwise cause +// scaling bottlenecks in the free threading build: +// - The reference from an object to `ob_type`. +// - The reference from a function to `func_code`. +// - The reference from a function to `func_globals` and `func_builtins`. +// +// It's safe, but not performant or necessary, to use these macros for other +// references to code, type, or dict objects. It's also safe to mix their +// usage with normal Py_INCREF/DECREF calls. +// +// See also Include/internal/pycore_dict.h for _Py_INCREF_DICT/_Py_DECREF_DICT. +#ifndef Py_GIL_DISABLED +# define _Py_INCREF_TYPE Py_INCREF +# define _Py_DECREF_TYPE Py_DECREF +# define _Py_INCREF_CODE Py_INCREF +# define _Py_DECREF_CODE Py_DECREF +#else +static inline void +_Py_THREAD_INCREF_OBJECT(PyObject *obj, Py_ssize_t unique_id) +{ + _PyThreadStateImpl *tstate = (_PyThreadStateImpl *)_PyThreadState_GET(); + + // The table index is `unique_id - 1` because 0 is not a valid unique id. + // Unsigned comparison so that `idx=-1` is handled by the "else". + size_t idx = (size_t)(unique_id - 1); + if (idx < (size_t)tstate->refcounts.size) { +# ifdef Py_REF_DEBUG + _Py_INCREF_IncRefTotal(); +# endif + _Py_INCREF_STAT_INC(); + tstate->refcounts.values[idx]++; + } + else { + // The slow path resizes the per-thread refcount array if necessary. + // It handles the unique_id=0 case to keep the inlinable function smaller. + _PyObject_ThreadIncrefSlow(obj, idx); + } +} + +static inline void +_Py_INCREF_TYPE(PyTypeObject *type) +{ + if (!_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE)) { + assert(_Py_IsImmortal(type)); + _Py_INCREF_IMMORTAL_STAT_INC(); + return; + } + + // gh-122974: GCC 11 warns about the access to PyHeapTypeObject fields when + // _Py_INCREF_TYPE() is called on a statically allocated type. The + // _PyType_HasFeature check above ensures that the type is a heap type. +#if defined(__GNUC__) && __GNUC__ >= 11 +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Warray-bounds" +#endif + _Py_THREAD_INCREF_OBJECT((PyObject *)type, ((PyHeapTypeObject *)type)->unique_id); +#if defined(__GNUC__) && __GNUC__ >= 11 +# pragma GCC diagnostic pop +#endif +} + +static inline void +_Py_INCREF_CODE(PyCodeObject *co) +{ + _Py_THREAD_INCREF_OBJECT((PyObject *)co, co->_co_unique_id); +} + +static inline void +_Py_THREAD_DECREF_OBJECT(PyObject *obj, Py_ssize_t unique_id) +{ + _PyThreadStateImpl *tstate = (_PyThreadStateImpl *)_PyThreadState_GET(); + + // The table index is `unique_id - 1` because 0 is not a valid unique id. + // Unsigned comparison so that `idx=-1` is handled by the "else". + size_t idx = (size_t)(unique_id - 1); + if (idx < (size_t)tstate->refcounts.size) { +# ifdef Py_REF_DEBUG + _Py_DECREF_DecRefTotal(); +# endif + _Py_DECREF_STAT_INC(); + tstate->refcounts.values[idx]--; + } + else { + // Directly decref the object if the id is not assigned or if + // per-thread refcounting has been disabled on this object. + Py_DECREF(obj); + } +} + +static inline void +_Py_DECREF_TYPE(PyTypeObject *type) +{ + if (!_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE)) { + assert(_Py_IsImmortal(type)); + _Py_DECREF_IMMORTAL_STAT_INC(); + return; + } + PyHeapTypeObject *ht = (PyHeapTypeObject *)type; + _Py_THREAD_DECREF_OBJECT((PyObject *)type, ht->unique_id); +} + +static inline void +_Py_DECREF_CODE(PyCodeObject *co) +{ + _Py_THREAD_DECREF_OBJECT((PyObject *)co, co->_co_unique_id); +} +#endif + +#ifndef Py_GIL_DISABLED +#ifdef Py_REF_DEBUG + +static inline void Py_DECREF_MORTAL(const char *filename, int lineno, PyObject *op) +{ + if (op->ob_refcnt <= 0) { + _Py_NegativeRefcount(filename, lineno, op); + } + _Py_DECREF_STAT_INC(); + assert(!_Py_IsStaticImmortal(op)); + if (!_Py_IsImmortal(op)) { + _Py_DECREF_DecRefTotal(); + } + if (--op->ob_refcnt == 0) { + _Py_Dealloc(op); + } +} +#define Py_DECREF_MORTAL(op) Py_DECREF_MORTAL(__FILE__, __LINE__, _PyObject_CAST(op)) + +static inline void _Py_DECREF_MORTAL_SPECIALIZED(const char *filename, int lineno, PyObject *op, destructor destruct) +{ + if (op->ob_refcnt <= 0) { + _Py_NegativeRefcount(filename, lineno, op); + } + _Py_DECREF_STAT_INC(); + assert(!_Py_IsStaticImmortal(op)); + if (!_Py_IsImmortal(op)) { + _Py_DECREF_DecRefTotal(); + } + if (--op->ob_refcnt == 0) { +#ifdef Py_TRACE_REFS + _Py_ForgetReference(op); +#endif + _PyReftracerTrack(op, PyRefTracer_DESTROY); + destruct(op); + } +} +#define Py_DECREF_MORTAL_SPECIALIZED(op, destruct) _Py_DECREF_MORTAL_SPECIALIZED(__FILE__, __LINE__, op, destruct) + +#else + +static inline void Py_DECREF_MORTAL(PyObject *op) +{ + assert(!_Py_IsStaticImmortal(op)); + _Py_DECREF_STAT_INC(); + if (--op->ob_refcnt == 0) { + _Py_Dealloc(op); + } +} +#define Py_DECREF_MORTAL(op) Py_DECREF_MORTAL(_PyObject_CAST(op)) + +static inline void Py_DECREF_MORTAL_SPECIALIZED(PyObject *op, destructor destruct) +{ + assert(!_Py_IsStaticImmortal(op)); + _Py_DECREF_STAT_INC(); + if (--op->ob_refcnt == 0) { + _PyReftracerTrack(op, PyRefTracer_DESTROY); + destruct(op); + } +} +#define Py_DECREF_MORTAL_SPECIALIZED(op, destruct) Py_DECREF_MORTAL_SPECIALIZED(_PyObject_CAST(op), destruct) + +#endif +#endif + +/* Inline functions trading binary compatibility for speed: + _PyObject_Init() is the fast version of PyObject_Init(), and + _PyObject_InitVar() is the fast version of PyObject_InitVar(). + + These inline functions must not be called with op=NULL. */ +static inline void +_PyObject_Init(PyObject *op, PyTypeObject *typeobj) +{ + assert(op != NULL); + Py_SET_TYPE(op, typeobj); + assert(_PyType_HasFeature(typeobj, Py_TPFLAGS_HEAPTYPE) || _Py_IsImmortal(typeobj)); + _Py_INCREF_TYPE(typeobj); + _Py_NewReference(op); +} + +static inline void +_PyObject_InitVar(PyVarObject *op, PyTypeObject *typeobj, Py_ssize_t size) +{ + assert(op != NULL); + assert(typeobj != &PyLong_Type); + _PyObject_Init((PyObject *)op, typeobj); + Py_SET_SIZE(op, size); +} + +// Macros to accept any type for the parameter, and to automatically pass +// the filename and the filename (if NDEBUG is not defined) where the macro +// is called. +#ifdef NDEBUG +# define _PyObject_GC_TRACK(op) \ + _PyObject_GC_TRACK(_PyObject_CAST(op)) +# define _PyObject_GC_UNTRACK(op) \ + _PyObject_GC_UNTRACK(_PyObject_CAST(op)) +#else +# define _PyObject_GC_TRACK(op) \ + _PyObject_GC_TRACK(__FILE__, __LINE__, _PyObject_CAST(op)) +# define _PyObject_GC_UNTRACK(op) \ + _PyObject_GC_UNTRACK(__FILE__, __LINE__, _PyObject_CAST(op)) +#endif + +#ifdef Py_GIL_DISABLED + +/* Tries to increment an object's reference count + * + * This is a specialized version of _Py_TryIncref that only succeeds if the + * object is immortal or local to this thread. It does not handle the case + * where the reference count modification requires an atomic operation. This + * allows call sites to specialize for the immortal/local case. + */ +static inline int +_Py_TryIncrefFast(PyObject *op) { + uint32_t local = _Py_atomic_load_uint32_relaxed(&op->ob_ref_local); + local += 1; + if (local == 0) { + // immortal + _Py_INCREF_IMMORTAL_STAT_INC(); + return 1; + } + if (_Py_IsOwnedByCurrentThread(op)) { + _Py_INCREF_STAT_INC(); + _Py_atomic_store_uint32_relaxed(&op->ob_ref_local, local); +#ifdef Py_REF_DEBUG + _Py_IncRefTotal(_PyThreadState_GET()); +#endif + return 1; + } + return 0; +} + +static inline int +_Py_TryIncRefShared(PyObject *op) +{ + Py_ssize_t shared = _Py_atomic_load_ssize_relaxed(&op->ob_ref_shared); + for (;;) { + // If the shared refcount is zero and the object is either merged + // or may not have weak references, then we cannot incref it. + if (shared == 0 || shared == _Py_REF_MERGED) { + return 0; + } + + if (_Py_atomic_compare_exchange_ssize( + &op->ob_ref_shared, + &shared, + shared + (1 << _Py_REF_SHARED_SHIFT))) { +#ifdef Py_REF_DEBUG + _Py_IncRefTotal(_PyThreadState_GET()); +#endif + _Py_INCREF_STAT_INC(); + return 1; + } + } +} + +/* Tries to incref the object op and ensures that *src still points to it. */ +static inline int +_Py_TryIncrefCompare(PyObject **src, PyObject *op) +{ + if (_Py_TryIncrefFast(op)) { + return 1; + } + if (!_Py_TryIncRefShared(op)) { + return 0; + } + if (op != _Py_atomic_load_ptr(src)) { + Py_DECREF(op); + return 0; + } + return 1; +} + +/* Loads and increfs an object from ptr, which may contain a NULL value. + Safe with concurrent (atomic) updates to ptr. + NOTE: The writer must set maybe-weakref on the stored object! */ +static inline PyObject * +_Py_XGetRef(PyObject **ptr) +{ + for (;;) { + PyObject *value = _PyObject_CAST(_Py_atomic_load_ptr(ptr)); + if (value == NULL) { + return value; + } + if (_Py_TryIncrefCompare(ptr, value)) { + return value; + } + } +} + +/* Attempts to loads and increfs an object from ptr. Returns NULL + on failure, which may be due to a NULL value or a concurrent update. */ +static inline PyObject * +_Py_TryXGetRef(PyObject **ptr) +{ + PyObject *value = _PyObject_CAST(_Py_atomic_load_ptr(ptr)); + if (value == NULL) { + return value; + } + if (_Py_TryIncrefCompare(ptr, value)) { + return value; + } + return NULL; +} + +/* Like Py_NewRef but also optimistically sets _Py_REF_MAYBE_WEAKREF + on objects owned by a different thread. */ +static inline PyObject * +_Py_NewRefWithLock(PyObject *op) +{ + if (_Py_TryIncrefFast(op)) { + return op; + } +#ifdef Py_REF_DEBUG + _Py_IncRefTotal(_PyThreadState_GET()); +#endif + _Py_INCREF_STAT_INC(); + for (;;) { + Py_ssize_t shared = _Py_atomic_load_ssize_relaxed(&op->ob_ref_shared); + Py_ssize_t new_shared = shared + (1 << _Py_REF_SHARED_SHIFT); + if ((shared & _Py_REF_SHARED_FLAG_MASK) == 0) { + new_shared |= _Py_REF_MAYBE_WEAKREF; + } + if (_Py_atomic_compare_exchange_ssize( + &op->ob_ref_shared, + &shared, + new_shared)) { + return op; + } + } +} + +static inline PyObject * +_Py_XNewRefWithLock(PyObject *obj) +{ + if (obj == NULL) { + return NULL; + } + return _Py_NewRefWithLock(obj); +} + +static inline void +_PyObject_SetMaybeWeakref(PyObject *op) +{ + if (_Py_IsImmortal(op)) { + return; + } + for (;;) { + Py_ssize_t shared = _Py_atomic_load_ssize_relaxed(&op->ob_ref_shared); + if ((shared & _Py_REF_SHARED_FLAG_MASK) != 0) { + // Nothing to do if it's in WEAKREFS, QUEUED, or MERGED states. + return; + } + if (_Py_atomic_compare_exchange_ssize( + &op->ob_ref_shared, &shared, shared | _Py_REF_MAYBE_WEAKREF)) { + return; + } + } +} + +extern PyAPI_FUNC(int) _PyObject_ResurrectEndSlow(PyObject *op); +#endif + +// Temporarily resurrects an object during deallocation. The refcount is set +// to one. +static inline void +_PyObject_ResurrectStart(PyObject *op) +{ + assert(Py_REFCNT(op) == 0); +#ifdef Py_REF_DEBUG + _Py_IncRefTotal(_PyThreadState_GET()); +#endif +#ifdef Py_GIL_DISABLED + _Py_atomic_store_uintptr_relaxed(&op->ob_tid, _Py_ThreadId()); + _Py_atomic_store_uint32_relaxed(&op->ob_ref_local, 1); + _Py_atomic_store_ssize_relaxed(&op->ob_ref_shared, 0); +#else + Py_SET_REFCNT(op, 1); +#endif +#ifdef Py_TRACE_REFS + _Py_ResurrectReference(op); +#endif +} + +// Undoes an object resurrection by decrementing the refcount without calling +// _Py_Dealloc(). Returns 0 if the object is dead (the normal case), and +// deallocation should continue. Returns 1 if the object is still alive. +static inline int +_PyObject_ResurrectEnd(PyObject *op) +{ +#ifdef Py_REF_DEBUG + _Py_DecRefTotal(_PyThreadState_GET()); +#endif +#ifndef Py_GIL_DISABLED + Py_SET_REFCNT(op, Py_REFCNT(op) - 1); + if (Py_REFCNT(op) == 0) { +# ifdef Py_TRACE_REFS + _Py_ForgetReference(op); +# endif + return 0; + } + return 1; +#else + uint32_t local = _Py_atomic_load_uint32_relaxed(&op->ob_ref_local); + Py_ssize_t shared = _Py_atomic_load_ssize_acquire(&op->ob_ref_shared); + if (_Py_IsOwnedByCurrentThread(op) && local == 1 && shared == 0) { + // Fast-path: object has a single refcount and is owned by this thread + _Py_atomic_store_uint32_relaxed(&op->ob_ref_local, 0); +# ifdef Py_TRACE_REFS + _Py_ForgetReference(op); +# endif + return 0; + } + // Slow-path: object has a shared refcount or is not owned by this thread + return _PyObject_ResurrectEndSlow(op); +#endif +} + +/* Tries to incref op and returns 1 if successful or 0 otherwise. */ +static inline int +_Py_TryIncref(PyObject *op) +{ +#ifdef Py_GIL_DISABLED + return _Py_TryIncrefFast(op) || _Py_TryIncRefShared(op); +#else + if (Py_REFCNT(op) > 0) { + Py_INCREF(op); + return 1; + } + return 0; +#endif +} + +#ifdef Py_REF_DEBUG +extern void _PyInterpreterState_FinalizeRefTotal(PyInterpreterState *); +extern void _Py_FinalizeRefTotal(_PyRuntimeState *); +extern void _PyDebug_PrintTotalRefs(void); +#endif + +#ifdef Py_TRACE_REFS +extern void _Py_AddToAllObjects(PyObject *op); +extern void _Py_PrintReferences(PyInterpreterState *, FILE *); +extern void _Py_PrintReferenceAddresses(PyInterpreterState *, FILE *); +#endif + + +/* Return the *address* of the object's weaklist. The address may be + * dereferenced to get the current head of the weaklist. This is useful + * for iterating over the linked list of weakrefs, especially when the + * list is being modified externally (e.g. refs getting removed). + * + * The returned pointer should not be used to change the head of the list + * nor should it be used to add, remove, or swap any refs in the list. + * That is the sole responsibility of the code in weakrefobject.c. + */ +static inline PyObject ** +_PyObject_GET_WEAKREFS_LISTPTR(PyObject *op) +{ + if (PyType_Check(op) && + ((PyTypeObject *)op)->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) { + PyInterpreterState *interp = _PyInterpreterState_GET(); + managed_static_type_state *state = _PyStaticType_GetState( + interp, (PyTypeObject *)op); + return _PyStaticType_GET_WEAKREFS_LISTPTR(state); + } + // Essentially _PyObject_GET_WEAKREFS_LISTPTR_FROM_OFFSET(): + Py_ssize_t offset = Py_TYPE(op)->tp_weaklistoffset; + return (PyObject **)((char *)op + offset); +} + +/* This is a special case of _PyObject_GET_WEAKREFS_LISTPTR(). + * Only the most fundamental lookup path is used. + * Consequently, static types should not be used. + * + * For static builtin types the returned pointer will always point + * to a NULL tp_weaklist. This is fine for any deallocation cases, + * since static types are never deallocated and static builtin types + * are only finalized at the end of runtime finalization. + * + * If the weaklist for static types is actually needed then use + * _PyObject_GET_WEAKREFS_LISTPTR(). + */ +static inline PyWeakReference ** +_PyObject_GET_WEAKREFS_LISTPTR_FROM_OFFSET(PyObject *op) +{ + assert(!PyType_Check(op) || + ((PyTypeObject *)op)->tp_flags & Py_TPFLAGS_HEAPTYPE); + Py_ssize_t offset = Py_TYPE(op)->tp_weaklistoffset; + return (PyWeakReference **)((char *)op + offset); +} + +// Fast inlined version of PyType_IS_GC() +#define _PyType_IS_GC(t) _PyType_HasFeature((t), Py_TPFLAGS_HAVE_GC) + +// Fast inlined version of PyObject_IS_GC() +static inline int +_PyObject_IS_GC(PyObject *obj) +{ + PyTypeObject *type = Py_TYPE(obj); + return (_PyType_IS_GC(type) + && (type->tp_is_gc == NULL || type->tp_is_gc(obj))); +} + +// Fast inlined version of PyObject_Hash() +static inline Py_hash_t +_PyObject_HashFast(PyObject *op) +{ + if (PyUnicode_CheckExact(op)) { + Py_hash_t hash = FT_ATOMIC_LOAD_SSIZE_RELAXED( + _PyASCIIObject_CAST(op)->hash); + if (hash != -1) { + return hash; + } + } + return PyObject_Hash(op); +} + +static inline size_t +_PyType_PreHeaderSize(PyTypeObject *tp) +{ + return ( +#ifndef Py_GIL_DISABLED + (size_t)_PyType_IS_GC(tp) * sizeof(PyGC_Head) + +#endif + (size_t)_PyType_HasFeature(tp, Py_TPFLAGS_PREHEADER) * 2 * sizeof(PyObject *) + ); +} + +void _PyObject_GC_Link(PyObject *op); + +// Usage: assert(_Py_CheckSlotResult(obj, "__getitem__", result != NULL)); +extern int _Py_CheckSlotResult( + PyObject *obj, + const char *slot_name, + int success); + +// Test if a type supports weak references +static inline int _PyType_SUPPORTS_WEAKREFS(PyTypeObject *type) { + return (type->tp_weaklistoffset != 0); +} + +extern PyObject* _PyType_AllocNoTrack(PyTypeObject *type, Py_ssize_t nitems); +PyAPI_FUNC(PyObject *) _PyType_NewManagedObject(PyTypeObject *type); + +extern PyTypeObject* _PyType_CalculateMetaclass(PyTypeObject *, PyObject *); +extern PyObject* _PyType_GetDocFromInternalDoc(const char *, const char *); +extern PyObject* _PyType_GetTextSignatureFromInternalDoc(const char *, const char *, int); +extern int _PyObject_SetAttributeErrorContext(PyObject *v, PyObject* name); + +void _PyObject_InitInlineValues(PyObject *obj, PyTypeObject *tp); +extern int _PyObject_StoreInstanceAttribute(PyObject *obj, + PyObject *name, PyObject *value); +extern bool _PyObject_TryGetInstanceAttribute(PyObject *obj, PyObject *name, + PyObject **attr); +extern PyObject *_PyType_LookupRefAndVersion(PyTypeObject *, PyObject *, + unsigned int *); + +// Internal API to look for a name through the MRO. +// This stores a stack reference in out and returns the value of +// type->tp_version or zero if name is missing. It doesn't set an exception! +extern unsigned int +_PyType_LookupStackRefAndVersion(PyTypeObject *type, PyObject *name, _PyStackRef *out); + +extern int _PyObject_GetMethodStackRef(PyThreadState *ts, _PyStackRef *self, + PyObject *name, _PyStackRef *method); + +// Cache the provided init method in the specialization cache of type if the +// provided type version matches the current version of the type. +// +// The cached value is borrowed and is only valid if guarded by a type +// version check. In free-threaded builds the init method must also use +// deferred reference counting. +// +// Returns 1 if the value was cached or 0 otherwise. +extern int _PyType_CacheInitForSpecialization(PyHeapTypeObject *type, + PyObject *init, + unsigned int tp_version); + +#ifdef Py_GIL_DISABLED +# define MANAGED_DICT_OFFSET (((Py_ssize_t)sizeof(PyObject *))*-1) +# define MANAGED_WEAKREF_OFFSET (((Py_ssize_t)sizeof(PyObject *))*-2) +#else +# define MANAGED_DICT_OFFSET (((Py_ssize_t)sizeof(PyObject *))*-3) +# define MANAGED_WEAKREF_OFFSET (((Py_ssize_t)sizeof(PyObject *))*-4) +#endif + +typedef union { + PyDictObject *dict; +} PyManagedDictPointer; + +static inline PyManagedDictPointer * +_PyObject_ManagedDictPointer(PyObject *obj) +{ + assert(Py_TYPE(obj)->tp_flags & Py_TPFLAGS_MANAGED_DICT); + return (PyManagedDictPointer *)((char *)obj + MANAGED_DICT_OFFSET); +} + +static inline PyDictObject * +_PyObject_GetManagedDict(PyObject *obj) +{ + PyManagedDictPointer *dorv = _PyObject_ManagedDictPointer(obj); + return (PyDictObject *)FT_ATOMIC_LOAD_PTR_ACQUIRE(dorv->dict); +} + +static inline PyDictValues * +_PyObject_InlineValues(PyObject *obj) +{ + PyTypeObject *tp = Py_TYPE(obj); + assert(tp->tp_basicsize > 0 && (size_t)tp->tp_basicsize % sizeof(PyObject *) == 0); + assert(Py_TYPE(obj)->tp_flags & Py_TPFLAGS_INLINE_VALUES); + assert(Py_TYPE(obj)->tp_flags & Py_TPFLAGS_MANAGED_DICT); + return (PyDictValues *)((char *)obj + tp->tp_basicsize); +} + +extern PyObject ** _PyObject_ComputedDictPointer(PyObject *); +extern int _PyObject_IsInstanceDictEmpty(PyObject *); + +// Export for 'math' shared extension +PyAPI_FUNC(PyObject*) _PyObject_LookupSpecial(PyObject *, PyObject *); +PyAPI_FUNC(int) _PyObject_LookupSpecialMethod(PyObject *attr, _PyStackRef *method_and_self); + +// Calls the method named `attr` on `self`, but does not set an exception if +// the attribute does not exist. +PyAPI_FUNC(PyObject *) +_PyObject_MaybeCallSpecialNoArgs(PyObject *self, PyObject *attr); + +PyAPI_FUNC(PyObject *) +_PyObject_MaybeCallSpecialOneArg(PyObject *self, PyObject *attr, PyObject *arg); + +extern int _PyObject_IsAbstract(PyObject *); + +PyAPI_FUNC(int) _PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); +extern PyObject* _PyObject_NextNotImplemented(PyObject *); + +// Pickle support. +// Export for '_datetime' shared extension +PyAPI_FUNC(PyObject*) _PyObject_GetState(PyObject *); + +/* C function call trampolines to mitigate bad function pointer casts. + * + * Typical native ABIs ignore additional arguments or fill in missing + * values with 0/NULL in function pointer cast. Compilers do not show + * warnings when a function pointer is explicitly casted to an + * incompatible type. + * + * Bad fpcasts are an issue in WebAssembly. WASM's indirect_call has strict + * function signature checks. Argument count, types, and return type must + * match. + * + * Third party code unintentionally rely on problematic fpcasts. The call + * trampoline mitigates common occurrences of bad fpcasts on Emscripten. + */ +#if !(defined(__EMSCRIPTEN__) && defined(PY_CALL_TRAMPOLINE)) +#define _PyCFunction_TrampolineCall(meth, self, args) \ + (meth)((self), (args)) +#define _PyCFunctionWithKeywords_TrampolineCall(meth, self, args, kw) \ + (meth)((self), (args), (kw)) +#endif // __EMSCRIPTEN__ && PY_CALL_TRAMPOLINE + +// Export these 2 symbols for '_pickle' shared extension +PyAPI_DATA(PyTypeObject) _PyNone_Type; +PyAPI_DATA(PyTypeObject) _PyNotImplemented_Type; + +// Maps Py_LT to Py_GT, ..., Py_GE to Py_LE. +// Export for the stable ABI. +PyAPI_DATA(int) _Py_SwappedOp[]; + +extern void _Py_GetConstant_Init(void); + +enum _PyAnnotateFormat { + _Py_ANNOTATE_FORMAT_VALUE = 1, + _Py_ANNOTATE_FORMAT_VALUE_WITH_FAKE_GLOBALS = 2, + _Py_ANNOTATE_FORMAT_FORWARDREF = 3, + _Py_ANNOTATE_FORMAT_STRING = 4, +}; + +int _PyObject_SetDict(PyObject *obj, PyObject *value); + +#ifndef Py_GIL_DISABLED +static inline Py_ALWAYS_INLINE void _Py_INCREF_MORTAL(PyObject *op) +{ + assert(!_Py_IsStaticImmortal(op)); + op->ob_refcnt++; + _Py_INCREF_STAT_INC(); +#if defined(Py_REF_DEBUG) && !defined(Py_LIMITED_API) + if (!_Py_IsImmortal(op)) { + _Py_INCREF_IncRefTotal(); + } +#endif +} +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_OBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_object_alloc.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_object_alloc.h new file mode 100644 index 0000000000000000000000000000000000000000..8cc7a444bc93e7141702a944c6fbce4fa8bc0961 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_object_alloc.h @@ -0,0 +1,71 @@ +#ifndef Py_INTERNAL_OBJECT_ALLOC_H +#define Py_INTERNAL_OBJECT_ALLOC_H + +#include "pycore_object.h" // _PyType_HasFeature() +#include "pycore_pystate.h" // _PyThreadState_GET() +#include "pycore_tstate.h" // _PyThreadStateImpl + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#ifdef Py_GIL_DISABLED +static inline mi_heap_t * +_PyObject_GetAllocationHeap(_PyThreadStateImpl *tstate, PyTypeObject *tp) +{ + struct _mimalloc_thread_state *m = &tstate->mimalloc; + if (_PyType_HasFeature(tp, Py_TPFLAGS_PREHEADER)) { + return &m->heaps[_Py_MIMALLOC_HEAP_GC_PRE]; + } + else if (_PyType_IS_GC(tp)) { + return &m->heaps[_Py_MIMALLOC_HEAP_GC]; + } + else { + return &m->heaps[_Py_MIMALLOC_HEAP_OBJECT]; + } +} +#endif + +// Sets the heap used for PyObject_Malloc(), PyObject_Realloc(), etc. calls in +// Py_GIL_DISABLED builds. We use different heaps depending on if the object +// supports GC and if it has a pre-header. We smuggle the choice of heap +// through the _mimalloc_thread_state. In the default build, this simply +// calls PyObject_Malloc(). +static inline void * +_PyObject_MallocWithType(PyTypeObject *tp, size_t size) +{ +#ifdef Py_GIL_DISABLED + _PyThreadStateImpl *tstate = (_PyThreadStateImpl *)_PyThreadState_GET(); + struct _mimalloc_thread_state *m = &tstate->mimalloc; + m->current_object_heap = _PyObject_GetAllocationHeap(tstate, tp); +#endif + void *mem = PyObject_Malloc(size); +#ifdef Py_GIL_DISABLED + m->current_object_heap = &m->heaps[_Py_MIMALLOC_HEAP_OBJECT]; +#endif + return mem; +} + +static inline void * +_PyObject_ReallocWithType(PyTypeObject *tp, void *ptr, size_t size) +{ +#ifdef Py_GIL_DISABLED + _PyThreadStateImpl *tstate = (_PyThreadStateImpl *)_PyThreadState_GET(); + struct _mimalloc_thread_state *m = &tstate->mimalloc; + m->current_object_heap = _PyObject_GetAllocationHeap(tstate, tp); +#endif + void *mem = PyObject_Realloc(ptr, size); +#ifdef Py_GIL_DISABLED + m->current_object_heap = &m->heaps[_Py_MIMALLOC_HEAP_OBJECT]; +#endif + return mem; +} + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_OBJECT_ALLOC_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_object_deferred.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_object_deferred.h new file mode 100644 index 0000000000000000000000000000000000000000..c070d768b7d771cf6f202b811ae524ef2fb4c21c --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_object_deferred.h @@ -0,0 +1,32 @@ +#ifndef Py_INTERNAL_OBJECT_DEFERRED_H +#define Py_INTERNAL_OBJECT_DEFERRED_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "pycore_gc.h" + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +// Mark an object as supporting deferred reference counting. This is a no-op +// in the default (with GIL) build. Objects that use deferred reference +// counting should be tracked by the GC so that they are eventually collected. +extern void _PyObject_SetDeferredRefcount(PyObject *op); + +static inline int +_PyObject_HasDeferredRefcount(PyObject *op) +{ +#ifdef Py_GIL_DISABLED + return _PyObject_HAS_GC_BITS(op, _PyGC_BITS_DEFERRED); +#else + return 0; +#endif +} + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_OBJECT_DEFERRED_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_object_stack.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_object_stack.h new file mode 100644 index 0000000000000000000000000000000000000000..39e69b7cde52a18ddf9a932ba0b747f8ec0c2e83 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_object_stack.h @@ -0,0 +1,95 @@ +#ifndef Py_INTERNAL_OBJECT_STACK_H +#define Py_INTERNAL_OBJECT_STACK_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +// _PyObjectStack is a stack of Python objects implemented as a linked list of +// fixed size buffers. + +// Chosen so that _PyObjectStackChunk is a power-of-two size. +#define _Py_OBJECT_STACK_CHUNK_SIZE 254 + +typedef struct _PyObjectStackChunk { + struct _PyObjectStackChunk *prev; + Py_ssize_t n; + PyObject *objs[_Py_OBJECT_STACK_CHUNK_SIZE]; +} _PyObjectStackChunk; + +typedef struct _PyObjectStack { + _PyObjectStackChunk *head; +} _PyObjectStack; + + +extern _PyObjectStackChunk * +_PyObjectStackChunk_New(void); + +extern void +_PyObjectStackChunk_Free(_PyObjectStackChunk *); + +// Push an item onto the stack. Return -1 on allocation failure, 0 on success. +static inline int +_PyObjectStack_Push(_PyObjectStack *stack, PyObject *obj) +{ + _PyObjectStackChunk *buf = stack->head; + if (buf == NULL || buf->n == _Py_OBJECT_STACK_CHUNK_SIZE) { + buf = _PyObjectStackChunk_New(); + if (buf == NULL) { + return -1; + } + buf->prev = stack->head; + buf->n = 0; + stack->head = buf; + } + + assert(buf->n >= 0 && buf->n < _Py_OBJECT_STACK_CHUNK_SIZE); + buf->objs[buf->n] = obj; + buf->n++; + return 0; +} + +// Pop the top item from the stack. Return NULL if the stack is empty. +static inline PyObject * +_PyObjectStack_Pop(_PyObjectStack *stack) +{ + _PyObjectStackChunk *buf = stack->head; + if (buf == NULL) { + return NULL; + } + assert(buf->n > 0 && buf->n <= _Py_OBJECT_STACK_CHUNK_SIZE); + buf->n--; + PyObject *obj = buf->objs[buf->n]; + if (buf->n == 0) { + stack->head = buf->prev; + _PyObjectStackChunk_Free(buf); + } + return obj; +} + +static inline Py_ssize_t +_PyObjectStack_Size(_PyObjectStack *stack) +{ + Py_ssize_t size = 0; + for (_PyObjectStackChunk *buf = stack->head; buf != NULL; buf = buf->prev) { + size += buf->n; + } + return size; +} + +// Merge src into dst, leaving src empty +extern void +_PyObjectStack_Merge(_PyObjectStack *dst, _PyObjectStack *src); + +// Remove all items from the stack +extern void +_PyObjectStack_Clear(_PyObjectStack *stack); + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_OBJECT_STACK_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_object_state.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_object_state.h new file mode 100644 index 0000000000000000000000000000000000000000..8a47a6d9e6eb0dcb9e069ebbcb8b8d85c92d6ae4 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_object_state.h @@ -0,0 +1,49 @@ +#ifndef Py_INTERNAL_OBJECT_STATE_H +#define Py_INTERNAL_OBJECT_STATE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_freelist_state.h" // _Py_freelists +#include "pycore_hashtable.h" // _Py_hashtable_t + + +/* Reference tracer state */ +struct _reftracer_runtime_state { + PyRefTracer tracer_func; + void* tracer_data; +}; + + +struct _py_object_runtime_state { +#ifdef Py_REF_DEBUG + Py_ssize_t interpreter_leaks; +#endif + int _not_used; +}; + +struct _py_object_state { +#if !defined(Py_GIL_DISABLED) + struct _Py_freelists freelists; +#endif +#ifdef Py_REF_DEBUG + Py_ssize_t reftotal; +#endif +#ifdef Py_TRACE_REFS + // Hash table storing all objects. The key is the object pointer + // (PyObject*) and the value is always the number 1 (as uintptr_t). + // See _PyRefchain_IsTraced() and _PyRefchain_Trace() functions. + _Py_hashtable_t *refchain; +#endif + int _not_used; +}; + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_OBJECT_STATE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_obmalloc.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_obmalloc.h new file mode 100644 index 0000000000000000000000000000000000000000..a7ba8f340737aabc39a15e2bb40604f53d110cfa --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_obmalloc.h @@ -0,0 +1,702 @@ +#ifndef Py_INTERNAL_OBMALLOC_H +#define Py_INTERNAL_OBMALLOC_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + + +typedef unsigned int pymem_uint; /* assuming >= 16 bits */ + +#undef uint +#define uint pymem_uint + + +/* An object allocator for Python. + + Here is an introduction to the layers of the Python memory architecture, + showing where the object allocator is actually used (layer +2), It is + called for every object allocation and deallocation (PyObject_New/Del), + unless the object-specific allocators implement a proprietary allocation + scheme (ex.: ints use a simple free list). This is also the place where + the cyclic garbage collector operates selectively on container objects. + + + Object-specific allocators + _____ ______ ______ ________ + [ int ] [ dict ] [ list ] ... [ string ] Python core | ++3 | <----- Object-specific memory -----> | <-- Non-object memory --> | + _______________________________ | | + [ Python's object allocator ] | | ++2 | ####### Object memory ####### | <------ Internal buffers ------> | + ______________________________________________________________ | + [ Python's raw memory allocator (PyMem_ API) ] | ++1 | <----- Python memory (under PyMem manager's control) ------> | | + __________________________________________________________________ + [ Underlying general-purpose allocator (ex: C library malloc) ] + 0 | <------ Virtual memory allocated for the python process -------> | + + ========================================================================= + _______________________________________________________________________ + [ OS-specific Virtual Memory Manager (VMM) ] +-1 | <--- Kernel dynamic storage allocation & management (page-based) ---> | + __________________________________ __________________________________ + [ ] [ ] +-2 | <-- Physical memory: ROM/RAM --> | | <-- Secondary storage (swap) --> | + +*/ +/*==========================================================================*/ + +/* A fast, special-purpose memory allocator for small blocks, to be used + on top of a general-purpose malloc -- heavily based on previous art. */ + +/* Vladimir Marangozov -- August 2000 */ + +/* + * "Memory management is where the rubber meets the road -- if we do the wrong + * thing at any level, the results will not be good. And if we don't make the + * levels work well together, we are in serious trouble." (1) + * + * (1) Paul R. Wilson, Mark S. Johnstone, Michael Neely, and David Boles, + * "Dynamic Storage Allocation: A Survey and Critical Review", + * in Proc. 1995 Int'l. Workshop on Memory Management, September 1995. + */ + +/* #undef WITH_MEMORY_LIMITS */ /* disable mem limit checks */ + +/*==========================================================================*/ + +/* + * Allocation strategy abstract: + * + * For small requests, the allocator sub-allocates blocks of memory. + * Requests greater than SMALL_REQUEST_THRESHOLD bytes are routed to the + * system's allocator. + * + * Small requests are grouped in size classes spaced 8 bytes apart, due + * to the required valid alignment of the returned address. Requests of + * a particular size are serviced from memory pools of 4K (one VMM page). + * Pools are fragmented on demand and contain free lists of blocks of one + * particular size class. In other words, there is a fixed-size allocator + * for each size class. Free pools are shared by the different allocators + * thus minimizing the space reserved for a particular size class. + * + * This allocation strategy is a variant of what is known as "simple + * segregated storage based on array of free lists". The main drawback of + * simple segregated storage is that we might end up with lot of reserved + * memory for the different free lists, which degenerate in time. To avoid + * this, we partition each free list in pools and we share dynamically the + * reserved space between all free lists. This technique is quite efficient + * for memory intensive programs which allocate mainly small-sized blocks. + * + * For small requests we have the following table: + * + * Request in bytes Size of allocated block Size class idx + * ---------------------------------------------------------------- + * 1-8 8 0 + * 9-16 16 1 + * 17-24 24 2 + * 25-32 32 3 + * 33-40 40 4 + * 41-48 48 5 + * 49-56 56 6 + * 57-64 64 7 + * 65-72 72 8 + * ... ... ... + * 497-504 504 62 + * 505-512 512 63 + * + * 0, SMALL_REQUEST_THRESHOLD + 1 and up: routed to the underlying + * allocator. + */ + +/*==========================================================================*/ + +/* + * -- Main tunable settings section -- + */ + +/* + * Alignment of addresses returned to the user. 8-bytes alignment works + * on most current architectures (with 32-bit or 64-bit address buses). + * The alignment value is also used for grouping small requests in size + * classes spaced ALIGNMENT bytes apart. + * + * You shouldn't change this unless you know what you are doing. + */ + +#if SIZEOF_VOID_P > 4 +#define ALIGNMENT 16 /* must be 2^N */ +#define ALIGNMENT_SHIFT 4 +#else +#define ALIGNMENT 8 /* must be 2^N */ +#define ALIGNMENT_SHIFT 3 +#endif + +/* Return the number of bytes in size class I, as a uint. */ +#define INDEX2SIZE(I) (((pymem_uint)(I) + 1) << ALIGNMENT_SHIFT) + +/* + * Max size threshold below which malloc requests are considered to be + * small enough in order to use preallocated memory pools. You can tune + * this value according to your application behaviour and memory needs. + * + * Note: a size threshold of 512 guarantees that newly created dictionaries + * will be allocated from preallocated memory pools on 64-bit. + * + * The following invariants must hold: + * 1) ALIGNMENT <= SMALL_REQUEST_THRESHOLD <= 512 + * 2) SMALL_REQUEST_THRESHOLD is evenly divisible by ALIGNMENT + * + * Although not required, for better performance and space efficiency, + * it is recommended that SMALL_REQUEST_THRESHOLD is set to a power of 2. + */ +#define SMALL_REQUEST_THRESHOLD 512 +#define NB_SMALL_SIZE_CLASSES (SMALL_REQUEST_THRESHOLD / ALIGNMENT) + +/* + * The system's VMM page size can be obtained on most unices with a + * getpagesize() call or deduced from various header files. To make + * things simpler, we assume that it is 4K, which is OK for most systems. + * It is probably better if this is the native page size, but it doesn't + * have to be. In theory, if SYSTEM_PAGE_SIZE is larger than the native page + * size, then `POOL_ADDR(p)->arenaindex' could rarely cause a segmentation + * violation fault. 4K is apparently OK for all the platforms that python + * currently targets. + */ +#define SYSTEM_PAGE_SIZE (4 * 1024) + +/* + * Maximum amount of memory managed by the allocator for small requests. + */ +#ifdef WITH_MEMORY_LIMITS +#ifndef SMALL_MEMORY_LIMIT +#define SMALL_MEMORY_LIMIT (64 * 1024 * 1024) /* 64 MB -- more? */ +#endif +#endif + +#if !defined(WITH_PYMALLOC_RADIX_TREE) +/* Use radix-tree to track arena memory regions, for address_in_range(). + * Enable by default since it allows larger pool sizes. Can be disabled + * using -DWITH_PYMALLOC_RADIX_TREE=0 */ +#define WITH_PYMALLOC_RADIX_TREE 1 +#endif + +#if SIZEOF_VOID_P > 4 +/* on 64-bit platforms use larger pools and arenas if we can */ +#define USE_LARGE_ARENAS +#if WITH_PYMALLOC_RADIX_TREE +/* large pools only supported if radix-tree is enabled */ +#define USE_LARGE_POOLS +#endif +#endif + +/* + * The allocator sub-allocates blocks of memory (called arenas) aligned + * on a page boundary. This is a reserved virtual address space for the + * current process (obtained through a malloc()/mmap() call). In no way this + * means that the memory arenas will be used entirely. A malloc() is + * usually an address range reservation for bytes, unless all pages within + * this space are referenced subsequently. So malloc'ing big blocks and not + * using them does not mean "wasting memory". It's an addressable range + * wastage... + * + * Arenas are allocated with mmap() on systems supporting anonymous memory + * mappings to reduce heap fragmentation. + */ +#ifdef USE_LARGE_ARENAS +#define ARENA_BITS 20 /* 1 MiB */ +#else +#define ARENA_BITS 18 /* 256 KiB */ +#endif +#define ARENA_SIZE (1 << ARENA_BITS) +#define ARENA_SIZE_MASK (ARENA_SIZE - 1) + +#ifdef WITH_MEMORY_LIMITS +#define MAX_ARENAS (SMALL_MEMORY_LIMIT / ARENA_SIZE) +#endif + +/* + * Size of the pools used for small blocks. Must be a power of 2. + */ +#ifdef USE_LARGE_POOLS +#define POOL_BITS 14 /* 16 KiB */ +#else +#define POOL_BITS 12 /* 4 KiB */ +#endif +#define POOL_SIZE (1 << POOL_BITS) +#define POOL_SIZE_MASK (POOL_SIZE - 1) + +#if !WITH_PYMALLOC_RADIX_TREE +#if POOL_SIZE != SYSTEM_PAGE_SIZE +# error "pool size must be equal to system page size" +#endif +#endif + +#define MAX_POOLS_IN_ARENA (ARENA_SIZE / POOL_SIZE) +#if MAX_POOLS_IN_ARENA * POOL_SIZE != ARENA_SIZE +# error "arena size not an exact multiple of pool size" +#endif + +/* + * -- End of tunable settings section -- + */ + +/*==========================================================================*/ + +/* When you say memory, my mind reasons in terms of (pointers to) blocks */ +typedef uint8_t pymem_block; + +/* Pool for small blocks. */ +struct pool_header { + union { pymem_block *_padding; + uint count; } ref; /* number of allocated blocks */ + pymem_block *freeblock; /* pool's free list head */ + struct pool_header *nextpool; /* see "Pool table" for meaning */ + struct pool_header *prevpool; /* " */ + uint arenaindex; /* index into arenas of base adr */ + uint szidx; /* block size class index */ + uint nextoffset; /* bytes to virgin block */ + uint maxnextoffset; /* largest valid nextoffset */ +}; + +typedef struct pool_header *poolp; + +/* Record keeping for arenas. */ +struct arena_object { + /* The address of the arena, as returned by malloc. Note that 0 + * will never be returned by a successful malloc, and is used + * here to mark an arena_object that doesn't correspond to an + * allocated arena. + */ + uintptr_t address; + + /* Pool-aligned pointer to the next pool to be carved off. */ + pymem_block* pool_address; + + /* The number of available pools in the arena: free pools + never- + * allocated pools. + */ + uint nfreepools; + + /* The total number of pools in the arena, whether or not available. */ + uint ntotalpools; + + /* Singly-linked list of available pools. */ + struct pool_header* freepools; + + /* Whenever this arena_object is not associated with an allocated + * arena, the nextarena member is used to link all unassociated + * arena_objects in the singly-linked `unused_arena_objects` list. + * The prevarena member is unused in this case. + * + * When this arena_object is associated with an allocated arena + * with at least one available pool, both members are used in the + * doubly-linked `usable_arenas` list, which is maintained in + * increasing order of `nfreepools` values. + * + * Else this arena_object is associated with an allocated arena + * all of whose pools are in use. `nextarena` and `prevarena` + * are both meaningless in this case. + */ + struct arena_object* nextarena; + struct arena_object* prevarena; +}; + +#define POOL_OVERHEAD _Py_SIZE_ROUND_UP(sizeof(struct pool_header), ALIGNMENT) + +#define DUMMY_SIZE_IDX 0xffff /* size class of newly cached pools */ + +/* Round pointer P down to the closest pool-aligned address <= P, as a poolp */ +#define POOL_ADDR(P) ((poolp)_Py_ALIGN_DOWN((P), POOL_SIZE)) + +/* Return total number of blocks in pool of size index I, as a uint. */ +#define NUMBLOCKS(I) ((pymem_uint)(POOL_SIZE - POOL_OVERHEAD) / INDEX2SIZE(I)) + +/*==========================================================================*/ + +/* + * Pool table -- headed, circular, doubly-linked lists of partially used pools. + +This is involved. For an index i, usedpools[i+i] is the header for a list of +all partially used pools holding small blocks with "size class idx" i. So +usedpools[0] corresponds to blocks of size 8, usedpools[2] to blocks of size +16, and so on: index 2*i <-> blocks of size (i+1)<freeblock points to +the start of a singly-linked list of free blocks within the pool. When a +block is freed, it's inserted at the front of its pool's freeblock list. Note +that the available blocks in a pool are *not* linked all together when a pool +is initialized. Instead only "the first two" (lowest addresses) blocks are +set up, returning the first such block, and setting pool->freeblock to a +one-block list holding the second such block. This is consistent with that +pymalloc strives at all levels (arena, pool, and block) never to touch a piece +of memory until it's actually needed. + +So long as a pool is in the used state, we're certain there *is* a block +available for allocating, and pool->freeblock is not NULL. If pool->freeblock +points to the end of the free list before we've carved the entire pool into +blocks, that means we simply haven't yet gotten to one of the higher-address +blocks. The offset from the pool_header to the start of "the next" virgin +block is stored in the pool_header nextoffset member, and the largest value +of nextoffset that makes sense is stored in the maxnextoffset member when a +pool is initialized. All the blocks in a pool have been passed out at least +once when and only when nextoffset > maxnextoffset. + + +Major obscurity: While the usedpools vector is declared to have poolp +entries, it doesn't really. It really contains two pointers per (conceptual) +poolp entry, the nextpool and prevpool members of a pool_header. The +excruciating initialization code below fools C so that + + usedpool[i+i] + +"acts like" a genuine poolp, but only so long as you only reference its +nextpool and prevpool members. The "- 2*sizeof(pymem_block *)" gibberish is +compensating for that a pool_header's nextpool and prevpool members +immediately follow a pool_header's first two members: + + union { pymem_block *_padding; + uint count; } ref; + pymem_block *freeblock; + +each of which consume sizeof(pymem_block *) bytes. So what usedpools[i+i] really +contains is a fudged-up pointer p such that *if* C believes it's a poolp +pointer, then p->nextpool and p->prevpool are both p (meaning that the headed +circular list is empty). + +It's unclear why the usedpools setup is so convoluted. It could be to +minimize the amount of cache required to hold this heavily-referenced table +(which only *needs* the two interpool pointer members of a pool_header). OTOH, +referencing code has to remember to "double the index" and doing so isn't +free, usedpools[0] isn't a strictly legal pointer, and we're crucially relying +on that C doesn't insert any padding anywhere in a pool_header at or before +the prevpool member. +**************************************************************************** */ + +#define OBMALLOC_USED_POOLS_SIZE (2 * ((NB_SMALL_SIZE_CLASSES + 7) / 8) * 8) + +struct _obmalloc_pools { + poolp used[OBMALLOC_USED_POOLS_SIZE]; +}; + + +/*========================================================================== +Arena management. + +`arenas` is a vector of arena_objects. It contains maxarenas entries, some of +which may not be currently used (== they're arena_objects that aren't +currently associated with an allocated arena). Note that arenas proper are +separately malloc'ed. + +Prior to Python 2.5, arenas were never free()'ed. Starting with Python 2.5, +we do try to free() arenas, and use some mild heuristic strategies to increase +the likelihood that arenas eventually can be freed. + +unused_arena_objects + + This is a singly-linked list of the arena_objects that are currently not + being used (no arena is associated with them). Objects are taken off the + head of the list in new_arena(), and are pushed on the head of the list in + PyObject_Free() when the arena is empty. Key invariant: an arena_object + is on this list if and only if its .address member is 0. + +usable_arenas + + This is a doubly-linked list of the arena_objects associated with arenas + that have pools available. These pools are either waiting to be reused, + or have not been used before. The list is sorted to have the most- + allocated arenas first (ascending order based on the nfreepools member). + This means that the next allocation will come from a heavily used arena, + which gives the nearly empty arenas a chance to be returned to the system. + In my unscientific tests this dramatically improved the number of arenas + that could be freed. + +Note that an arena_object associated with an arena all of whose pools are +currently in use isn't on either list. + +Changed in Python 3.8: keeping usable_arenas sorted by number of free pools +used to be done by one-at-a-time linear search when an arena's number of +free pools changed. That could, overall, consume time quadratic in the +number of arenas. That didn't really matter when there were only a few +hundred arenas (typical!), but could be a timing disaster when there were +hundreds of thousands. See bpo-37029. + +Now we have a vector of "search fingers" to eliminate the need to search: +nfp2lasta[nfp] returns the last ("rightmost") arena in usable_arenas +with nfp free pools. This is NULL if and only if there is no arena with +nfp free pools in usable_arenas. +*/ + +/* How many arena_objects do we initially allocate? + * 16 = can allocate 16 arenas = 16 * ARENA_SIZE = 4MB before growing the + * `arenas` vector. + */ +#define INITIAL_ARENA_OBJECTS 16 + +struct _obmalloc_mgmt { + /* Array of objects used to track chunks of memory (arenas). */ + struct arena_object* arenas; + /* Number of slots currently allocated in the `arenas` vector. */ + uint maxarenas; + + /* The head of the singly-linked, NULL-terminated list of available + * arena_objects. + */ + struct arena_object* unused_arena_objects; + + /* The head of the doubly-linked, NULL-terminated at each end, list of + * arena_objects associated with arenas that have pools available. + */ + struct arena_object* usable_arenas; + + /* nfp2lasta[nfp] is the last arena in usable_arenas with nfp free pools */ + struct arena_object* nfp2lasta[MAX_POOLS_IN_ARENA + 1]; + + /* Number of arenas allocated that haven't been free()'d. */ + size_t narenas_currently_allocated; + + /* Total number of times malloc() called to allocate an arena. */ + size_t ntimes_arena_allocated; + /* High water mark (max value ever seen) for narenas_currently_allocated. */ + size_t narenas_highwater; + + Py_ssize_t raw_allocated_blocks; +}; + + +#if WITH_PYMALLOC_RADIX_TREE +/*==========================================================================*/ +/* radix tree for tracking arena usage. If enabled, used to implement + address_in_range(). + + memory address bit allocation for keys + + 64-bit pointers, IGNORE_BITS=0 and 2^20 arena size: + 15 -> MAP_TOP_BITS + 15 -> MAP_MID_BITS + 14 -> MAP_BOT_BITS + 20 -> ideal aligned arena + ---- + 64 + + 64-bit pointers, IGNORE_BITS=16, and 2^20 arena size: + 16 -> IGNORE_BITS + 10 -> MAP_TOP_BITS + 10 -> MAP_MID_BITS + 8 -> MAP_BOT_BITS + 20 -> ideal aligned arena + ---- + 64 + + 32-bit pointers and 2^18 arena size: + 14 -> MAP_BOT_BITS + 18 -> ideal aligned arena + ---- + 32 + +*/ + +#if SIZEOF_VOID_P == 8 + +/* number of bits in a pointer */ +#define POINTER_BITS 64 + +/* High bits of memory addresses that will be ignored when indexing into the + * radix tree. Setting this to zero is the safe default. For most 64-bit + * machines, setting this to 16 would be safe. The kernel would not give + * user-space virtual memory addresses that have significant information in + * those high bits. The main advantage to setting IGNORE_BITS > 0 is that less + * virtual memory will be used for the top and middle radix tree arrays. Those + * arrays are allocated in the BSS segment and so will typically consume real + * memory only if actually accessed. + */ +#define IGNORE_BITS 0 + +/* use the top and mid layers of the radix tree */ +#define USE_INTERIOR_NODES + +#elif SIZEOF_VOID_P == 4 + +#define POINTER_BITS 32 +#define IGNORE_BITS 0 + +#else + + /* Currently this code works for 64-bit or 32-bit pointers only. */ +#error "obmalloc radix tree requires 64-bit or 32-bit pointers." + +#endif /* SIZEOF_VOID_P */ + +/* arena_coverage_t members require this to be true */ +#if ARENA_BITS >= 32 +# error "arena size must be < 2^32" +#endif + +/* the lower bits of the address that are not ignored */ +#define ADDRESS_BITS (POINTER_BITS - IGNORE_BITS) + +#ifdef USE_INTERIOR_NODES +/* number of bits used for MAP_TOP and MAP_MID nodes */ +#define INTERIOR_BITS ((ADDRESS_BITS - ARENA_BITS + 2) / 3) +#else +#define INTERIOR_BITS 0 +#endif + +#define MAP_TOP_BITS INTERIOR_BITS +#define MAP_TOP_LENGTH (1 << MAP_TOP_BITS) +#define MAP_TOP_MASK (MAP_TOP_LENGTH - 1) + +#define MAP_MID_BITS INTERIOR_BITS +#define MAP_MID_LENGTH (1 << MAP_MID_BITS) +#define MAP_MID_MASK (MAP_MID_LENGTH - 1) + +#define MAP_BOT_BITS (ADDRESS_BITS - ARENA_BITS - 2*INTERIOR_BITS) +#define MAP_BOT_LENGTH (1 << MAP_BOT_BITS) +#define MAP_BOT_MASK (MAP_BOT_LENGTH - 1) + +#define MAP_BOT_SHIFT ARENA_BITS +#define MAP_MID_SHIFT (MAP_BOT_BITS + MAP_BOT_SHIFT) +#define MAP_TOP_SHIFT (MAP_MID_BITS + MAP_MID_SHIFT) + +#define AS_UINT(p) ((uintptr_t)(p)) +#define MAP_BOT_INDEX(p) ((AS_UINT(p) >> MAP_BOT_SHIFT) & MAP_BOT_MASK) +#define MAP_MID_INDEX(p) ((AS_UINT(p) >> MAP_MID_SHIFT) & MAP_MID_MASK) +#define MAP_TOP_INDEX(p) ((AS_UINT(p) >> MAP_TOP_SHIFT) & MAP_TOP_MASK) + +#if IGNORE_BITS > 0 +/* Return the ignored part of the pointer address. Those bits should be same + * for all valid pointers if IGNORE_BITS is set correctly. + */ +#define HIGH_BITS(p) (AS_UINT(p) >> ADDRESS_BITS) +#else +#define HIGH_BITS(p) 0 +#endif + + +/* This is the leaf of the radix tree. See arena_map_mark_used() for the + * meaning of these members. */ +typedef struct { + int32_t tail_hi; + int32_t tail_lo; +} arena_coverage_t; + +typedef struct arena_map_bot { + /* The members tail_hi and tail_lo are accessed together. So, it + * better to have them as an array of structs, rather than two + * arrays. + */ + arena_coverage_t arenas[MAP_BOT_LENGTH]; +} arena_map_bot_t; + +#ifdef USE_INTERIOR_NODES +typedef struct arena_map_mid { + struct arena_map_bot *ptrs[MAP_MID_LENGTH]; +} arena_map_mid_t; + +typedef struct arena_map_top { + struct arena_map_mid *ptrs[MAP_TOP_LENGTH]; +} arena_map_top_t; +#endif + +struct _obmalloc_usage { + /* The root of radix tree. Note that by initializing like this, the memory + * should be in the BSS. The OS will only memory map pages as the MAP_MID + * nodes get used (OS pages are demand loaded as needed). + */ +#ifdef USE_INTERIOR_NODES + arena_map_top_t arena_map_root; + /* accounting for number of used interior nodes */ + int arena_map_mid_count; + int arena_map_bot_count; +#else + arena_map_bot_t arena_map_root; +#endif +}; + +#endif /* WITH_PYMALLOC_RADIX_TREE */ + + +struct _obmalloc_global_state { + int dump_debug_stats; + Py_ssize_t interpreter_leaks; +}; + +struct _obmalloc_state { + struct _obmalloc_pools pools; + struct _obmalloc_mgmt mgmt; +#if WITH_PYMALLOC_RADIX_TREE + struct _obmalloc_usage usage; +#endif +}; + + +#undef uint + + +/* Allocate memory directly from the O/S virtual memory system, + * where supported. Otherwise fallback on malloc */ +void *_PyObject_VirtualAlloc(size_t size); +void _PyObject_VirtualFree(void *, size_t size); + + +/* This function returns the number of allocated memory blocks, regardless of size */ +extern Py_ssize_t _Py_GetGlobalAllocatedBlocks(void); +#define _Py_GetAllocatedBlocks() \ + _Py_GetGlobalAllocatedBlocks() +extern Py_ssize_t _PyInterpreterState_GetAllocatedBlocks(PyInterpreterState *); +extern void _PyInterpreterState_FinalizeAllocatedBlocks(PyInterpreterState *); +extern int _PyMem_init_obmalloc(PyInterpreterState *interp); +extern bool _PyMem_obmalloc_state_on_heap(PyInterpreterState *interp); + + +#ifdef WITH_PYMALLOC +// Export the symbol for the 3rd party 'guppy3' project +PyAPI_FUNC(int) _PyObject_DebugMallocStats(FILE *out); +#endif + + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_OBMALLOC_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_obmalloc_init.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_obmalloc_init.h new file mode 100644 index 0000000000000000000000000000000000000000..e6811b7aeca73c196b16519cb12a902af442f998 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_obmalloc_init.h @@ -0,0 +1,66 @@ +#ifndef Py_INTERNAL_OBMALLOC_INIT_H +#define Py_INTERNAL_OBMALLOC_INIT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + + +/****************************************************/ +/* the default object allocator's state initializer */ + +#define PTA(pools, x) \ + ((poolp )((uint8_t *)&(pools.used[2*(x)]) - 2*sizeof(pymem_block *))) +#define PT(p, x) PTA(p, x), PTA(p, x) + +#define PT_8(p, start) \ + PT(p, start), \ + PT(p, start+1), \ + PT(p, start+2), \ + PT(p, start+3), \ + PT(p, start+4), \ + PT(p, start+5), \ + PT(p, start+6), \ + PT(p, start+7) + +#if NB_SMALL_SIZE_CLASSES <= 8 +# define _obmalloc_pools_INIT(p) \ + { PT_8(p, 0) } +#elif NB_SMALL_SIZE_CLASSES <= 16 +# define _obmalloc_pools_INIT(p) \ + { PT_8(p, 0), PT_8(p, 8) } +#elif NB_SMALL_SIZE_CLASSES <= 24 +# define _obmalloc_pools_INIT(p) \ + { PT_8(p, 0), PT_8(p, 8), PT_8(p, 16) } +#elif NB_SMALL_SIZE_CLASSES <= 32 +# define _obmalloc_pools_INIT(p) \ + { PT_8(p, 0), PT_8(p, 8), PT_8(p, 16), PT_8(p, 24) } +#elif NB_SMALL_SIZE_CLASSES <= 40 +# define _obmalloc_pools_INIT(p) \ + { PT_8(p, 0), PT_8(p, 8), PT_8(p, 16), PT_8(p, 24), PT_8(p, 32) } +#elif NB_SMALL_SIZE_CLASSES <= 48 +# define _obmalloc_pools_INIT(p) \ + { PT_8(p, 0), PT_8(p, 8), PT_8(p, 16), PT_8(p, 24), PT_8(p, 32), PT_8(p, 40) } +#elif NB_SMALL_SIZE_CLASSES <= 56 +# define _obmalloc_pools_INIT(p) \ + { PT_8(p, 0), PT_8(p, 8), PT_8(p, 16), PT_8(p, 24), PT_8(p, 32), PT_8(p, 40), PT_8(p, 48) } +#elif NB_SMALL_SIZE_CLASSES <= 64 +# define _obmalloc_pools_INIT(p) \ + { PT_8(p, 0), PT_8(p, 8), PT_8(p, 16), PT_8(p, 24), PT_8(p, 32), PT_8(p, 40), PT_8(p, 48), PT_8(p, 56) } +#else +# error "NB_SMALL_SIZE_CLASSES should be less than 64" +#endif + +#define _obmalloc_global_state_INIT \ + { \ + .dump_debug_stats = -1, \ + } + + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_OBMALLOC_INIT_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_opcode_metadata.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_opcode_metadata.h new file mode 100644 index 0000000000000000000000000000000000000000..ccd10e90f0c0a35780646920674e89887e465aa7 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_opcode_metadata.h @@ -0,0 +1,2117 @@ +// This file is generated by Tools/cases_generator/opcode_metadata_generator.py +// from: +// Python/bytecodes.c +// Do not edit! + +#ifndef Py_CORE_OPCODE_METADATA_H +#define Py_CORE_OPCODE_METADATA_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include // bool +#include "opcode_ids.h" + + +#define IS_PSEUDO_INSTR(OP) ( \ + ((OP) == LOAD_CLOSURE) || \ + ((OP) == STORE_FAST_MAYBE_NULL) || \ + ((OP) == ANNOTATIONS_PLACEHOLDER) || \ + ((OP) == JUMP) || \ + ((OP) == JUMP_NO_INTERRUPT) || \ + ((OP) == JUMP_IF_FALSE) || \ + ((OP) == JUMP_IF_TRUE) || \ + ((OP) == SETUP_FINALLY) || \ + ((OP) == SETUP_CLEANUP) || \ + ((OP) == SETUP_WITH) || \ + ((OP) == POP_BLOCK) || \ + 0) + +#include "pycore_uop_ids.h" +extern int _PyOpcode_num_popped(int opcode, int oparg); +#ifdef NEED_OPCODE_METADATA +int _PyOpcode_num_popped(int opcode, int oparg) { + switch(opcode) { + case ANNOTATIONS_PLACEHOLDER: + return 0; + case BINARY_OP: + return 2; + case BINARY_OP_ADD_FLOAT: + return 2; + case BINARY_OP_ADD_INT: + return 2; + case BINARY_OP_ADD_UNICODE: + return 2; + case BINARY_OP_EXTEND: + return 2; + case BINARY_OP_INPLACE_ADD_UNICODE: + return 2; + case BINARY_OP_MULTIPLY_FLOAT: + return 2; + case BINARY_OP_MULTIPLY_INT: + return 2; + case BINARY_OP_SUBSCR_DICT: + return 2; + case BINARY_OP_SUBSCR_GETITEM: + return 2; + case BINARY_OP_SUBSCR_LIST_INT: + return 2; + case BINARY_OP_SUBSCR_LIST_SLICE: + return 2; + case BINARY_OP_SUBSCR_STR_INT: + return 2; + case BINARY_OP_SUBSCR_TUPLE_INT: + return 2; + case BINARY_OP_SUBTRACT_FLOAT: + return 2; + case BINARY_OP_SUBTRACT_INT: + return 2; + case BINARY_SLICE: + return 3; + case BUILD_INTERPOLATION: + return 2 + (oparg & 1); + case BUILD_LIST: + return oparg; + case BUILD_MAP: + return oparg*2; + case BUILD_SET: + return oparg; + case BUILD_SLICE: + return oparg; + case BUILD_STRING: + return oparg; + case BUILD_TEMPLATE: + return 2; + case BUILD_TUPLE: + return oparg; + case CACHE: + return 0; + case CALL: + return 2 + oparg; + case CALL_ALLOC_AND_ENTER_INIT: + return 2 + oparg; + case CALL_BOUND_METHOD_EXACT_ARGS: + return 2 + oparg; + case CALL_BOUND_METHOD_GENERAL: + return 2 + oparg; + case CALL_BUILTIN_CLASS: + return 2 + oparg; + case CALL_BUILTIN_FAST: + return 2 + oparg; + case CALL_BUILTIN_FAST_WITH_KEYWORDS: + return 2 + oparg; + case CALL_BUILTIN_O: + return 2 + oparg; + case CALL_FUNCTION_EX: + return 4; + case CALL_INTRINSIC_1: + return 1; + case CALL_INTRINSIC_2: + return 2; + case CALL_ISINSTANCE: + return 2 + oparg; + case CALL_KW: + return 3 + oparg; + case CALL_KW_BOUND_METHOD: + return 3 + oparg; + case CALL_KW_NON_PY: + return 3 + oparg; + case CALL_KW_PY: + return 3 + oparg; + case CALL_LEN: + return 3; + case CALL_LIST_APPEND: + return 3; + case CALL_METHOD_DESCRIPTOR_FAST: + return 2 + oparg; + case CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS: + return 2 + oparg; + case CALL_METHOD_DESCRIPTOR_NOARGS: + return 2 + oparg; + case CALL_METHOD_DESCRIPTOR_O: + return 2 + oparg; + case CALL_NON_PY_GENERAL: + return 2 + oparg; + case CALL_PY_EXACT_ARGS: + return 2 + oparg; + case CALL_PY_GENERAL: + return 2 + oparg; + case CALL_STR_1: + return 3; + case CALL_TUPLE_1: + return 3; + case CALL_TYPE_1: + return 3; + case CHECK_EG_MATCH: + return 2; + case CHECK_EXC_MATCH: + return 2; + case CLEANUP_THROW: + return 3; + case COMPARE_OP: + return 2; + case COMPARE_OP_FLOAT: + return 2; + case COMPARE_OP_INT: + return 2; + case COMPARE_OP_STR: + return 2; + case CONTAINS_OP: + return 2; + case CONTAINS_OP_DICT: + return 2; + case CONTAINS_OP_SET: + return 2; + case CONVERT_VALUE: + return 1; + case COPY: + return 1 + (oparg-1); + case COPY_FREE_VARS: + return 0; + case DELETE_ATTR: + return 1; + case DELETE_DEREF: + return 0; + case DELETE_FAST: + return 0; + case DELETE_GLOBAL: + return 0; + case DELETE_NAME: + return 0; + case DELETE_SUBSCR: + return 2; + case DICT_MERGE: + return 5 + (oparg - 1); + case DICT_UPDATE: + return 2 + (oparg - 1); + case END_ASYNC_FOR: + return 2; + case END_FOR: + return 1; + case END_SEND: + return 2; + case ENTER_EXECUTOR: + return 0; + case EXIT_INIT_CHECK: + return 1; + case EXTENDED_ARG: + return 0; + case FORMAT_SIMPLE: + return 1; + case FORMAT_WITH_SPEC: + return 2; + case FOR_ITER: + return 1; + case FOR_ITER_GEN: + return 1; + case FOR_ITER_LIST: + return 1; + case FOR_ITER_RANGE: + return 1; + case FOR_ITER_TUPLE: + return 1; + case GET_AITER: + return 1; + case GET_ANEXT: + return 1; + case GET_AWAITABLE: + return 1; + case GET_ITER: + return 1; + case GET_LEN: + return 1; + case GET_YIELD_FROM_ITER: + return 1; + case IMPORT_FROM: + return 1; + case IMPORT_NAME: + return 2; + case INSTRUMENTED_CALL: + return 2 + oparg; + case INSTRUMENTED_CALL_FUNCTION_EX: + return 4; + case INSTRUMENTED_CALL_KW: + return 3 + oparg; + case INSTRUMENTED_END_ASYNC_FOR: + return 2; + case INSTRUMENTED_END_FOR: + return 2; + case INSTRUMENTED_END_SEND: + return 2; + case INSTRUMENTED_FOR_ITER: + return 1; + case INSTRUMENTED_INSTRUCTION: + return 0; + case INSTRUMENTED_JUMP_BACKWARD: + return 0; + case INSTRUMENTED_JUMP_FORWARD: + return 0; + case INSTRUMENTED_LINE: + return 0; + case INSTRUMENTED_LOAD_SUPER_ATTR: + return 3; + case INSTRUMENTED_NOT_TAKEN: + return 0; + case INSTRUMENTED_POP_ITER: + return 1; + case INSTRUMENTED_POP_JUMP_IF_FALSE: + return 1; + case INSTRUMENTED_POP_JUMP_IF_NONE: + return 1; + case INSTRUMENTED_POP_JUMP_IF_NOT_NONE: + return 1; + case INSTRUMENTED_POP_JUMP_IF_TRUE: + return 1; + case INSTRUMENTED_RESUME: + return 0; + case INSTRUMENTED_RETURN_VALUE: + return 1; + case INSTRUMENTED_YIELD_VALUE: + return 1; + case INTERPRETER_EXIT: + return 1; + case IS_OP: + return 2; + case JUMP: + return 0; + case JUMP_BACKWARD: + return 0; + case JUMP_BACKWARD_JIT: + return 0; + case JUMP_BACKWARD_NO_INTERRUPT: + return 0; + case JUMP_BACKWARD_NO_JIT: + return 0; + case JUMP_FORWARD: + return 0; + case JUMP_IF_FALSE: + return 1; + case JUMP_IF_TRUE: + return 1; + case JUMP_NO_INTERRUPT: + return 0; + case LIST_APPEND: + return 2 + (oparg-1); + case LIST_EXTEND: + return 2 + (oparg-1); + case LOAD_ATTR: + return 1; + case LOAD_ATTR_CLASS: + return 1; + case LOAD_ATTR_CLASS_WITH_METACLASS_CHECK: + return 1; + case LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN: + return 1; + case LOAD_ATTR_INSTANCE_VALUE: + return 1; + case LOAD_ATTR_METHOD_LAZY_DICT: + return 1; + case LOAD_ATTR_METHOD_NO_DICT: + return 1; + case LOAD_ATTR_METHOD_WITH_VALUES: + return 1; + case LOAD_ATTR_MODULE: + return 1; + case LOAD_ATTR_NONDESCRIPTOR_NO_DICT: + return 1; + case LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES: + return 1; + case LOAD_ATTR_PROPERTY: + return 1; + case LOAD_ATTR_SLOT: + return 1; + case LOAD_ATTR_WITH_HINT: + return 1; + case LOAD_BUILD_CLASS: + return 0; + case LOAD_CLOSURE: + return 0; + case LOAD_COMMON_CONSTANT: + return 0; + case LOAD_CONST: + return 0; + case LOAD_CONST_IMMORTAL: + return 0; + case LOAD_CONST_MORTAL: + return 0; + case LOAD_DEREF: + return 0; + case LOAD_FAST: + return 0; + case LOAD_FAST_AND_CLEAR: + return 0; + case LOAD_FAST_BORROW: + return 0; + case LOAD_FAST_BORROW_LOAD_FAST_BORROW: + return 0; + case LOAD_FAST_CHECK: + return 0; + case LOAD_FAST_LOAD_FAST: + return 0; + case LOAD_FROM_DICT_OR_DEREF: + return 1; + case LOAD_FROM_DICT_OR_GLOBALS: + return 1; + case LOAD_GLOBAL: + return 0; + case LOAD_GLOBAL_BUILTIN: + return 0; + case LOAD_GLOBAL_MODULE: + return 0; + case LOAD_LOCALS: + return 0; + case LOAD_NAME: + return 0; + case LOAD_SMALL_INT: + return 0; + case LOAD_SPECIAL: + return 1; + case LOAD_SUPER_ATTR: + return 3; + case LOAD_SUPER_ATTR_ATTR: + return 3; + case LOAD_SUPER_ATTR_METHOD: + return 3; + case MAKE_CELL: + return 0; + case MAKE_FUNCTION: + return 1; + case MAP_ADD: + return 3 + (oparg - 1); + case MATCH_CLASS: + return 3; + case MATCH_KEYS: + return 2; + case MATCH_MAPPING: + return 1; + case MATCH_SEQUENCE: + return 1; + case NOP: + return 0; + case NOT_TAKEN: + return 0; + case POP_BLOCK: + return 0; + case POP_EXCEPT: + return 1; + case POP_ITER: + return 1; + case POP_JUMP_IF_FALSE: + return 1; + case POP_JUMP_IF_NONE: + return 1; + case POP_JUMP_IF_NOT_NONE: + return 1; + case POP_JUMP_IF_TRUE: + return 1; + case POP_TOP: + return 1; + case PUSH_EXC_INFO: + return 1; + case PUSH_NULL: + return 0; + case RAISE_VARARGS: + return oparg; + case RERAISE: + return 1 + oparg; + case RESERVED: + return 0; + case RESUME: + return 0; + case RESUME_CHECK: + return 0; + case RETURN_GENERATOR: + return 0; + case RETURN_VALUE: + return 1; + case SEND: + return 2; + case SEND_GEN: + return 2; + case SETUP_ANNOTATIONS: + return 0; + case SETUP_CLEANUP: + return 0; + case SETUP_FINALLY: + return 0; + case SETUP_WITH: + return 0; + case SET_ADD: + return 2 + (oparg-1); + case SET_FUNCTION_ATTRIBUTE: + return 2; + case SET_UPDATE: + return 2 + (oparg-1); + case STORE_ATTR: + return 2; + case STORE_ATTR_INSTANCE_VALUE: + return 2; + case STORE_ATTR_SLOT: + return 2; + case STORE_ATTR_WITH_HINT: + return 2; + case STORE_DEREF: + return 1; + case STORE_FAST: + return 1; + case STORE_FAST_LOAD_FAST: + return 1; + case STORE_FAST_MAYBE_NULL: + return 1; + case STORE_FAST_STORE_FAST: + return 2; + case STORE_GLOBAL: + return 1; + case STORE_NAME: + return 1; + case STORE_SLICE: + return 4; + case STORE_SUBSCR: + return 3; + case STORE_SUBSCR_DICT: + return 3; + case STORE_SUBSCR_LIST_INT: + return 3; + case SWAP: + return 2 + (oparg-2); + case TO_BOOL: + return 1; + case TO_BOOL_ALWAYS_TRUE: + return 1; + case TO_BOOL_BOOL: + return 1; + case TO_BOOL_INT: + return 1; + case TO_BOOL_LIST: + return 1; + case TO_BOOL_NONE: + return 1; + case TO_BOOL_STR: + return 1; + case UNARY_INVERT: + return 1; + case UNARY_NEGATIVE: + return 1; + case UNARY_NOT: + return 1; + case UNPACK_EX: + return 1; + case UNPACK_SEQUENCE: + return 1; + case UNPACK_SEQUENCE_LIST: + return 1; + case UNPACK_SEQUENCE_TUPLE: + return 1; + case UNPACK_SEQUENCE_TWO_TUPLE: + return 1; + case WITH_EXCEPT_START: + return 5; + case YIELD_VALUE: + return 1; + default: + return -1; + } +} + +#endif + +extern int _PyOpcode_num_pushed(int opcode, int oparg); +#ifdef NEED_OPCODE_METADATA +int _PyOpcode_num_pushed(int opcode, int oparg) { + switch(opcode) { + case ANNOTATIONS_PLACEHOLDER: + return 0; + case BINARY_OP: + return 1; + case BINARY_OP_ADD_FLOAT: + return 1; + case BINARY_OP_ADD_INT: + return 1; + case BINARY_OP_ADD_UNICODE: + return 1; + case BINARY_OP_EXTEND: + return 1; + case BINARY_OP_INPLACE_ADD_UNICODE: + return 0; + case BINARY_OP_MULTIPLY_FLOAT: + return 1; + case BINARY_OP_MULTIPLY_INT: + return 1; + case BINARY_OP_SUBSCR_DICT: + return 1; + case BINARY_OP_SUBSCR_GETITEM: + return 0; + case BINARY_OP_SUBSCR_LIST_INT: + return 1; + case BINARY_OP_SUBSCR_LIST_SLICE: + return 1; + case BINARY_OP_SUBSCR_STR_INT: + return 1; + case BINARY_OP_SUBSCR_TUPLE_INT: + return 1; + case BINARY_OP_SUBTRACT_FLOAT: + return 1; + case BINARY_OP_SUBTRACT_INT: + return 1; + case BINARY_SLICE: + return 1; + case BUILD_INTERPOLATION: + return 1; + case BUILD_LIST: + return 1; + case BUILD_MAP: + return 1; + case BUILD_SET: + return 1; + case BUILD_SLICE: + return 1; + case BUILD_STRING: + return 1; + case BUILD_TEMPLATE: + return 1; + case BUILD_TUPLE: + return 1; + case CACHE: + return 0; + case CALL: + return 1; + case CALL_ALLOC_AND_ENTER_INIT: + return 0; + case CALL_BOUND_METHOD_EXACT_ARGS: + return 0; + case CALL_BOUND_METHOD_GENERAL: + return 0; + case CALL_BUILTIN_CLASS: + return 1; + case CALL_BUILTIN_FAST: + return 1; + case CALL_BUILTIN_FAST_WITH_KEYWORDS: + return 1; + case CALL_BUILTIN_O: + return 1; + case CALL_FUNCTION_EX: + return 1; + case CALL_INTRINSIC_1: + return 1; + case CALL_INTRINSIC_2: + return 1; + case CALL_ISINSTANCE: + return 1; + case CALL_KW: + return 1; + case CALL_KW_BOUND_METHOD: + return 0; + case CALL_KW_NON_PY: + return 1; + case CALL_KW_PY: + return 0; + case CALL_LEN: + return 1; + case CALL_LIST_APPEND: + return 0; + case CALL_METHOD_DESCRIPTOR_FAST: + return 1; + case CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS: + return 1; + case CALL_METHOD_DESCRIPTOR_NOARGS: + return 1; + case CALL_METHOD_DESCRIPTOR_O: + return 1; + case CALL_NON_PY_GENERAL: + return 1; + case CALL_PY_EXACT_ARGS: + return 0; + case CALL_PY_GENERAL: + return 0; + case CALL_STR_1: + return 1; + case CALL_TUPLE_1: + return 1; + case CALL_TYPE_1: + return 1; + case CHECK_EG_MATCH: + return 2; + case CHECK_EXC_MATCH: + return 2; + case CLEANUP_THROW: + return 2; + case COMPARE_OP: + return 1; + case COMPARE_OP_FLOAT: + return 1; + case COMPARE_OP_INT: + return 1; + case COMPARE_OP_STR: + return 1; + case CONTAINS_OP: + return 1; + case CONTAINS_OP_DICT: + return 1; + case CONTAINS_OP_SET: + return 1; + case CONVERT_VALUE: + return 1; + case COPY: + return 2 + (oparg-1); + case COPY_FREE_VARS: + return 0; + case DELETE_ATTR: + return 0; + case DELETE_DEREF: + return 0; + case DELETE_FAST: + return 0; + case DELETE_GLOBAL: + return 0; + case DELETE_NAME: + return 0; + case DELETE_SUBSCR: + return 0; + case DICT_MERGE: + return 4 + (oparg - 1); + case DICT_UPDATE: + return 1 + (oparg - 1); + case END_ASYNC_FOR: + return 0; + case END_FOR: + return 0; + case END_SEND: + return 1; + case ENTER_EXECUTOR: + return 0; + case EXIT_INIT_CHECK: + return 0; + case EXTENDED_ARG: + return 0; + case FORMAT_SIMPLE: + return 1; + case FORMAT_WITH_SPEC: + return 1; + case FOR_ITER: + return 2; + case FOR_ITER_GEN: + return 1; + case FOR_ITER_LIST: + return 2; + case FOR_ITER_RANGE: + return 2; + case FOR_ITER_TUPLE: + return 2; + case GET_AITER: + return 1; + case GET_ANEXT: + return 2; + case GET_AWAITABLE: + return 1; + case GET_ITER: + return 1; + case GET_LEN: + return 2; + case GET_YIELD_FROM_ITER: + return 1; + case IMPORT_FROM: + return 2; + case IMPORT_NAME: + return 1; + case INSTRUMENTED_CALL: + return 1; + case INSTRUMENTED_CALL_FUNCTION_EX: + return 1; + case INSTRUMENTED_CALL_KW: + return 1; + case INSTRUMENTED_END_ASYNC_FOR: + return 0; + case INSTRUMENTED_END_FOR: + return 1; + case INSTRUMENTED_END_SEND: + return 1; + case INSTRUMENTED_FOR_ITER: + return 2; + case INSTRUMENTED_INSTRUCTION: + return 0; + case INSTRUMENTED_JUMP_BACKWARD: + return 0; + case INSTRUMENTED_JUMP_FORWARD: + return 0; + case INSTRUMENTED_LINE: + return 0; + case INSTRUMENTED_LOAD_SUPER_ATTR: + return 1 + (oparg & 1); + case INSTRUMENTED_NOT_TAKEN: + return 0; + case INSTRUMENTED_POP_ITER: + return 0; + case INSTRUMENTED_POP_JUMP_IF_FALSE: + return 0; + case INSTRUMENTED_POP_JUMP_IF_NONE: + return 0; + case INSTRUMENTED_POP_JUMP_IF_NOT_NONE: + return 0; + case INSTRUMENTED_POP_JUMP_IF_TRUE: + return 0; + case INSTRUMENTED_RESUME: + return 0; + case INSTRUMENTED_RETURN_VALUE: + return 1; + case INSTRUMENTED_YIELD_VALUE: + return 1; + case INTERPRETER_EXIT: + return 0; + case IS_OP: + return 1; + case JUMP: + return 0; + case JUMP_BACKWARD: + return 0; + case JUMP_BACKWARD_JIT: + return 0; + case JUMP_BACKWARD_NO_INTERRUPT: + return 0; + case JUMP_BACKWARD_NO_JIT: + return 0; + case JUMP_FORWARD: + return 0; + case JUMP_IF_FALSE: + return 1; + case JUMP_IF_TRUE: + return 1; + case JUMP_NO_INTERRUPT: + return 0; + case LIST_APPEND: + return 1 + (oparg-1); + case LIST_EXTEND: + return 1 + (oparg-1); + case LOAD_ATTR: + return 1 + (oparg&1); + case LOAD_ATTR_CLASS: + return 1 + (oparg & 1); + case LOAD_ATTR_CLASS_WITH_METACLASS_CHECK: + return 1 + (oparg & 1); + case LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN: + return 1; + case LOAD_ATTR_INSTANCE_VALUE: + return 1 + (oparg & 1); + case LOAD_ATTR_METHOD_LAZY_DICT: + return 2; + case LOAD_ATTR_METHOD_NO_DICT: + return 2; + case LOAD_ATTR_METHOD_WITH_VALUES: + return 2; + case LOAD_ATTR_MODULE: + return 1 + (oparg & 1); + case LOAD_ATTR_NONDESCRIPTOR_NO_DICT: + return 1; + case LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES: + return 1; + case LOAD_ATTR_PROPERTY: + return 0; + case LOAD_ATTR_SLOT: + return 1 + (oparg & 1); + case LOAD_ATTR_WITH_HINT: + return 1 + (oparg & 1); + case LOAD_BUILD_CLASS: + return 1; + case LOAD_CLOSURE: + return 1; + case LOAD_COMMON_CONSTANT: + return 1; + case LOAD_CONST: + return 1; + case LOAD_CONST_IMMORTAL: + return 1; + case LOAD_CONST_MORTAL: + return 1; + case LOAD_DEREF: + return 1; + case LOAD_FAST: + return 1; + case LOAD_FAST_AND_CLEAR: + return 1; + case LOAD_FAST_BORROW: + return 1; + case LOAD_FAST_BORROW_LOAD_FAST_BORROW: + return 2; + case LOAD_FAST_CHECK: + return 1; + case LOAD_FAST_LOAD_FAST: + return 2; + case LOAD_FROM_DICT_OR_DEREF: + return 1; + case LOAD_FROM_DICT_OR_GLOBALS: + return 1; + case LOAD_GLOBAL: + return 1 + (oparg & 1); + case LOAD_GLOBAL_BUILTIN: + return 1 + (oparg & 1); + case LOAD_GLOBAL_MODULE: + return 1 + (oparg & 1); + case LOAD_LOCALS: + return 1; + case LOAD_NAME: + return 1; + case LOAD_SMALL_INT: + return 1; + case LOAD_SPECIAL: + return 2; + case LOAD_SUPER_ATTR: + return 1 + (oparg & 1); + case LOAD_SUPER_ATTR_ATTR: + return 1; + case LOAD_SUPER_ATTR_METHOD: + return 2; + case MAKE_CELL: + return 0; + case MAKE_FUNCTION: + return 1; + case MAP_ADD: + return 1 + (oparg - 1); + case MATCH_CLASS: + return 1; + case MATCH_KEYS: + return 3; + case MATCH_MAPPING: + return 2; + case MATCH_SEQUENCE: + return 2; + case NOP: + return 0; + case NOT_TAKEN: + return 0; + case POP_BLOCK: + return 0; + case POP_EXCEPT: + return 0; + case POP_ITER: + return 0; + case POP_JUMP_IF_FALSE: + return 0; + case POP_JUMP_IF_NONE: + return 0; + case POP_JUMP_IF_NOT_NONE: + return 0; + case POP_JUMP_IF_TRUE: + return 0; + case POP_TOP: + return 0; + case PUSH_EXC_INFO: + return 2; + case PUSH_NULL: + return 1; + case RAISE_VARARGS: + return 0; + case RERAISE: + return oparg; + case RESERVED: + return 0; + case RESUME: + return 0; + case RESUME_CHECK: + return 0; + case RETURN_GENERATOR: + return 1; + case RETURN_VALUE: + return 1; + case SEND: + return 2; + case SEND_GEN: + return 1; + case SETUP_ANNOTATIONS: + return 0; + case SETUP_CLEANUP: + return 2; + case SETUP_FINALLY: + return 1; + case SETUP_WITH: + return 1; + case SET_ADD: + return 1 + (oparg-1); + case SET_FUNCTION_ATTRIBUTE: + return 1; + case SET_UPDATE: + return 1 + (oparg-1); + case STORE_ATTR: + return 0; + case STORE_ATTR_INSTANCE_VALUE: + return 0; + case STORE_ATTR_SLOT: + return 0; + case STORE_ATTR_WITH_HINT: + return 0; + case STORE_DEREF: + return 0; + case STORE_FAST: + return 0; + case STORE_FAST_LOAD_FAST: + return 1; + case STORE_FAST_MAYBE_NULL: + return 0; + case STORE_FAST_STORE_FAST: + return 0; + case STORE_GLOBAL: + return 0; + case STORE_NAME: + return 0; + case STORE_SLICE: + return 0; + case STORE_SUBSCR: + return 0; + case STORE_SUBSCR_DICT: + return 0; + case STORE_SUBSCR_LIST_INT: + return 0; + case SWAP: + return 2 + (oparg-2); + case TO_BOOL: + return 1; + case TO_BOOL_ALWAYS_TRUE: + return 1; + case TO_BOOL_BOOL: + return 1; + case TO_BOOL_INT: + return 1; + case TO_BOOL_LIST: + return 1; + case TO_BOOL_NONE: + return 1; + case TO_BOOL_STR: + return 1; + case UNARY_INVERT: + return 1; + case UNARY_NEGATIVE: + return 1; + case UNARY_NOT: + return 1; + case UNPACK_EX: + return 1 + (oparg & 0xFF) + (oparg >> 8); + case UNPACK_SEQUENCE: + return oparg; + case UNPACK_SEQUENCE_LIST: + return oparg; + case UNPACK_SEQUENCE_TUPLE: + return oparg; + case UNPACK_SEQUENCE_TWO_TUPLE: + return 2; + case WITH_EXCEPT_START: + return 6; + case YIELD_VALUE: + return 1; + default: + return -1; + } +} + +#endif + +enum InstructionFormat { + INSTR_FMT_IB = 1, + INSTR_FMT_IBC = 2, + INSTR_FMT_IBC00 = 3, + INSTR_FMT_IBC000 = 4, + INSTR_FMT_IBC0000 = 5, + INSTR_FMT_IBC00000000 = 6, + INSTR_FMT_IX = 7, + INSTR_FMT_IXC = 8, + INSTR_FMT_IXC00 = 9, + INSTR_FMT_IXC000 = 10, + INSTR_FMT_IXC0000 = 11, +}; + +#define IS_VALID_OPCODE(OP) \ + (((OP) >= 0) && ((OP) < 267) && \ + (_PyOpcode_opcode_metadata[(OP)].valid_entry)) + +#define HAS_ARG_FLAG (1) +#define HAS_CONST_FLAG (2) +#define HAS_NAME_FLAG (4) +#define HAS_JUMP_FLAG (8) +#define HAS_FREE_FLAG (16) +#define HAS_LOCAL_FLAG (32) +#define HAS_EVAL_BREAK_FLAG (64) +#define HAS_DEOPT_FLAG (128) +#define HAS_ERROR_FLAG (256) +#define HAS_ESCAPES_FLAG (512) +#define HAS_EXIT_FLAG (1024) +#define HAS_PURE_FLAG (2048) +#define HAS_PASSTHROUGH_FLAG (4096) +#define HAS_OPARG_AND_1_FLAG (8192) +#define HAS_ERROR_NO_POP_FLAG (16384) +#define HAS_NO_SAVE_IP_FLAG (32768) +#define OPCODE_HAS_ARG(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ARG_FLAG)) +#define OPCODE_HAS_CONST(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_CONST_FLAG)) +#define OPCODE_HAS_NAME(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_NAME_FLAG)) +#define OPCODE_HAS_JUMP(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_JUMP_FLAG)) +#define OPCODE_HAS_FREE(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_FREE_FLAG)) +#define OPCODE_HAS_LOCAL(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_LOCAL_FLAG)) +#define OPCODE_HAS_EVAL_BREAK(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_EVAL_BREAK_FLAG)) +#define OPCODE_HAS_DEOPT(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_DEOPT_FLAG)) +#define OPCODE_HAS_ERROR(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ERROR_FLAG)) +#define OPCODE_HAS_ESCAPES(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ESCAPES_FLAG)) +#define OPCODE_HAS_EXIT(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_EXIT_FLAG)) +#define OPCODE_HAS_PURE(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_PURE_FLAG)) +#define OPCODE_HAS_PASSTHROUGH(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_PASSTHROUGH_FLAG)) +#define OPCODE_HAS_OPARG_AND_1(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_OPARG_AND_1_FLAG)) +#define OPCODE_HAS_ERROR_NO_POP(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ERROR_NO_POP_FLAG)) +#define OPCODE_HAS_NO_SAVE_IP(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_NO_SAVE_IP_FLAG)) + +#define OPARG_SIMPLE 0 +#define OPARG_CACHE_1 1 +#define OPARG_CACHE_2 2 +#define OPARG_CACHE_4 4 +#define OPARG_TOP 5 +#define OPARG_BOTTOM 6 +#define OPARG_SAVE_RETURN_OFFSET 7 +#define OPARG_REPLACED 9 +#define OPERAND1_1 10 +#define OPERAND1_2 11 +#define OPERAND1_4 12 + +struct opcode_metadata { + uint8_t valid_entry; + uint8_t instr_format; + uint16_t flags; +}; + +extern const struct opcode_metadata _PyOpcode_opcode_metadata[267]; +#ifdef NEED_OPCODE_METADATA +const struct opcode_metadata _PyOpcode_opcode_metadata[267] = { + [BINARY_OP] = { true, INSTR_FMT_IBC0000, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [BINARY_OP_ADD_FLOAT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG }, + [BINARY_OP_ADD_INT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BINARY_OP_ADD_UNICODE] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG }, + [BINARY_OP_EXTEND] = { true, INSTR_FMT_IXC0000, HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BINARY_OP_INPLACE_ADD_UNICODE] = { true, INSTR_FMT_IXC0000, HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BINARY_OP_MULTIPLY_FLOAT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG }, + [BINARY_OP_MULTIPLY_INT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BINARY_OP_SUBSCR_DICT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BINARY_OP_SUBSCR_GETITEM] = { true, INSTR_FMT_IXC0000, HAS_DEOPT_FLAG }, + [BINARY_OP_SUBSCR_LIST_INT] = { true, INSTR_FMT_IXC0000, HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ESCAPES_FLAG }, + [BINARY_OP_SUBSCR_LIST_SLICE] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BINARY_OP_SUBSCR_STR_INT] = { true, INSTR_FMT_IXC0000, HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ESCAPES_FLAG }, + [BINARY_OP_SUBSCR_TUPLE_INT] = { true, INSTR_FMT_IXC0000, HAS_DEOPT_FLAG | HAS_EXIT_FLAG }, + [BINARY_OP_SUBTRACT_FLOAT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG }, + [BINARY_OP_SUBTRACT_INT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BINARY_SLICE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BUILD_INTERPOLATION] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BUILD_LIST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [BUILD_MAP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BUILD_SET] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BUILD_SLICE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, + [BUILD_STRING] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, + [BUILD_TEMPLATE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BUILD_TUPLE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG }, + [CACHE] = { true, INSTR_FMT_IX, 0 }, + [CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [CALL_ALLOC_AND_ENTER_INIT] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [CALL_BOUND_METHOD_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ESCAPES_FLAG }, + [CALL_BOUND_METHOD_GENERAL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [CALL_BUILTIN_CLASS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_BUILTIN_FAST] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_BUILTIN_O] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_FUNCTION_EX] = { true, INSTR_FMT_IX, HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [CALL_INTRINSIC_1] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_INTRINSIC_2] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_ISINSTANCE] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [CALL_KW] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [CALL_KW_BOUND_METHOD] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_KW_NON_PY] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_KW_PY] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_LEN] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [CALL_LIST_APPEND] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_METHOD_DESCRIPTOR_FAST] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_METHOD_DESCRIPTOR_NOARGS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_METHOD_DESCRIPTOR_O] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_NON_PY_GENERAL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_PY_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG }, + [CALL_PY_GENERAL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [CALL_STR_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_TUPLE_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_TYPE_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [CHECK_EG_MATCH] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CHECK_EXC_MATCH] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [CLEANUP_THROW] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [COMPARE_OP] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [COMPARE_OP_FLOAT] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_EXIT_FLAG }, + [COMPARE_OP_INT] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG }, + [COMPARE_OP_STR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_EXIT_FLAG }, + [CONTAINS_OP] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CONTAINS_OP_DICT] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CONTAINS_OP_SET] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CONVERT_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [COPY] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_PURE_FLAG }, + [COPY_FREE_VARS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [DELETE_ATTR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [DELETE_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [DELETE_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [DELETE_GLOBAL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [DELETE_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [DELETE_SUBSCR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [DICT_MERGE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [DICT_UPDATE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [END_ASYNC_FOR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [END_FOR] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_NO_SAVE_IP_FLAG }, + [END_SEND] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_PURE_FLAG }, + [ENTER_EXECUTOR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [EXIT_INIT_CHECK] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [EXTENDED_ARG] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [FORMAT_SIMPLE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [FORMAT_WITH_SPEC] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [FOR_ITER] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [FOR_ITER_GEN] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, + [FOR_ITER_LIST] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ESCAPES_FLAG }, + [FOR_ITER_RANGE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG }, + [FOR_ITER_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_EXIT_FLAG | HAS_ESCAPES_FLAG }, + [GET_AITER] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [GET_ANEXT] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [GET_AWAITABLE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [GET_ITER] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [GET_LEN] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [GET_YIELD_FROM_ITER] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [IMPORT_FROM] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [IMPORT_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_CALL_FUNCTION_EX] = { true, INSTR_FMT_IX, HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_CALL_KW] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_END_ASYNC_FOR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_END_FOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG | HAS_NO_SAVE_IP_FLAG }, + [INSTRUMENTED_END_SEND] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_FOR_ITER] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_INSTRUCTION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_JUMP_BACKWARD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_JUMP_FORWARD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [INSTRUMENTED_LINE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, + [INSTRUMENTED_LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_NOT_TAKEN] = { true, INSTR_FMT_IX, 0 }, + [INSTRUMENTED_POP_ITER] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, + [INSTRUMENTED_POP_JUMP_IF_FALSE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, + [INSTRUMENTED_POP_JUMP_IF_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_POP_JUMP_IF_TRUE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, + [INSTRUMENTED_RESUME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [INTERPRETER_EXIT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, + [IS_OP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [JUMP_BACKWARD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [JUMP_BACKWARD_JIT] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [JUMP_BACKWARD_NO_INTERRUPT] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_JUMP_FLAG }, + [JUMP_BACKWARD_NO_JIT] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [JUMP_FORWARD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_JUMP_FLAG }, + [LIST_APPEND] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, + [LIST_EXTEND] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_ATTR] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_ATTR_CLASS] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_EXIT_FLAG }, + [LOAD_ATTR_CLASS_WITH_METACLASS_CHECK] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_EXIT_FLAG }, + [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG }, + [LOAD_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_ATTR_METHOD_LAZY_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG }, + [LOAD_ATTR_METHOD_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_EXIT_FLAG }, + [LOAD_ATTR_METHOD_WITH_VALUES] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG }, + [LOAD_ATTR_MODULE] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_ATTR_PROPERTY] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG }, + [LOAD_ATTR_SLOT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG }, + [LOAD_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_BUILD_CLASS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_COMMON_CONSTANT] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [LOAD_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_CONST_FLAG }, + [LOAD_CONST_IMMORTAL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_CONST_FLAG }, + [LOAD_CONST_MORTAL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_CONST_FLAG }, + [LOAD_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_PURE_FLAG }, + [LOAD_FAST_AND_CLEAR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, + [LOAD_FAST_BORROW] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_PURE_FLAG }, + [LOAD_FAST_BORROW_LOAD_FAST_BORROW] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, + [LOAD_FAST_CHECK] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, + [LOAD_FROM_DICT_OR_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_FROM_DICT_OR_GLOBALS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_GLOBAL] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_GLOBAL_BUILTIN] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, + [LOAD_GLOBAL_MODULE] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, + [LOAD_LOCALS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_SMALL_INT] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [LOAD_SPECIAL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_SUPER_ATTR_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_SUPER_ATTR_METHOD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [MAKE_CELL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [MAKE_FUNCTION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [MAP_ADD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [MATCH_CLASS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [MATCH_KEYS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [MATCH_MAPPING] = { true, INSTR_FMT_IX, 0 }, + [MATCH_SEQUENCE] = { true, INSTR_FMT_IX, 0 }, + [NOP] = { true, INSTR_FMT_IX, HAS_PURE_FLAG }, + [NOT_TAKEN] = { true, INSTR_FMT_IX, HAS_PURE_FLAG }, + [POP_EXCEPT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, + [POP_ITER] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_PURE_FLAG }, + [POP_JUMP_IF_FALSE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG }, + [POP_JUMP_IF_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG }, + [POP_JUMP_IF_NOT_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG }, + [POP_JUMP_IF_TRUE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG }, + [POP_TOP] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_PURE_FLAG }, + [PUSH_EXC_INFO] = { true, INSTR_FMT_IX, 0 }, + [PUSH_NULL] = { true, INSTR_FMT_IX, HAS_PURE_FLAG }, + [RAISE_VARARGS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [RERAISE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [RESERVED] = { true, INSTR_FMT_IX, 0 }, + [RESUME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [RESUME_CHECK] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, + [RETURN_GENERATOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, + [SEND] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [SEND_GEN] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, + [SETUP_ANNOTATIONS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [SET_ADD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [SET_FUNCTION_ATTRIBUTE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [SET_UPDATE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [STORE_ATTR] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [STORE_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IXC000, HAS_EXIT_FLAG | HAS_ESCAPES_FLAG }, + [STORE_ATTR_SLOT] = { true, INSTR_FMT_IXC000, HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ESCAPES_FLAG }, + [STORE_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ESCAPES_FLAG }, + [STORE_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ESCAPES_FLAG }, + [STORE_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG }, + [STORE_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG }, + [STORE_FAST_STORE_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG }, + [STORE_GLOBAL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [STORE_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [STORE_SLICE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [STORE_SUBSCR] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [STORE_SUBSCR_DICT] = { true, INSTR_FMT_IXC, HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [STORE_SUBSCR_LIST_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ESCAPES_FLAG }, + [SWAP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_PURE_FLAG }, + [TO_BOOL] = { true, INSTR_FMT_IXC00, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [TO_BOOL_ALWAYS_TRUE] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG | HAS_ESCAPES_FLAG }, + [TO_BOOL_BOOL] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG }, + [TO_BOOL_INT] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG | HAS_ESCAPES_FLAG }, + [TO_BOOL_LIST] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG }, + [TO_BOOL_NONE] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG }, + [TO_BOOL_STR] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG | HAS_ESCAPES_FLAG }, + [UNARY_INVERT] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [UNARY_NEGATIVE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [UNARY_NOT] = { true, INSTR_FMT_IX, HAS_PURE_FLAG }, + [UNPACK_EX] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [UNPACK_SEQUENCE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [UNPACK_SEQUENCE_LIST] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG }, + [UNPACK_SEQUENCE_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG }, + [UNPACK_SEQUENCE_TWO_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ESCAPES_FLAG }, + [WITH_EXCEPT_START] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [ANNOTATIONS_PLACEHOLDER] = { true, -1, HAS_PURE_FLAG }, + [JUMP] = { true, -1, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [JUMP_IF_FALSE] = { true, -1, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [JUMP_IF_TRUE] = { true, -1, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [JUMP_NO_INTERRUPT] = { true, -1, HAS_ARG_FLAG | HAS_JUMP_FLAG }, + [LOAD_CLOSURE] = { true, -1, HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_PURE_FLAG }, + [POP_BLOCK] = { true, -1, HAS_PURE_FLAG }, + [SETUP_CLEANUP] = { true, -1, HAS_PURE_FLAG | HAS_ARG_FLAG }, + [SETUP_FINALLY] = { true, -1, HAS_PURE_FLAG | HAS_ARG_FLAG }, + [SETUP_WITH] = { true, -1, HAS_PURE_FLAG | HAS_ARG_FLAG }, + [STORE_FAST_MAYBE_NULL] = { true, -1, HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG }, +}; +#endif + +#define MAX_UOP_PER_EXPANSION 10 +struct opcode_macro_expansion { + int nuops; + struct { int16_t uop; int8_t size; int8_t offset; } uops[MAX_UOP_PER_EXPANSION]; +}; +extern const struct opcode_macro_expansion _PyOpcode_macro_expansion[256]; + +#ifdef NEED_OPCODE_METADATA +const struct opcode_macro_expansion +_PyOpcode_macro_expansion[256] = { + [BINARY_OP] = { .nuops = 1, .uops = { { _BINARY_OP, OPARG_SIMPLE, 4 } } }, + [BINARY_OP_ADD_FLOAT] = { .nuops = 3, .uops = { { _GUARD_TOS_FLOAT, OPARG_SIMPLE, 0 }, { _GUARD_NOS_FLOAT, OPARG_SIMPLE, 0 }, { _BINARY_OP_ADD_FLOAT, OPARG_SIMPLE, 5 } } }, + [BINARY_OP_ADD_INT] = { .nuops = 3, .uops = { { _GUARD_TOS_INT, OPARG_SIMPLE, 0 }, { _GUARD_NOS_INT, OPARG_SIMPLE, 0 }, { _BINARY_OP_ADD_INT, OPARG_SIMPLE, 5 } } }, + [BINARY_OP_ADD_UNICODE] = { .nuops = 3, .uops = { { _GUARD_TOS_UNICODE, OPARG_SIMPLE, 0 }, { _GUARD_NOS_UNICODE, OPARG_SIMPLE, 0 }, { _BINARY_OP_ADD_UNICODE, OPARG_SIMPLE, 5 } } }, + [BINARY_OP_EXTEND] = { .nuops = 2, .uops = { { _GUARD_BINARY_OP_EXTEND, 4, 1 }, { _BINARY_OP_EXTEND, 4, 1 } } }, + [BINARY_OP_INPLACE_ADD_UNICODE] = { .nuops = 3, .uops = { { _GUARD_TOS_UNICODE, OPARG_SIMPLE, 0 }, { _GUARD_NOS_UNICODE, OPARG_SIMPLE, 0 }, { _BINARY_OP_INPLACE_ADD_UNICODE, OPARG_SIMPLE, 5 } } }, + [BINARY_OP_MULTIPLY_FLOAT] = { .nuops = 3, .uops = { { _GUARD_TOS_FLOAT, OPARG_SIMPLE, 0 }, { _GUARD_NOS_FLOAT, OPARG_SIMPLE, 0 }, { _BINARY_OP_MULTIPLY_FLOAT, OPARG_SIMPLE, 5 } } }, + [BINARY_OP_MULTIPLY_INT] = { .nuops = 3, .uops = { { _GUARD_TOS_INT, OPARG_SIMPLE, 0 }, { _GUARD_NOS_INT, OPARG_SIMPLE, 0 }, { _BINARY_OP_MULTIPLY_INT, OPARG_SIMPLE, 5 } } }, + [BINARY_OP_SUBSCR_DICT] = { .nuops = 2, .uops = { { _GUARD_NOS_DICT, OPARG_SIMPLE, 0 }, { _BINARY_OP_SUBSCR_DICT, OPARG_SIMPLE, 5 } } }, + [BINARY_OP_SUBSCR_GETITEM] = { .nuops = 4, .uops = { { _CHECK_PEP_523, OPARG_SIMPLE, 5 }, { _BINARY_OP_SUBSCR_CHECK_FUNC, OPARG_SIMPLE, 5 }, { _BINARY_OP_SUBSCR_INIT_CALL, OPARG_SIMPLE, 5 }, { _PUSH_FRAME, OPARG_SIMPLE, 5 } } }, + [BINARY_OP_SUBSCR_LIST_INT] = { .nuops = 3, .uops = { { _GUARD_TOS_INT, OPARG_SIMPLE, 0 }, { _GUARD_NOS_LIST, OPARG_SIMPLE, 0 }, { _BINARY_OP_SUBSCR_LIST_INT, OPARG_SIMPLE, 5 } } }, + [BINARY_OP_SUBSCR_LIST_SLICE] = { .nuops = 3, .uops = { { _GUARD_TOS_SLICE, OPARG_SIMPLE, 0 }, { _GUARD_NOS_LIST, OPARG_SIMPLE, 0 }, { _BINARY_OP_SUBSCR_LIST_SLICE, OPARG_SIMPLE, 5 } } }, + [BINARY_OP_SUBSCR_STR_INT] = { .nuops = 3, .uops = { { _GUARD_TOS_INT, OPARG_SIMPLE, 0 }, { _GUARD_NOS_UNICODE, OPARG_SIMPLE, 0 }, { _BINARY_OP_SUBSCR_STR_INT, OPARG_SIMPLE, 5 } } }, + [BINARY_OP_SUBSCR_TUPLE_INT] = { .nuops = 3, .uops = { { _GUARD_TOS_INT, OPARG_SIMPLE, 0 }, { _GUARD_NOS_TUPLE, OPARG_SIMPLE, 0 }, { _BINARY_OP_SUBSCR_TUPLE_INT, OPARG_SIMPLE, 5 } } }, + [BINARY_OP_SUBTRACT_FLOAT] = { .nuops = 3, .uops = { { _GUARD_TOS_FLOAT, OPARG_SIMPLE, 0 }, { _GUARD_NOS_FLOAT, OPARG_SIMPLE, 0 }, { _BINARY_OP_SUBTRACT_FLOAT, OPARG_SIMPLE, 5 } } }, + [BINARY_OP_SUBTRACT_INT] = { .nuops = 3, .uops = { { _GUARD_TOS_INT, OPARG_SIMPLE, 0 }, { _GUARD_NOS_INT, OPARG_SIMPLE, 0 }, { _BINARY_OP_SUBTRACT_INT, OPARG_SIMPLE, 5 } } }, + [BINARY_SLICE] = { .nuops = 1, .uops = { { _BINARY_SLICE, OPARG_SIMPLE, 0 } } }, + [BUILD_INTERPOLATION] = { .nuops = 1, .uops = { { _BUILD_INTERPOLATION, OPARG_SIMPLE, 0 } } }, + [BUILD_LIST] = { .nuops = 1, .uops = { { _BUILD_LIST, OPARG_SIMPLE, 0 } } }, + [BUILD_MAP] = { .nuops = 1, .uops = { { _BUILD_MAP, OPARG_SIMPLE, 0 } } }, + [BUILD_SET] = { .nuops = 1, .uops = { { _BUILD_SET, OPARG_SIMPLE, 0 } } }, + [BUILD_SLICE] = { .nuops = 1, .uops = { { _BUILD_SLICE, OPARG_SIMPLE, 0 } } }, + [BUILD_STRING] = { .nuops = 1, .uops = { { _BUILD_STRING, OPARG_SIMPLE, 0 } } }, + [BUILD_TEMPLATE] = { .nuops = 1, .uops = { { _BUILD_TEMPLATE, OPARG_SIMPLE, 0 } } }, + [BUILD_TUPLE] = { .nuops = 1, .uops = { { _BUILD_TUPLE, OPARG_SIMPLE, 0 } } }, + [CALL_ALLOC_AND_ENTER_INIT] = { .nuops = 4, .uops = { { _CHECK_PEP_523, OPARG_SIMPLE, 1 }, { _CHECK_AND_ALLOCATE_OBJECT, 2, 1 }, { _CREATE_INIT_FRAME, OPARG_SIMPLE, 3 }, { _PUSH_FRAME, OPARG_SIMPLE, 3 } } }, + [CALL_BOUND_METHOD_EXACT_ARGS] = { .nuops = 10, .uops = { { _CHECK_PEP_523, OPARG_SIMPLE, 1 }, { _CHECK_CALL_BOUND_METHOD_EXACT_ARGS, OPARG_SIMPLE, 1 }, { _INIT_CALL_BOUND_METHOD_EXACT_ARGS, OPARG_SIMPLE, 1 }, { _CHECK_FUNCTION_VERSION, 2, 1 }, { _CHECK_FUNCTION_EXACT_ARGS, OPARG_SIMPLE, 3 }, { _CHECK_STACK_SPACE, OPARG_SIMPLE, 3 }, { _CHECK_RECURSION_REMAINING, OPARG_SIMPLE, 3 }, { _INIT_CALL_PY_EXACT_ARGS, OPARG_SIMPLE, 3 }, { _SAVE_RETURN_OFFSET, OPARG_SAVE_RETURN_OFFSET, 3 }, { _PUSH_FRAME, OPARG_SIMPLE, 3 } } }, + [CALL_BOUND_METHOD_GENERAL] = { .nuops = 7, .uops = { { _CHECK_PEP_523, OPARG_SIMPLE, 1 }, { _CHECK_METHOD_VERSION, 2, 1 }, { _EXPAND_METHOD, OPARG_SIMPLE, 3 }, { _CHECK_RECURSION_REMAINING, OPARG_SIMPLE, 3 }, { _PY_FRAME_GENERAL, OPARG_SIMPLE, 3 }, { _SAVE_RETURN_OFFSET, OPARG_SAVE_RETURN_OFFSET, 3 }, { _PUSH_FRAME, OPARG_SIMPLE, 3 } } }, + [CALL_BUILTIN_CLASS] = { .nuops = 2, .uops = { { _CALL_BUILTIN_CLASS, OPARG_SIMPLE, 3 }, { _CHECK_PERIODIC, OPARG_SIMPLE, 3 } } }, + [CALL_BUILTIN_FAST] = { .nuops = 2, .uops = { { _CALL_BUILTIN_FAST, OPARG_SIMPLE, 3 }, { _CHECK_PERIODIC, OPARG_SIMPLE, 3 } } }, + [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { .nuops = 2, .uops = { { _CALL_BUILTIN_FAST_WITH_KEYWORDS, OPARG_SIMPLE, 3 }, { _CHECK_PERIODIC, OPARG_SIMPLE, 3 } } }, + [CALL_BUILTIN_O] = { .nuops = 2, .uops = { { _CALL_BUILTIN_O, OPARG_SIMPLE, 3 }, { _CHECK_PERIODIC, OPARG_SIMPLE, 3 } } }, + [CALL_INTRINSIC_1] = { .nuops = 1, .uops = { { _CALL_INTRINSIC_1, OPARG_SIMPLE, 0 } } }, + [CALL_INTRINSIC_2] = { .nuops = 1, .uops = { { _CALL_INTRINSIC_2, OPARG_SIMPLE, 0 } } }, + [CALL_ISINSTANCE] = { .nuops = 1, .uops = { { _CALL_ISINSTANCE, OPARG_SIMPLE, 3 } } }, + [CALL_KW_BOUND_METHOD] = { .nuops = 6, .uops = { { _CHECK_PEP_523, OPARG_SIMPLE, 1 }, { _CHECK_METHOD_VERSION_KW, 2, 1 }, { _EXPAND_METHOD_KW, OPARG_SIMPLE, 3 }, { _PY_FRAME_KW, OPARG_SIMPLE, 3 }, { _SAVE_RETURN_OFFSET, OPARG_SAVE_RETURN_OFFSET, 3 }, { _PUSH_FRAME, OPARG_SIMPLE, 3 } } }, + [CALL_KW_NON_PY] = { .nuops = 3, .uops = { { _CHECK_IS_NOT_PY_CALLABLE_KW, OPARG_SIMPLE, 3 }, { _CALL_KW_NON_PY, OPARG_SIMPLE, 3 }, { _CHECK_PERIODIC, OPARG_SIMPLE, 3 } } }, + [CALL_KW_PY] = { .nuops = 6, .uops = { { _CHECK_PEP_523, OPARG_SIMPLE, 1 }, { _CHECK_FUNCTION_VERSION_KW, 2, 1 }, { _CHECK_RECURSION_REMAINING, OPARG_SIMPLE, 3 }, { _PY_FRAME_KW, OPARG_SIMPLE, 3 }, { _SAVE_RETURN_OFFSET, OPARG_SAVE_RETURN_OFFSET, 3 }, { _PUSH_FRAME, OPARG_SIMPLE, 3 } } }, + [CALL_LEN] = { .nuops = 3, .uops = { { _GUARD_NOS_NULL, OPARG_SIMPLE, 3 }, { _GUARD_CALLABLE_LEN, OPARG_SIMPLE, 3 }, { _CALL_LEN, OPARG_SIMPLE, 3 } } }, + [CALL_LIST_APPEND] = { .nuops = 1, .uops = { { _CALL_LIST_APPEND, OPARG_SIMPLE, 3 } } }, + [CALL_METHOD_DESCRIPTOR_FAST] = { .nuops = 2, .uops = { { _CALL_METHOD_DESCRIPTOR_FAST, OPARG_SIMPLE, 3 }, { _CHECK_PERIODIC, OPARG_SIMPLE, 3 } } }, + [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = { .nuops = 2, .uops = { { _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS, OPARG_SIMPLE, 3 }, { _CHECK_PERIODIC, OPARG_SIMPLE, 3 } } }, + [CALL_METHOD_DESCRIPTOR_NOARGS] = { .nuops = 2, .uops = { { _CALL_METHOD_DESCRIPTOR_NOARGS, OPARG_SIMPLE, 3 }, { _CHECK_PERIODIC, OPARG_SIMPLE, 3 } } }, + [CALL_METHOD_DESCRIPTOR_O] = { .nuops = 2, .uops = { { _CALL_METHOD_DESCRIPTOR_O, OPARG_SIMPLE, 3 }, { _CHECK_PERIODIC, OPARG_SIMPLE, 3 } } }, + [CALL_NON_PY_GENERAL] = { .nuops = 3, .uops = { { _CHECK_IS_NOT_PY_CALLABLE, OPARG_SIMPLE, 3 }, { _CALL_NON_PY_GENERAL, OPARG_SIMPLE, 3 }, { _CHECK_PERIODIC, OPARG_SIMPLE, 3 } } }, + [CALL_PY_EXACT_ARGS] = { .nuops = 8, .uops = { { _CHECK_PEP_523, OPARG_SIMPLE, 1 }, { _CHECK_FUNCTION_VERSION, 2, 1 }, { _CHECK_FUNCTION_EXACT_ARGS, OPARG_SIMPLE, 3 }, { _CHECK_STACK_SPACE, OPARG_SIMPLE, 3 }, { _CHECK_RECURSION_REMAINING, OPARG_SIMPLE, 3 }, { _INIT_CALL_PY_EXACT_ARGS, OPARG_SIMPLE, 3 }, { _SAVE_RETURN_OFFSET, OPARG_SAVE_RETURN_OFFSET, 3 }, { _PUSH_FRAME, OPARG_SIMPLE, 3 } } }, + [CALL_PY_GENERAL] = { .nuops = 6, .uops = { { _CHECK_PEP_523, OPARG_SIMPLE, 1 }, { _CHECK_FUNCTION_VERSION, 2, 1 }, { _CHECK_RECURSION_REMAINING, OPARG_SIMPLE, 3 }, { _PY_FRAME_GENERAL, OPARG_SIMPLE, 3 }, { _SAVE_RETURN_OFFSET, OPARG_SAVE_RETURN_OFFSET, 3 }, { _PUSH_FRAME, OPARG_SIMPLE, 3 } } }, + [CALL_STR_1] = { .nuops = 4, .uops = { { _GUARD_NOS_NULL, OPARG_SIMPLE, 3 }, { _GUARD_CALLABLE_STR_1, OPARG_SIMPLE, 3 }, { _CALL_STR_1, OPARG_SIMPLE, 3 }, { _CHECK_PERIODIC, OPARG_SIMPLE, 3 } } }, + [CALL_TUPLE_1] = { .nuops = 4, .uops = { { _GUARD_NOS_NULL, OPARG_SIMPLE, 3 }, { _GUARD_CALLABLE_TUPLE_1, OPARG_SIMPLE, 3 }, { _CALL_TUPLE_1, OPARG_SIMPLE, 3 }, { _CHECK_PERIODIC, OPARG_SIMPLE, 3 } } }, + [CALL_TYPE_1] = { .nuops = 3, .uops = { { _GUARD_NOS_NULL, OPARG_SIMPLE, 3 }, { _GUARD_CALLABLE_TYPE_1, OPARG_SIMPLE, 3 }, { _CALL_TYPE_1, OPARG_SIMPLE, 3 } } }, + [CHECK_EG_MATCH] = { .nuops = 1, .uops = { { _CHECK_EG_MATCH, OPARG_SIMPLE, 0 } } }, + [CHECK_EXC_MATCH] = { .nuops = 1, .uops = { { _CHECK_EXC_MATCH, OPARG_SIMPLE, 0 } } }, + [COMPARE_OP] = { .nuops = 1, .uops = { { _COMPARE_OP, OPARG_SIMPLE, 0 } } }, + [COMPARE_OP_FLOAT] = { .nuops = 3, .uops = { { _GUARD_TOS_FLOAT, OPARG_SIMPLE, 0 }, { _GUARD_NOS_FLOAT, OPARG_SIMPLE, 0 }, { _COMPARE_OP_FLOAT, OPARG_SIMPLE, 1 } } }, + [COMPARE_OP_INT] = { .nuops = 3, .uops = { { _GUARD_TOS_INT, OPARG_SIMPLE, 0 }, { _GUARD_NOS_INT, OPARG_SIMPLE, 0 }, { _COMPARE_OP_INT, OPARG_SIMPLE, 1 } } }, + [COMPARE_OP_STR] = { .nuops = 3, .uops = { { _GUARD_TOS_UNICODE, OPARG_SIMPLE, 0 }, { _GUARD_NOS_UNICODE, OPARG_SIMPLE, 0 }, { _COMPARE_OP_STR, OPARG_SIMPLE, 1 } } }, + [CONTAINS_OP] = { .nuops = 1, .uops = { { _CONTAINS_OP, OPARG_SIMPLE, 0 } } }, + [CONTAINS_OP_DICT] = { .nuops = 2, .uops = { { _GUARD_TOS_DICT, OPARG_SIMPLE, 0 }, { _CONTAINS_OP_DICT, OPARG_SIMPLE, 1 } } }, + [CONTAINS_OP_SET] = { .nuops = 2, .uops = { { _GUARD_TOS_ANY_SET, OPARG_SIMPLE, 0 }, { _CONTAINS_OP_SET, OPARG_SIMPLE, 1 } } }, + [CONVERT_VALUE] = { .nuops = 1, .uops = { { _CONVERT_VALUE, OPARG_SIMPLE, 0 } } }, + [COPY] = { .nuops = 1, .uops = { { _COPY, OPARG_SIMPLE, 0 } } }, + [COPY_FREE_VARS] = { .nuops = 1, .uops = { { _COPY_FREE_VARS, OPARG_SIMPLE, 0 } } }, + [DELETE_ATTR] = { .nuops = 1, .uops = { { _DELETE_ATTR, OPARG_SIMPLE, 0 } } }, + [DELETE_DEREF] = { .nuops = 1, .uops = { { _DELETE_DEREF, OPARG_SIMPLE, 0 } } }, + [DELETE_FAST] = { .nuops = 1, .uops = { { _DELETE_FAST, OPARG_SIMPLE, 0 } } }, + [DELETE_GLOBAL] = { .nuops = 1, .uops = { { _DELETE_GLOBAL, OPARG_SIMPLE, 0 } } }, + [DELETE_NAME] = { .nuops = 1, .uops = { { _DELETE_NAME, OPARG_SIMPLE, 0 } } }, + [DELETE_SUBSCR] = { .nuops = 1, .uops = { { _DELETE_SUBSCR, OPARG_SIMPLE, 0 } } }, + [DICT_MERGE] = { .nuops = 1, .uops = { { _DICT_MERGE, OPARG_SIMPLE, 0 } } }, + [DICT_UPDATE] = { .nuops = 1, .uops = { { _DICT_UPDATE, OPARG_SIMPLE, 0 } } }, + [END_FOR] = { .nuops = 1, .uops = { { _END_FOR, OPARG_SIMPLE, 0 } } }, + [END_SEND] = { .nuops = 1, .uops = { { _END_SEND, OPARG_SIMPLE, 0 } } }, + [EXIT_INIT_CHECK] = { .nuops = 1, .uops = { { _EXIT_INIT_CHECK, OPARG_SIMPLE, 0 } } }, + [FORMAT_SIMPLE] = { .nuops = 1, .uops = { { _FORMAT_SIMPLE, OPARG_SIMPLE, 0 } } }, + [FORMAT_WITH_SPEC] = { .nuops = 1, .uops = { { _FORMAT_WITH_SPEC, OPARG_SIMPLE, 0 } } }, + [FOR_ITER] = { .nuops = 1, .uops = { { _FOR_ITER, OPARG_REPLACED, 0 } } }, + [FOR_ITER_GEN] = { .nuops = 3, .uops = { { _CHECK_PEP_523, OPARG_SIMPLE, 1 }, { _FOR_ITER_GEN_FRAME, OPARG_SIMPLE, 1 }, { _PUSH_FRAME, OPARG_SIMPLE, 1 } } }, + [FOR_ITER_LIST] = { .nuops = 3, .uops = { { _ITER_CHECK_LIST, OPARG_SIMPLE, 1 }, { _ITER_JUMP_LIST, OPARG_REPLACED, 1 }, { _ITER_NEXT_LIST, OPARG_REPLACED, 1 } } }, + [FOR_ITER_RANGE] = { .nuops = 3, .uops = { { _ITER_CHECK_RANGE, OPARG_SIMPLE, 1 }, { _ITER_JUMP_RANGE, OPARG_REPLACED, 1 }, { _ITER_NEXT_RANGE, OPARG_SIMPLE, 1 } } }, + [FOR_ITER_TUPLE] = { .nuops = 3, .uops = { { _ITER_CHECK_TUPLE, OPARG_SIMPLE, 1 }, { _ITER_JUMP_TUPLE, OPARG_REPLACED, 1 }, { _ITER_NEXT_TUPLE, OPARG_SIMPLE, 1 } } }, + [GET_AITER] = { .nuops = 1, .uops = { { _GET_AITER, OPARG_SIMPLE, 0 } } }, + [GET_ANEXT] = { .nuops = 1, .uops = { { _GET_ANEXT, OPARG_SIMPLE, 0 } } }, + [GET_AWAITABLE] = { .nuops = 1, .uops = { { _GET_AWAITABLE, OPARG_SIMPLE, 0 } } }, + [GET_ITER] = { .nuops = 1, .uops = { { _GET_ITER, OPARG_SIMPLE, 0 } } }, + [GET_LEN] = { .nuops = 1, .uops = { { _GET_LEN, OPARG_SIMPLE, 0 } } }, + [GET_YIELD_FROM_ITER] = { .nuops = 1, .uops = { { _GET_YIELD_FROM_ITER, OPARG_SIMPLE, 0 } } }, + [IMPORT_FROM] = { .nuops = 1, .uops = { { _IMPORT_FROM, OPARG_SIMPLE, 0 } } }, + [IMPORT_NAME] = { .nuops = 1, .uops = { { _IMPORT_NAME, OPARG_SIMPLE, 0 } } }, + [IS_OP] = { .nuops = 1, .uops = { { _IS_OP, OPARG_SIMPLE, 0 } } }, + [LIST_APPEND] = { .nuops = 1, .uops = { { _LIST_APPEND, OPARG_SIMPLE, 0 } } }, + [LIST_EXTEND] = { .nuops = 1, .uops = { { _LIST_EXTEND, OPARG_SIMPLE, 0 } } }, + [LOAD_ATTR] = { .nuops = 1, .uops = { { _LOAD_ATTR, OPARG_SIMPLE, 8 } } }, + [LOAD_ATTR_CLASS] = { .nuops = 3, .uops = { { _CHECK_ATTR_CLASS, 2, 1 }, { _LOAD_ATTR_CLASS, 4, 5 }, { _PUSH_NULL_CONDITIONAL, OPARG_SIMPLE, 9 } } }, + [LOAD_ATTR_CLASS_WITH_METACLASS_CHECK] = { .nuops = 4, .uops = { { _CHECK_ATTR_CLASS, 2, 1 }, { _GUARD_TYPE_VERSION, 2, 3 }, { _LOAD_ATTR_CLASS, 4, 5 }, { _PUSH_NULL_CONDITIONAL, OPARG_SIMPLE, 9 } } }, + [LOAD_ATTR_INSTANCE_VALUE] = { .nuops = 4, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _CHECK_MANAGED_OBJECT_HAS_VALUES, OPARG_SIMPLE, 3 }, { _LOAD_ATTR_INSTANCE_VALUE, 1, 3 }, { _PUSH_NULL_CONDITIONAL, OPARG_SIMPLE, 9 } } }, + [LOAD_ATTR_METHOD_LAZY_DICT] = { .nuops = 3, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _CHECK_ATTR_METHOD_LAZY_DICT, 1, 3 }, { _LOAD_ATTR_METHOD_LAZY_DICT, 4, 5 } } }, + [LOAD_ATTR_METHOD_NO_DICT] = { .nuops = 2, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _LOAD_ATTR_METHOD_NO_DICT, 4, 5 } } }, + [LOAD_ATTR_METHOD_WITH_VALUES] = { .nuops = 4, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT, OPARG_SIMPLE, 3 }, { _GUARD_KEYS_VERSION, 2, 3 }, { _LOAD_ATTR_METHOD_WITH_VALUES, 4, 5 } } }, + [LOAD_ATTR_MODULE] = { .nuops = 3, .uops = { { _LOAD_ATTR_MODULE, 2, 1 }, { _LOAD_ATTR_MODULE, OPERAND1_1, 3 }, { _PUSH_NULL_CONDITIONAL, OPARG_SIMPLE, 9 } } }, + [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = { .nuops = 2, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _LOAD_ATTR_NONDESCRIPTOR_NO_DICT, 4, 5 } } }, + [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { .nuops = 4, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT, OPARG_SIMPLE, 3 }, { _GUARD_KEYS_VERSION, 2, 3 }, { _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES, 4, 5 } } }, + [LOAD_ATTR_PROPERTY] = { .nuops = 5, .uops = { { _CHECK_PEP_523, OPARG_SIMPLE, 1 }, { _GUARD_TYPE_VERSION, 2, 1 }, { _LOAD_ATTR_PROPERTY_FRAME, 4, 5 }, { _SAVE_RETURN_OFFSET, OPARG_SAVE_RETURN_OFFSET, 9 }, { _PUSH_FRAME, OPARG_SIMPLE, 9 } } }, + [LOAD_ATTR_SLOT] = { .nuops = 3, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _LOAD_ATTR_SLOT, 1, 3 }, { _PUSH_NULL_CONDITIONAL, OPARG_SIMPLE, 9 } } }, + [LOAD_ATTR_WITH_HINT] = { .nuops = 3, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _LOAD_ATTR_WITH_HINT, 1, 3 }, { _PUSH_NULL_CONDITIONAL, OPARG_SIMPLE, 9 } } }, + [LOAD_BUILD_CLASS] = { .nuops = 1, .uops = { { _LOAD_BUILD_CLASS, OPARG_SIMPLE, 0 } } }, + [LOAD_COMMON_CONSTANT] = { .nuops = 1, .uops = { { _LOAD_COMMON_CONSTANT, OPARG_SIMPLE, 0 } } }, + [LOAD_CONST_IMMORTAL] = { .nuops = 1, .uops = { { _LOAD_CONST_IMMORTAL, OPARG_SIMPLE, 0 } } }, + [LOAD_CONST_MORTAL] = { .nuops = 1, .uops = { { _LOAD_CONST_MORTAL, OPARG_SIMPLE, 0 } } }, + [LOAD_DEREF] = { .nuops = 1, .uops = { { _LOAD_DEREF, OPARG_SIMPLE, 0 } } }, + [LOAD_FAST] = { .nuops = 1, .uops = { { _LOAD_FAST, OPARG_SIMPLE, 0 } } }, + [LOAD_FAST_AND_CLEAR] = { .nuops = 1, .uops = { { _LOAD_FAST_AND_CLEAR, OPARG_SIMPLE, 0 } } }, + [LOAD_FAST_BORROW] = { .nuops = 1, .uops = { { _LOAD_FAST_BORROW, OPARG_SIMPLE, 0 } } }, + [LOAD_FAST_BORROW_LOAD_FAST_BORROW] = { .nuops = 2, .uops = { { _LOAD_FAST_BORROW, OPARG_TOP, 0 }, { _LOAD_FAST_BORROW, OPARG_BOTTOM, 0 } } }, + [LOAD_FAST_CHECK] = { .nuops = 1, .uops = { { _LOAD_FAST_CHECK, OPARG_SIMPLE, 0 } } }, + [LOAD_FAST_LOAD_FAST] = { .nuops = 2, .uops = { { _LOAD_FAST, OPARG_TOP, 0 }, { _LOAD_FAST, OPARG_BOTTOM, 0 } } }, + [LOAD_FROM_DICT_OR_DEREF] = { .nuops = 1, .uops = { { _LOAD_FROM_DICT_OR_DEREF, OPARG_SIMPLE, 0 } } }, + [LOAD_GLOBAL] = { .nuops = 2, .uops = { { _LOAD_GLOBAL, OPARG_SIMPLE, 3 }, { _PUSH_NULL_CONDITIONAL, OPARG_SIMPLE, 3 } } }, + [LOAD_GLOBAL_BUILTIN] = { .nuops = 4, .uops = { { _GUARD_GLOBALS_VERSION, 1, 1 }, { _LOAD_GLOBAL_BUILTINS, 1, 2 }, { _LOAD_GLOBAL_BUILTINS, OPERAND1_1, 3 }, { _PUSH_NULL_CONDITIONAL, OPARG_SIMPLE, 4 } } }, + [LOAD_GLOBAL_MODULE] = { .nuops = 4, .uops = { { _NOP, OPARG_SIMPLE, 1 }, { _LOAD_GLOBAL_MODULE, 1, 1 }, { _LOAD_GLOBAL_MODULE, OPERAND1_1, 3 }, { _PUSH_NULL_CONDITIONAL, OPARG_SIMPLE, 4 } } }, + [LOAD_LOCALS] = { .nuops = 1, .uops = { { _LOAD_LOCALS, OPARG_SIMPLE, 0 } } }, + [LOAD_NAME] = { .nuops = 1, .uops = { { _LOAD_NAME, OPARG_SIMPLE, 0 } } }, + [LOAD_SMALL_INT] = { .nuops = 1, .uops = { { _LOAD_SMALL_INT, OPARG_SIMPLE, 0 } } }, + [LOAD_SPECIAL] = { .nuops = 2, .uops = { { _INSERT_NULL, OPARG_SIMPLE, 0 }, { _LOAD_SPECIAL, OPARG_SIMPLE, 0 } } }, + [LOAD_SUPER_ATTR_ATTR] = { .nuops = 1, .uops = { { _LOAD_SUPER_ATTR_ATTR, OPARG_SIMPLE, 1 } } }, + [LOAD_SUPER_ATTR_METHOD] = { .nuops = 1, .uops = { { _LOAD_SUPER_ATTR_METHOD, OPARG_SIMPLE, 1 } } }, + [MAKE_CELL] = { .nuops = 1, .uops = { { _MAKE_CELL, OPARG_SIMPLE, 0 } } }, + [MAKE_FUNCTION] = { .nuops = 1, .uops = { { _MAKE_FUNCTION, OPARG_SIMPLE, 0 } } }, + [MAP_ADD] = { .nuops = 1, .uops = { { _MAP_ADD, OPARG_SIMPLE, 0 } } }, + [MATCH_CLASS] = { .nuops = 1, .uops = { { _MATCH_CLASS, OPARG_SIMPLE, 0 } } }, + [MATCH_KEYS] = { .nuops = 1, .uops = { { _MATCH_KEYS, OPARG_SIMPLE, 0 } } }, + [MATCH_MAPPING] = { .nuops = 1, .uops = { { _MATCH_MAPPING, OPARG_SIMPLE, 0 } } }, + [MATCH_SEQUENCE] = { .nuops = 1, .uops = { { _MATCH_SEQUENCE, OPARG_SIMPLE, 0 } } }, + [NOP] = { .nuops = 1, .uops = { { _NOP, OPARG_SIMPLE, 0 } } }, + [NOT_TAKEN] = { .nuops = 1, .uops = { { _NOP, OPARG_SIMPLE, 0 } } }, + [POP_EXCEPT] = { .nuops = 1, .uops = { { _POP_EXCEPT, OPARG_SIMPLE, 0 } } }, + [POP_ITER] = { .nuops = 1, .uops = { { _POP_TOP, OPARG_SIMPLE, 0 } } }, + [POP_JUMP_IF_FALSE] = { .nuops = 1, .uops = { { _POP_JUMP_IF_FALSE, OPARG_REPLACED, 1 } } }, + [POP_JUMP_IF_NONE] = { .nuops = 2, .uops = { { _IS_NONE, OPARG_SIMPLE, 1 }, { _POP_JUMP_IF_TRUE, OPARG_REPLACED, 1 } } }, + [POP_JUMP_IF_NOT_NONE] = { .nuops = 2, .uops = { { _IS_NONE, OPARG_SIMPLE, 1 }, { _POP_JUMP_IF_FALSE, OPARG_REPLACED, 1 } } }, + [POP_JUMP_IF_TRUE] = { .nuops = 1, .uops = { { _POP_JUMP_IF_TRUE, OPARG_REPLACED, 1 } } }, + [POP_TOP] = { .nuops = 1, .uops = { { _POP_TOP, OPARG_SIMPLE, 0 } } }, + [PUSH_EXC_INFO] = { .nuops = 1, .uops = { { _PUSH_EXC_INFO, OPARG_SIMPLE, 0 } } }, + [PUSH_NULL] = { .nuops = 1, .uops = { { _PUSH_NULL, OPARG_SIMPLE, 0 } } }, + [RESUME_CHECK] = { .nuops = 1, .uops = { { _RESUME_CHECK, OPARG_SIMPLE, 0 } } }, + [RETURN_GENERATOR] = { .nuops = 1, .uops = { { _RETURN_GENERATOR, OPARG_SIMPLE, 0 } } }, + [RETURN_VALUE] = { .nuops = 1, .uops = { { _RETURN_VALUE, OPARG_SIMPLE, 0 } } }, + [SEND_GEN] = { .nuops = 3, .uops = { { _CHECK_PEP_523, OPARG_SIMPLE, 1 }, { _SEND_GEN_FRAME, OPARG_SIMPLE, 1 }, { _PUSH_FRAME, OPARG_SIMPLE, 1 } } }, + [SETUP_ANNOTATIONS] = { .nuops = 1, .uops = { { _SETUP_ANNOTATIONS, OPARG_SIMPLE, 0 } } }, + [SET_ADD] = { .nuops = 1, .uops = { { _SET_ADD, OPARG_SIMPLE, 0 } } }, + [SET_FUNCTION_ATTRIBUTE] = { .nuops = 1, .uops = { { _SET_FUNCTION_ATTRIBUTE, OPARG_SIMPLE, 0 } } }, + [SET_UPDATE] = { .nuops = 1, .uops = { { _SET_UPDATE, OPARG_SIMPLE, 0 } } }, + [STORE_ATTR] = { .nuops = 1, .uops = { { _STORE_ATTR, OPARG_SIMPLE, 3 } } }, + [STORE_ATTR_INSTANCE_VALUE] = { .nuops = 3, .uops = { { _GUARD_TYPE_VERSION_AND_LOCK, 2, 1 }, { _GUARD_DORV_NO_DICT, OPARG_SIMPLE, 3 }, { _STORE_ATTR_INSTANCE_VALUE, 1, 3 } } }, + [STORE_ATTR_SLOT] = { .nuops = 2, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _STORE_ATTR_SLOT, 1, 3 } } }, + [STORE_ATTR_WITH_HINT] = { .nuops = 2, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _STORE_ATTR_WITH_HINT, 1, 3 } } }, + [STORE_DEREF] = { .nuops = 1, .uops = { { _STORE_DEREF, OPARG_SIMPLE, 0 } } }, + [STORE_FAST] = { .nuops = 1, .uops = { { _STORE_FAST, OPARG_SIMPLE, 0 } } }, + [STORE_FAST_LOAD_FAST] = { .nuops = 2, .uops = { { _STORE_FAST, OPARG_TOP, 0 }, { _LOAD_FAST, OPARG_BOTTOM, 0 } } }, + [STORE_FAST_STORE_FAST] = { .nuops = 2, .uops = { { _STORE_FAST, OPARG_TOP, 0 }, { _STORE_FAST, OPARG_BOTTOM, 0 } } }, + [STORE_GLOBAL] = { .nuops = 1, .uops = { { _STORE_GLOBAL, OPARG_SIMPLE, 0 } } }, + [STORE_NAME] = { .nuops = 1, .uops = { { _STORE_NAME, OPARG_SIMPLE, 0 } } }, + [STORE_SLICE] = { .nuops = 1, .uops = { { _STORE_SLICE, OPARG_SIMPLE, 0 } } }, + [STORE_SUBSCR] = { .nuops = 1, .uops = { { _STORE_SUBSCR, OPARG_SIMPLE, 0 } } }, + [STORE_SUBSCR_DICT] = { .nuops = 2, .uops = { { _GUARD_NOS_DICT, OPARG_SIMPLE, 0 }, { _STORE_SUBSCR_DICT, OPARG_SIMPLE, 1 } } }, + [STORE_SUBSCR_LIST_INT] = { .nuops = 3, .uops = { { _GUARD_TOS_INT, OPARG_SIMPLE, 0 }, { _GUARD_NOS_LIST, OPARG_SIMPLE, 0 }, { _STORE_SUBSCR_LIST_INT, OPARG_SIMPLE, 1 } } }, + [SWAP] = { .nuops = 1, .uops = { { _SWAP, OPARG_SIMPLE, 0 } } }, + [TO_BOOL] = { .nuops = 1, .uops = { { _TO_BOOL, OPARG_SIMPLE, 2 } } }, + [TO_BOOL_ALWAYS_TRUE] = { .nuops = 2, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _REPLACE_WITH_TRUE, OPARG_SIMPLE, 3 } } }, + [TO_BOOL_BOOL] = { .nuops = 1, .uops = { { _TO_BOOL_BOOL, OPARG_SIMPLE, 3 } } }, + [TO_BOOL_INT] = { .nuops = 1, .uops = { { _TO_BOOL_INT, OPARG_SIMPLE, 3 } } }, + [TO_BOOL_LIST] = { .nuops = 2, .uops = { { _GUARD_TOS_LIST, OPARG_SIMPLE, 0 }, { _TO_BOOL_LIST, OPARG_SIMPLE, 3 } } }, + [TO_BOOL_NONE] = { .nuops = 1, .uops = { { _TO_BOOL_NONE, OPARG_SIMPLE, 3 } } }, + [TO_BOOL_STR] = { .nuops = 2, .uops = { { _GUARD_TOS_UNICODE, OPARG_SIMPLE, 0 }, { _TO_BOOL_STR, OPARG_SIMPLE, 3 } } }, + [UNARY_INVERT] = { .nuops = 1, .uops = { { _UNARY_INVERT, OPARG_SIMPLE, 0 } } }, + [UNARY_NEGATIVE] = { .nuops = 1, .uops = { { _UNARY_NEGATIVE, OPARG_SIMPLE, 0 } } }, + [UNARY_NOT] = { .nuops = 1, .uops = { { _UNARY_NOT, OPARG_SIMPLE, 0 } } }, + [UNPACK_EX] = { .nuops = 1, .uops = { { _UNPACK_EX, OPARG_SIMPLE, 0 } } }, + [UNPACK_SEQUENCE] = { .nuops = 1, .uops = { { _UNPACK_SEQUENCE, OPARG_SIMPLE, 0 } } }, + [UNPACK_SEQUENCE_LIST] = { .nuops = 2, .uops = { { _GUARD_TOS_LIST, OPARG_SIMPLE, 0 }, { _UNPACK_SEQUENCE_LIST, OPARG_SIMPLE, 1 } } }, + [UNPACK_SEQUENCE_TUPLE] = { .nuops = 2, .uops = { { _GUARD_TOS_TUPLE, OPARG_SIMPLE, 0 }, { _UNPACK_SEQUENCE_TUPLE, OPARG_SIMPLE, 1 } } }, + [UNPACK_SEQUENCE_TWO_TUPLE] = { .nuops = 2, .uops = { { _GUARD_TOS_TUPLE, OPARG_SIMPLE, 0 }, { _UNPACK_SEQUENCE_TWO_TUPLE, OPARG_SIMPLE, 1 } } }, + [WITH_EXCEPT_START] = { .nuops = 1, .uops = { { _WITH_EXCEPT_START, OPARG_SIMPLE, 0 } } }, + [YIELD_VALUE] = { .nuops = 1, .uops = { { _YIELD_VALUE, OPARG_SIMPLE, 0 } } }, +}; +#endif // NEED_OPCODE_METADATA + +extern const char *_PyOpcode_OpName[267]; +#ifdef NEED_OPCODE_METADATA +const char *_PyOpcode_OpName[267] = { + [ANNOTATIONS_PLACEHOLDER] = "ANNOTATIONS_PLACEHOLDER", + [BINARY_OP] = "BINARY_OP", + [BINARY_OP_ADD_FLOAT] = "BINARY_OP_ADD_FLOAT", + [BINARY_OP_ADD_INT] = "BINARY_OP_ADD_INT", + [BINARY_OP_ADD_UNICODE] = "BINARY_OP_ADD_UNICODE", + [BINARY_OP_EXTEND] = "BINARY_OP_EXTEND", + [BINARY_OP_INPLACE_ADD_UNICODE] = "BINARY_OP_INPLACE_ADD_UNICODE", + [BINARY_OP_MULTIPLY_FLOAT] = "BINARY_OP_MULTIPLY_FLOAT", + [BINARY_OP_MULTIPLY_INT] = "BINARY_OP_MULTIPLY_INT", + [BINARY_OP_SUBSCR_DICT] = "BINARY_OP_SUBSCR_DICT", + [BINARY_OP_SUBSCR_GETITEM] = "BINARY_OP_SUBSCR_GETITEM", + [BINARY_OP_SUBSCR_LIST_INT] = "BINARY_OP_SUBSCR_LIST_INT", + [BINARY_OP_SUBSCR_LIST_SLICE] = "BINARY_OP_SUBSCR_LIST_SLICE", + [BINARY_OP_SUBSCR_STR_INT] = "BINARY_OP_SUBSCR_STR_INT", + [BINARY_OP_SUBSCR_TUPLE_INT] = "BINARY_OP_SUBSCR_TUPLE_INT", + [BINARY_OP_SUBTRACT_FLOAT] = "BINARY_OP_SUBTRACT_FLOAT", + [BINARY_OP_SUBTRACT_INT] = "BINARY_OP_SUBTRACT_INT", + [BINARY_SLICE] = "BINARY_SLICE", + [BUILD_INTERPOLATION] = "BUILD_INTERPOLATION", + [BUILD_LIST] = "BUILD_LIST", + [BUILD_MAP] = "BUILD_MAP", + [BUILD_SET] = "BUILD_SET", + [BUILD_SLICE] = "BUILD_SLICE", + [BUILD_STRING] = "BUILD_STRING", + [BUILD_TEMPLATE] = "BUILD_TEMPLATE", + [BUILD_TUPLE] = "BUILD_TUPLE", + [CACHE] = "CACHE", + [CALL] = "CALL", + [CALL_ALLOC_AND_ENTER_INIT] = "CALL_ALLOC_AND_ENTER_INIT", + [CALL_BOUND_METHOD_EXACT_ARGS] = "CALL_BOUND_METHOD_EXACT_ARGS", + [CALL_BOUND_METHOD_GENERAL] = "CALL_BOUND_METHOD_GENERAL", + [CALL_BUILTIN_CLASS] = "CALL_BUILTIN_CLASS", + [CALL_BUILTIN_FAST] = "CALL_BUILTIN_FAST", + [CALL_BUILTIN_FAST_WITH_KEYWORDS] = "CALL_BUILTIN_FAST_WITH_KEYWORDS", + [CALL_BUILTIN_O] = "CALL_BUILTIN_O", + [CALL_FUNCTION_EX] = "CALL_FUNCTION_EX", + [CALL_INTRINSIC_1] = "CALL_INTRINSIC_1", + [CALL_INTRINSIC_2] = "CALL_INTRINSIC_2", + [CALL_ISINSTANCE] = "CALL_ISINSTANCE", + [CALL_KW] = "CALL_KW", + [CALL_KW_BOUND_METHOD] = "CALL_KW_BOUND_METHOD", + [CALL_KW_NON_PY] = "CALL_KW_NON_PY", + [CALL_KW_PY] = "CALL_KW_PY", + [CALL_LEN] = "CALL_LEN", + [CALL_LIST_APPEND] = "CALL_LIST_APPEND", + [CALL_METHOD_DESCRIPTOR_FAST] = "CALL_METHOD_DESCRIPTOR_FAST", + [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = "CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS", + [CALL_METHOD_DESCRIPTOR_NOARGS] = "CALL_METHOD_DESCRIPTOR_NOARGS", + [CALL_METHOD_DESCRIPTOR_O] = "CALL_METHOD_DESCRIPTOR_O", + [CALL_NON_PY_GENERAL] = "CALL_NON_PY_GENERAL", + [CALL_PY_EXACT_ARGS] = "CALL_PY_EXACT_ARGS", + [CALL_PY_GENERAL] = "CALL_PY_GENERAL", + [CALL_STR_1] = "CALL_STR_1", + [CALL_TUPLE_1] = "CALL_TUPLE_1", + [CALL_TYPE_1] = "CALL_TYPE_1", + [CHECK_EG_MATCH] = "CHECK_EG_MATCH", + [CHECK_EXC_MATCH] = "CHECK_EXC_MATCH", + [CLEANUP_THROW] = "CLEANUP_THROW", + [COMPARE_OP] = "COMPARE_OP", + [COMPARE_OP_FLOAT] = "COMPARE_OP_FLOAT", + [COMPARE_OP_INT] = "COMPARE_OP_INT", + [COMPARE_OP_STR] = "COMPARE_OP_STR", + [CONTAINS_OP] = "CONTAINS_OP", + [CONTAINS_OP_DICT] = "CONTAINS_OP_DICT", + [CONTAINS_OP_SET] = "CONTAINS_OP_SET", + [CONVERT_VALUE] = "CONVERT_VALUE", + [COPY] = "COPY", + [COPY_FREE_VARS] = "COPY_FREE_VARS", + [DELETE_ATTR] = "DELETE_ATTR", + [DELETE_DEREF] = "DELETE_DEREF", + [DELETE_FAST] = "DELETE_FAST", + [DELETE_GLOBAL] = "DELETE_GLOBAL", + [DELETE_NAME] = "DELETE_NAME", + [DELETE_SUBSCR] = "DELETE_SUBSCR", + [DICT_MERGE] = "DICT_MERGE", + [DICT_UPDATE] = "DICT_UPDATE", + [END_ASYNC_FOR] = "END_ASYNC_FOR", + [END_FOR] = "END_FOR", + [END_SEND] = "END_SEND", + [ENTER_EXECUTOR] = "ENTER_EXECUTOR", + [EXIT_INIT_CHECK] = "EXIT_INIT_CHECK", + [EXTENDED_ARG] = "EXTENDED_ARG", + [FORMAT_SIMPLE] = "FORMAT_SIMPLE", + [FORMAT_WITH_SPEC] = "FORMAT_WITH_SPEC", + [FOR_ITER] = "FOR_ITER", + [FOR_ITER_GEN] = "FOR_ITER_GEN", + [FOR_ITER_LIST] = "FOR_ITER_LIST", + [FOR_ITER_RANGE] = "FOR_ITER_RANGE", + [FOR_ITER_TUPLE] = "FOR_ITER_TUPLE", + [GET_AITER] = "GET_AITER", + [GET_ANEXT] = "GET_ANEXT", + [GET_AWAITABLE] = "GET_AWAITABLE", + [GET_ITER] = "GET_ITER", + [GET_LEN] = "GET_LEN", + [GET_YIELD_FROM_ITER] = "GET_YIELD_FROM_ITER", + [IMPORT_FROM] = "IMPORT_FROM", + [IMPORT_NAME] = "IMPORT_NAME", + [INSTRUMENTED_CALL] = "INSTRUMENTED_CALL", + [INSTRUMENTED_CALL_FUNCTION_EX] = "INSTRUMENTED_CALL_FUNCTION_EX", + [INSTRUMENTED_CALL_KW] = "INSTRUMENTED_CALL_KW", + [INSTRUMENTED_END_ASYNC_FOR] = "INSTRUMENTED_END_ASYNC_FOR", + [INSTRUMENTED_END_FOR] = "INSTRUMENTED_END_FOR", + [INSTRUMENTED_END_SEND] = "INSTRUMENTED_END_SEND", + [INSTRUMENTED_FOR_ITER] = "INSTRUMENTED_FOR_ITER", + [INSTRUMENTED_INSTRUCTION] = "INSTRUMENTED_INSTRUCTION", + [INSTRUMENTED_JUMP_BACKWARD] = "INSTRUMENTED_JUMP_BACKWARD", + [INSTRUMENTED_JUMP_FORWARD] = "INSTRUMENTED_JUMP_FORWARD", + [INSTRUMENTED_LINE] = "INSTRUMENTED_LINE", + [INSTRUMENTED_LOAD_SUPER_ATTR] = "INSTRUMENTED_LOAD_SUPER_ATTR", + [INSTRUMENTED_NOT_TAKEN] = "INSTRUMENTED_NOT_TAKEN", + [INSTRUMENTED_POP_ITER] = "INSTRUMENTED_POP_ITER", + [INSTRUMENTED_POP_JUMP_IF_FALSE] = "INSTRUMENTED_POP_JUMP_IF_FALSE", + [INSTRUMENTED_POP_JUMP_IF_NONE] = "INSTRUMENTED_POP_JUMP_IF_NONE", + [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = "INSTRUMENTED_POP_JUMP_IF_NOT_NONE", + [INSTRUMENTED_POP_JUMP_IF_TRUE] = "INSTRUMENTED_POP_JUMP_IF_TRUE", + [INSTRUMENTED_RESUME] = "INSTRUMENTED_RESUME", + [INSTRUMENTED_RETURN_VALUE] = "INSTRUMENTED_RETURN_VALUE", + [INSTRUMENTED_YIELD_VALUE] = "INSTRUMENTED_YIELD_VALUE", + [INTERPRETER_EXIT] = "INTERPRETER_EXIT", + [IS_OP] = "IS_OP", + [JUMP] = "JUMP", + [JUMP_BACKWARD] = "JUMP_BACKWARD", + [JUMP_BACKWARD_JIT] = "JUMP_BACKWARD_JIT", + [JUMP_BACKWARD_NO_INTERRUPT] = "JUMP_BACKWARD_NO_INTERRUPT", + [JUMP_BACKWARD_NO_JIT] = "JUMP_BACKWARD_NO_JIT", + [JUMP_FORWARD] = "JUMP_FORWARD", + [JUMP_IF_FALSE] = "JUMP_IF_FALSE", + [JUMP_IF_TRUE] = "JUMP_IF_TRUE", + [JUMP_NO_INTERRUPT] = "JUMP_NO_INTERRUPT", + [LIST_APPEND] = "LIST_APPEND", + [LIST_EXTEND] = "LIST_EXTEND", + [LOAD_ATTR] = "LOAD_ATTR", + [LOAD_ATTR_CLASS] = "LOAD_ATTR_CLASS", + [LOAD_ATTR_CLASS_WITH_METACLASS_CHECK] = "LOAD_ATTR_CLASS_WITH_METACLASS_CHECK", + [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = "LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN", + [LOAD_ATTR_INSTANCE_VALUE] = "LOAD_ATTR_INSTANCE_VALUE", + [LOAD_ATTR_METHOD_LAZY_DICT] = "LOAD_ATTR_METHOD_LAZY_DICT", + [LOAD_ATTR_METHOD_NO_DICT] = "LOAD_ATTR_METHOD_NO_DICT", + [LOAD_ATTR_METHOD_WITH_VALUES] = "LOAD_ATTR_METHOD_WITH_VALUES", + [LOAD_ATTR_MODULE] = "LOAD_ATTR_MODULE", + [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = "LOAD_ATTR_NONDESCRIPTOR_NO_DICT", + [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = "LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES", + [LOAD_ATTR_PROPERTY] = "LOAD_ATTR_PROPERTY", + [LOAD_ATTR_SLOT] = "LOAD_ATTR_SLOT", + [LOAD_ATTR_WITH_HINT] = "LOAD_ATTR_WITH_HINT", + [LOAD_BUILD_CLASS] = "LOAD_BUILD_CLASS", + [LOAD_CLOSURE] = "LOAD_CLOSURE", + [LOAD_COMMON_CONSTANT] = "LOAD_COMMON_CONSTANT", + [LOAD_CONST] = "LOAD_CONST", + [LOAD_CONST_IMMORTAL] = "LOAD_CONST_IMMORTAL", + [LOAD_CONST_MORTAL] = "LOAD_CONST_MORTAL", + [LOAD_DEREF] = "LOAD_DEREF", + [LOAD_FAST] = "LOAD_FAST", + [LOAD_FAST_AND_CLEAR] = "LOAD_FAST_AND_CLEAR", + [LOAD_FAST_BORROW] = "LOAD_FAST_BORROW", + [LOAD_FAST_BORROW_LOAD_FAST_BORROW] = "LOAD_FAST_BORROW_LOAD_FAST_BORROW", + [LOAD_FAST_CHECK] = "LOAD_FAST_CHECK", + [LOAD_FAST_LOAD_FAST] = "LOAD_FAST_LOAD_FAST", + [LOAD_FROM_DICT_OR_DEREF] = "LOAD_FROM_DICT_OR_DEREF", + [LOAD_FROM_DICT_OR_GLOBALS] = "LOAD_FROM_DICT_OR_GLOBALS", + [LOAD_GLOBAL] = "LOAD_GLOBAL", + [LOAD_GLOBAL_BUILTIN] = "LOAD_GLOBAL_BUILTIN", + [LOAD_GLOBAL_MODULE] = "LOAD_GLOBAL_MODULE", + [LOAD_LOCALS] = "LOAD_LOCALS", + [LOAD_NAME] = "LOAD_NAME", + [LOAD_SMALL_INT] = "LOAD_SMALL_INT", + [LOAD_SPECIAL] = "LOAD_SPECIAL", + [LOAD_SUPER_ATTR] = "LOAD_SUPER_ATTR", + [LOAD_SUPER_ATTR_ATTR] = "LOAD_SUPER_ATTR_ATTR", + [LOAD_SUPER_ATTR_METHOD] = "LOAD_SUPER_ATTR_METHOD", + [MAKE_CELL] = "MAKE_CELL", + [MAKE_FUNCTION] = "MAKE_FUNCTION", + [MAP_ADD] = "MAP_ADD", + [MATCH_CLASS] = "MATCH_CLASS", + [MATCH_KEYS] = "MATCH_KEYS", + [MATCH_MAPPING] = "MATCH_MAPPING", + [MATCH_SEQUENCE] = "MATCH_SEQUENCE", + [NOP] = "NOP", + [NOT_TAKEN] = "NOT_TAKEN", + [POP_BLOCK] = "POP_BLOCK", + [POP_EXCEPT] = "POP_EXCEPT", + [POP_ITER] = "POP_ITER", + [POP_JUMP_IF_FALSE] = "POP_JUMP_IF_FALSE", + [POP_JUMP_IF_NONE] = "POP_JUMP_IF_NONE", + [POP_JUMP_IF_NOT_NONE] = "POP_JUMP_IF_NOT_NONE", + [POP_JUMP_IF_TRUE] = "POP_JUMP_IF_TRUE", + [POP_TOP] = "POP_TOP", + [PUSH_EXC_INFO] = "PUSH_EXC_INFO", + [PUSH_NULL] = "PUSH_NULL", + [RAISE_VARARGS] = "RAISE_VARARGS", + [RERAISE] = "RERAISE", + [RESERVED] = "RESERVED", + [RESUME] = "RESUME", + [RESUME_CHECK] = "RESUME_CHECK", + [RETURN_GENERATOR] = "RETURN_GENERATOR", + [RETURN_VALUE] = "RETURN_VALUE", + [SEND] = "SEND", + [SEND_GEN] = "SEND_GEN", + [SETUP_ANNOTATIONS] = "SETUP_ANNOTATIONS", + [SETUP_CLEANUP] = "SETUP_CLEANUP", + [SETUP_FINALLY] = "SETUP_FINALLY", + [SETUP_WITH] = "SETUP_WITH", + [SET_ADD] = "SET_ADD", + [SET_FUNCTION_ATTRIBUTE] = "SET_FUNCTION_ATTRIBUTE", + [SET_UPDATE] = "SET_UPDATE", + [STORE_ATTR] = "STORE_ATTR", + [STORE_ATTR_INSTANCE_VALUE] = "STORE_ATTR_INSTANCE_VALUE", + [STORE_ATTR_SLOT] = "STORE_ATTR_SLOT", + [STORE_ATTR_WITH_HINT] = "STORE_ATTR_WITH_HINT", + [STORE_DEREF] = "STORE_DEREF", + [STORE_FAST] = "STORE_FAST", + [STORE_FAST_LOAD_FAST] = "STORE_FAST_LOAD_FAST", + [STORE_FAST_MAYBE_NULL] = "STORE_FAST_MAYBE_NULL", + [STORE_FAST_STORE_FAST] = "STORE_FAST_STORE_FAST", + [STORE_GLOBAL] = "STORE_GLOBAL", + [STORE_NAME] = "STORE_NAME", + [STORE_SLICE] = "STORE_SLICE", + [STORE_SUBSCR] = "STORE_SUBSCR", + [STORE_SUBSCR_DICT] = "STORE_SUBSCR_DICT", + [STORE_SUBSCR_LIST_INT] = "STORE_SUBSCR_LIST_INT", + [SWAP] = "SWAP", + [TO_BOOL] = "TO_BOOL", + [TO_BOOL_ALWAYS_TRUE] = "TO_BOOL_ALWAYS_TRUE", + [TO_BOOL_BOOL] = "TO_BOOL_BOOL", + [TO_BOOL_INT] = "TO_BOOL_INT", + [TO_BOOL_LIST] = "TO_BOOL_LIST", + [TO_BOOL_NONE] = "TO_BOOL_NONE", + [TO_BOOL_STR] = "TO_BOOL_STR", + [UNARY_INVERT] = "UNARY_INVERT", + [UNARY_NEGATIVE] = "UNARY_NEGATIVE", + [UNARY_NOT] = "UNARY_NOT", + [UNPACK_EX] = "UNPACK_EX", + [UNPACK_SEQUENCE] = "UNPACK_SEQUENCE", + [UNPACK_SEQUENCE_LIST] = "UNPACK_SEQUENCE_LIST", + [UNPACK_SEQUENCE_TUPLE] = "UNPACK_SEQUENCE_TUPLE", + [UNPACK_SEQUENCE_TWO_TUPLE] = "UNPACK_SEQUENCE_TWO_TUPLE", + [WITH_EXCEPT_START] = "WITH_EXCEPT_START", + [YIELD_VALUE] = "YIELD_VALUE", +}; +#endif + +extern const uint8_t _PyOpcode_Caches[256]; +#ifdef NEED_OPCODE_METADATA +const uint8_t _PyOpcode_Caches[256] = { + [TO_BOOL] = 3, + [STORE_SUBSCR] = 1, + [SEND] = 1, + [UNPACK_SEQUENCE] = 1, + [STORE_ATTR] = 4, + [LOAD_GLOBAL] = 4, + [LOAD_SUPER_ATTR] = 1, + [LOAD_ATTR] = 9, + [COMPARE_OP] = 1, + [CONTAINS_OP] = 1, + [JUMP_BACKWARD] = 1, + [POP_JUMP_IF_TRUE] = 1, + [POP_JUMP_IF_FALSE] = 1, + [POP_JUMP_IF_NONE] = 1, + [POP_JUMP_IF_NOT_NONE] = 1, + [FOR_ITER] = 1, + [CALL] = 3, + [CALL_KW] = 3, + [BINARY_OP] = 5, +}; +#endif + +extern const uint8_t _PyOpcode_Deopt[256]; +#ifdef NEED_OPCODE_METADATA +const uint8_t _PyOpcode_Deopt[256] = { + [121] = 121, + [122] = 122, + [123] = 123, + [124] = 124, + [125] = 125, + [126] = 126, + [127] = 127, + [212] = 212, + [213] = 213, + [214] = 214, + [215] = 215, + [216] = 216, + [217] = 217, + [218] = 218, + [219] = 219, + [220] = 220, + [221] = 221, + [222] = 222, + [223] = 223, + [224] = 224, + [225] = 225, + [226] = 226, + [227] = 227, + [228] = 228, + [229] = 229, + [230] = 230, + [231] = 231, + [232] = 232, + [233] = 233, + [BINARY_OP] = BINARY_OP, + [BINARY_OP_ADD_FLOAT] = BINARY_OP, + [BINARY_OP_ADD_INT] = BINARY_OP, + [BINARY_OP_ADD_UNICODE] = BINARY_OP, + [BINARY_OP_EXTEND] = BINARY_OP, + [BINARY_OP_INPLACE_ADD_UNICODE] = BINARY_OP, + [BINARY_OP_MULTIPLY_FLOAT] = BINARY_OP, + [BINARY_OP_MULTIPLY_INT] = BINARY_OP, + [BINARY_OP_SUBSCR_DICT] = BINARY_OP, + [BINARY_OP_SUBSCR_GETITEM] = BINARY_OP, + [BINARY_OP_SUBSCR_LIST_INT] = BINARY_OP, + [BINARY_OP_SUBSCR_LIST_SLICE] = BINARY_OP, + [BINARY_OP_SUBSCR_STR_INT] = BINARY_OP, + [BINARY_OP_SUBSCR_TUPLE_INT] = BINARY_OP, + [BINARY_OP_SUBTRACT_FLOAT] = BINARY_OP, + [BINARY_OP_SUBTRACT_INT] = BINARY_OP, + [BINARY_SLICE] = BINARY_SLICE, + [BUILD_INTERPOLATION] = BUILD_INTERPOLATION, + [BUILD_LIST] = BUILD_LIST, + [BUILD_MAP] = BUILD_MAP, + [BUILD_SET] = BUILD_SET, + [BUILD_SLICE] = BUILD_SLICE, + [BUILD_STRING] = BUILD_STRING, + [BUILD_TEMPLATE] = BUILD_TEMPLATE, + [BUILD_TUPLE] = BUILD_TUPLE, + [CACHE] = CACHE, + [CALL] = CALL, + [CALL_ALLOC_AND_ENTER_INIT] = CALL, + [CALL_BOUND_METHOD_EXACT_ARGS] = CALL, + [CALL_BOUND_METHOD_GENERAL] = CALL, + [CALL_BUILTIN_CLASS] = CALL, + [CALL_BUILTIN_FAST] = CALL, + [CALL_BUILTIN_FAST_WITH_KEYWORDS] = CALL, + [CALL_BUILTIN_O] = CALL, + [CALL_FUNCTION_EX] = CALL_FUNCTION_EX, + [CALL_INTRINSIC_1] = CALL_INTRINSIC_1, + [CALL_INTRINSIC_2] = CALL_INTRINSIC_2, + [CALL_ISINSTANCE] = CALL, + [CALL_KW] = CALL_KW, + [CALL_KW_BOUND_METHOD] = CALL_KW, + [CALL_KW_NON_PY] = CALL_KW, + [CALL_KW_PY] = CALL_KW, + [CALL_LEN] = CALL, + [CALL_LIST_APPEND] = CALL, + [CALL_METHOD_DESCRIPTOR_FAST] = CALL, + [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = CALL, + [CALL_METHOD_DESCRIPTOR_NOARGS] = CALL, + [CALL_METHOD_DESCRIPTOR_O] = CALL, + [CALL_NON_PY_GENERAL] = CALL, + [CALL_PY_EXACT_ARGS] = CALL, + [CALL_PY_GENERAL] = CALL, + [CALL_STR_1] = CALL, + [CALL_TUPLE_1] = CALL, + [CALL_TYPE_1] = CALL, + [CHECK_EG_MATCH] = CHECK_EG_MATCH, + [CHECK_EXC_MATCH] = CHECK_EXC_MATCH, + [CLEANUP_THROW] = CLEANUP_THROW, + [COMPARE_OP] = COMPARE_OP, + [COMPARE_OP_FLOAT] = COMPARE_OP, + [COMPARE_OP_INT] = COMPARE_OP, + [COMPARE_OP_STR] = COMPARE_OP, + [CONTAINS_OP] = CONTAINS_OP, + [CONTAINS_OP_DICT] = CONTAINS_OP, + [CONTAINS_OP_SET] = CONTAINS_OP, + [CONVERT_VALUE] = CONVERT_VALUE, + [COPY] = COPY, + [COPY_FREE_VARS] = COPY_FREE_VARS, + [DELETE_ATTR] = DELETE_ATTR, + [DELETE_DEREF] = DELETE_DEREF, + [DELETE_FAST] = DELETE_FAST, + [DELETE_GLOBAL] = DELETE_GLOBAL, + [DELETE_NAME] = DELETE_NAME, + [DELETE_SUBSCR] = DELETE_SUBSCR, + [DICT_MERGE] = DICT_MERGE, + [DICT_UPDATE] = DICT_UPDATE, + [END_ASYNC_FOR] = END_ASYNC_FOR, + [END_FOR] = END_FOR, + [END_SEND] = END_SEND, + [ENTER_EXECUTOR] = ENTER_EXECUTOR, + [EXIT_INIT_CHECK] = EXIT_INIT_CHECK, + [EXTENDED_ARG] = EXTENDED_ARG, + [FORMAT_SIMPLE] = FORMAT_SIMPLE, + [FORMAT_WITH_SPEC] = FORMAT_WITH_SPEC, + [FOR_ITER] = FOR_ITER, + [FOR_ITER_GEN] = FOR_ITER, + [FOR_ITER_LIST] = FOR_ITER, + [FOR_ITER_RANGE] = FOR_ITER, + [FOR_ITER_TUPLE] = FOR_ITER, + [GET_AITER] = GET_AITER, + [GET_ANEXT] = GET_ANEXT, + [GET_AWAITABLE] = GET_AWAITABLE, + [GET_ITER] = GET_ITER, + [GET_LEN] = GET_LEN, + [GET_YIELD_FROM_ITER] = GET_YIELD_FROM_ITER, + [IMPORT_FROM] = IMPORT_FROM, + [IMPORT_NAME] = IMPORT_NAME, + [INSTRUMENTED_CALL] = INSTRUMENTED_CALL, + [INSTRUMENTED_CALL_FUNCTION_EX] = INSTRUMENTED_CALL_FUNCTION_EX, + [INSTRUMENTED_CALL_KW] = INSTRUMENTED_CALL_KW, + [INSTRUMENTED_END_ASYNC_FOR] = INSTRUMENTED_END_ASYNC_FOR, + [INSTRUMENTED_END_FOR] = INSTRUMENTED_END_FOR, + [INSTRUMENTED_END_SEND] = INSTRUMENTED_END_SEND, + [INSTRUMENTED_FOR_ITER] = INSTRUMENTED_FOR_ITER, + [INSTRUMENTED_INSTRUCTION] = INSTRUMENTED_INSTRUCTION, + [INSTRUMENTED_JUMP_BACKWARD] = INSTRUMENTED_JUMP_BACKWARD, + [INSTRUMENTED_JUMP_FORWARD] = INSTRUMENTED_JUMP_FORWARD, + [INSTRUMENTED_LINE] = INSTRUMENTED_LINE, + [INSTRUMENTED_LOAD_SUPER_ATTR] = INSTRUMENTED_LOAD_SUPER_ATTR, + [INSTRUMENTED_NOT_TAKEN] = INSTRUMENTED_NOT_TAKEN, + [INSTRUMENTED_POP_ITER] = INSTRUMENTED_POP_ITER, + [INSTRUMENTED_POP_JUMP_IF_FALSE] = INSTRUMENTED_POP_JUMP_IF_FALSE, + [INSTRUMENTED_POP_JUMP_IF_NONE] = INSTRUMENTED_POP_JUMP_IF_NONE, + [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = INSTRUMENTED_POP_JUMP_IF_NOT_NONE, + [INSTRUMENTED_POP_JUMP_IF_TRUE] = INSTRUMENTED_POP_JUMP_IF_TRUE, + [INSTRUMENTED_RESUME] = INSTRUMENTED_RESUME, + [INSTRUMENTED_RETURN_VALUE] = INSTRUMENTED_RETURN_VALUE, + [INSTRUMENTED_YIELD_VALUE] = INSTRUMENTED_YIELD_VALUE, + [INTERPRETER_EXIT] = INTERPRETER_EXIT, + [IS_OP] = IS_OP, + [JUMP_BACKWARD] = JUMP_BACKWARD, + [JUMP_BACKWARD_JIT] = JUMP_BACKWARD, + [JUMP_BACKWARD_NO_INTERRUPT] = JUMP_BACKWARD_NO_INTERRUPT, + [JUMP_BACKWARD_NO_JIT] = JUMP_BACKWARD, + [JUMP_FORWARD] = JUMP_FORWARD, + [LIST_APPEND] = LIST_APPEND, + [LIST_EXTEND] = LIST_EXTEND, + [LOAD_ATTR] = LOAD_ATTR, + [LOAD_ATTR_CLASS] = LOAD_ATTR, + [LOAD_ATTR_CLASS_WITH_METACLASS_CHECK] = LOAD_ATTR, + [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = LOAD_ATTR, + [LOAD_ATTR_INSTANCE_VALUE] = LOAD_ATTR, + [LOAD_ATTR_METHOD_LAZY_DICT] = LOAD_ATTR, + [LOAD_ATTR_METHOD_NO_DICT] = LOAD_ATTR, + [LOAD_ATTR_METHOD_WITH_VALUES] = LOAD_ATTR, + [LOAD_ATTR_MODULE] = LOAD_ATTR, + [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = LOAD_ATTR, + [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = LOAD_ATTR, + [LOAD_ATTR_PROPERTY] = LOAD_ATTR, + [LOAD_ATTR_SLOT] = LOAD_ATTR, + [LOAD_ATTR_WITH_HINT] = LOAD_ATTR, + [LOAD_BUILD_CLASS] = LOAD_BUILD_CLASS, + [LOAD_COMMON_CONSTANT] = LOAD_COMMON_CONSTANT, + [LOAD_CONST] = LOAD_CONST, + [LOAD_CONST_IMMORTAL] = LOAD_CONST, + [LOAD_CONST_MORTAL] = LOAD_CONST, + [LOAD_DEREF] = LOAD_DEREF, + [LOAD_FAST] = LOAD_FAST, + [LOAD_FAST_AND_CLEAR] = LOAD_FAST_AND_CLEAR, + [LOAD_FAST_BORROW] = LOAD_FAST_BORROW, + [LOAD_FAST_BORROW_LOAD_FAST_BORROW] = LOAD_FAST_BORROW_LOAD_FAST_BORROW, + [LOAD_FAST_CHECK] = LOAD_FAST_CHECK, + [LOAD_FAST_LOAD_FAST] = LOAD_FAST_LOAD_FAST, + [LOAD_FROM_DICT_OR_DEREF] = LOAD_FROM_DICT_OR_DEREF, + [LOAD_FROM_DICT_OR_GLOBALS] = LOAD_FROM_DICT_OR_GLOBALS, + [LOAD_GLOBAL] = LOAD_GLOBAL, + [LOAD_GLOBAL_BUILTIN] = LOAD_GLOBAL, + [LOAD_GLOBAL_MODULE] = LOAD_GLOBAL, + [LOAD_LOCALS] = LOAD_LOCALS, + [LOAD_NAME] = LOAD_NAME, + [LOAD_SMALL_INT] = LOAD_SMALL_INT, + [LOAD_SPECIAL] = LOAD_SPECIAL, + [LOAD_SUPER_ATTR] = LOAD_SUPER_ATTR, + [LOAD_SUPER_ATTR_ATTR] = LOAD_SUPER_ATTR, + [LOAD_SUPER_ATTR_METHOD] = LOAD_SUPER_ATTR, + [MAKE_CELL] = MAKE_CELL, + [MAKE_FUNCTION] = MAKE_FUNCTION, + [MAP_ADD] = MAP_ADD, + [MATCH_CLASS] = MATCH_CLASS, + [MATCH_KEYS] = MATCH_KEYS, + [MATCH_MAPPING] = MATCH_MAPPING, + [MATCH_SEQUENCE] = MATCH_SEQUENCE, + [NOP] = NOP, + [NOT_TAKEN] = NOT_TAKEN, + [POP_EXCEPT] = POP_EXCEPT, + [POP_ITER] = POP_ITER, + [POP_JUMP_IF_FALSE] = POP_JUMP_IF_FALSE, + [POP_JUMP_IF_NONE] = POP_JUMP_IF_NONE, + [POP_JUMP_IF_NOT_NONE] = POP_JUMP_IF_NOT_NONE, + [POP_JUMP_IF_TRUE] = POP_JUMP_IF_TRUE, + [POP_TOP] = POP_TOP, + [PUSH_EXC_INFO] = PUSH_EXC_INFO, + [PUSH_NULL] = PUSH_NULL, + [RAISE_VARARGS] = RAISE_VARARGS, + [RERAISE] = RERAISE, + [RESERVED] = RESERVED, + [RESUME] = RESUME, + [RESUME_CHECK] = RESUME, + [RETURN_GENERATOR] = RETURN_GENERATOR, + [RETURN_VALUE] = RETURN_VALUE, + [SEND] = SEND, + [SEND_GEN] = SEND, + [SETUP_ANNOTATIONS] = SETUP_ANNOTATIONS, + [SET_ADD] = SET_ADD, + [SET_FUNCTION_ATTRIBUTE] = SET_FUNCTION_ATTRIBUTE, + [SET_UPDATE] = SET_UPDATE, + [STORE_ATTR] = STORE_ATTR, + [STORE_ATTR_INSTANCE_VALUE] = STORE_ATTR, + [STORE_ATTR_SLOT] = STORE_ATTR, + [STORE_ATTR_WITH_HINT] = STORE_ATTR, + [STORE_DEREF] = STORE_DEREF, + [STORE_FAST] = STORE_FAST, + [STORE_FAST_LOAD_FAST] = STORE_FAST_LOAD_FAST, + [STORE_FAST_STORE_FAST] = STORE_FAST_STORE_FAST, + [STORE_GLOBAL] = STORE_GLOBAL, + [STORE_NAME] = STORE_NAME, + [STORE_SLICE] = STORE_SLICE, + [STORE_SUBSCR] = STORE_SUBSCR, + [STORE_SUBSCR_DICT] = STORE_SUBSCR, + [STORE_SUBSCR_LIST_INT] = STORE_SUBSCR, + [SWAP] = SWAP, + [TO_BOOL] = TO_BOOL, + [TO_BOOL_ALWAYS_TRUE] = TO_BOOL, + [TO_BOOL_BOOL] = TO_BOOL, + [TO_BOOL_INT] = TO_BOOL, + [TO_BOOL_LIST] = TO_BOOL, + [TO_BOOL_NONE] = TO_BOOL, + [TO_BOOL_STR] = TO_BOOL, + [UNARY_INVERT] = UNARY_INVERT, + [UNARY_NEGATIVE] = UNARY_NEGATIVE, + [UNARY_NOT] = UNARY_NOT, + [UNPACK_EX] = UNPACK_EX, + [UNPACK_SEQUENCE] = UNPACK_SEQUENCE, + [UNPACK_SEQUENCE_LIST] = UNPACK_SEQUENCE, + [UNPACK_SEQUENCE_TUPLE] = UNPACK_SEQUENCE, + [UNPACK_SEQUENCE_TWO_TUPLE] = UNPACK_SEQUENCE, + [WITH_EXCEPT_START] = WITH_EXCEPT_START, + [YIELD_VALUE] = YIELD_VALUE, +}; + +#endif // NEED_OPCODE_METADATA + +#define EXTRA_CASES \ + case 121: \ + case 122: \ + case 123: \ + case 124: \ + case 125: \ + case 126: \ + case 127: \ + case 212: \ + case 213: \ + case 214: \ + case 215: \ + case 216: \ + case 217: \ + case 218: \ + case 219: \ + case 220: \ + case 221: \ + case 222: \ + case 223: \ + case 224: \ + case 225: \ + case 226: \ + case 227: \ + case 228: \ + case 229: \ + case 230: \ + case 231: \ + case 232: \ + case 233: \ + ; +struct pseudo_targets { + uint8_t as_sequence; + uint8_t targets[4]; +}; +extern const struct pseudo_targets _PyOpcode_PseudoTargets[11]; +#ifdef NEED_OPCODE_METADATA +const struct pseudo_targets _PyOpcode_PseudoTargets[11] = { + [LOAD_CLOSURE-256] = { 0, { LOAD_FAST, 0, 0, 0 } }, + [STORE_FAST_MAYBE_NULL-256] = { 0, { STORE_FAST, 0, 0, 0 } }, + [ANNOTATIONS_PLACEHOLDER-256] = { 0, { NOP, 0, 0, 0 } }, + [JUMP-256] = { 0, { JUMP_FORWARD, JUMP_BACKWARD, 0, 0 } }, + [JUMP_NO_INTERRUPT-256] = { 0, { JUMP_FORWARD, JUMP_BACKWARD_NO_INTERRUPT, 0, 0 } }, + [JUMP_IF_FALSE-256] = { 1, { COPY, TO_BOOL, POP_JUMP_IF_FALSE, 0 } }, + [JUMP_IF_TRUE-256] = { 1, { COPY, TO_BOOL, POP_JUMP_IF_TRUE, 0 } }, + [SETUP_FINALLY-256] = { 0, { NOP, 0, 0, 0 } }, + [SETUP_CLEANUP-256] = { 0, { NOP, 0, 0, 0 } }, + [SETUP_WITH-256] = { 0, { NOP, 0, 0, 0 } }, + [POP_BLOCK-256] = { 0, { NOP, 0, 0, 0 } }, +}; + +#endif // NEED_OPCODE_METADATA +static inline bool +is_pseudo_target(int pseudo, int target) { + if (pseudo < 256 || pseudo >= 267) { + return false; + } + for (int i = 0; _PyOpcode_PseudoTargets[pseudo-256].targets[i]; i++) { + if (_PyOpcode_PseudoTargets[pseudo-256].targets[i] == target) return true; + } + return false; +} + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_CORE_OPCODE_METADATA_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_opcode_utils.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_opcode_utils.h new file mode 100644 index 0000000000000000000000000000000000000000..79a1a242556a52be650e6104198108fff5d1a2ef --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_opcode_utils.h @@ -0,0 +1,90 @@ +#ifndef Py_INTERNAL_OPCODE_UTILS_H +#define Py_INTERNAL_OPCODE_UTILS_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#define MAX_REAL_OPCODE 254 + +#define IS_WITHIN_OPCODE_RANGE(opcode) \ + (((opcode) >= 0 && (opcode) <= MAX_REAL_OPCODE) || \ + IS_PSEUDO_INSTR(opcode)) + +#define IS_BLOCK_PUSH_OPCODE(opcode) \ + ((opcode) == SETUP_FINALLY || \ + (opcode) == SETUP_WITH || \ + (opcode) == SETUP_CLEANUP) + +#define HAS_TARGET(opcode) \ + (OPCODE_HAS_JUMP(opcode) || IS_BLOCK_PUSH_OPCODE(opcode)) + +/* opcodes that must be last in the basicblock */ +#define IS_TERMINATOR_OPCODE(opcode) \ + (OPCODE_HAS_JUMP(opcode) || IS_SCOPE_EXIT_OPCODE(opcode)) + +/* opcodes which are not emitted in codegen stage, only by the assembler */ +#define IS_ASSEMBLER_OPCODE(opcode) \ + ((opcode) == JUMP_FORWARD || \ + (opcode) == JUMP_BACKWARD || \ + (opcode) == JUMP_BACKWARD_NO_INTERRUPT) + +#define IS_BACKWARDS_JUMP_OPCODE(opcode) \ + ((opcode) == JUMP_BACKWARD || \ + (opcode) == JUMP_BACKWARD_NO_INTERRUPT) + +#define IS_UNCONDITIONAL_JUMP_OPCODE(opcode) \ + ((opcode) == JUMP || \ + (opcode) == JUMP_NO_INTERRUPT || \ + (opcode) == JUMP_FORWARD || \ + (opcode) == JUMP_BACKWARD || \ + (opcode) == JUMP_BACKWARD_NO_INTERRUPT) + +#define IS_CONDITIONAL_JUMP_OPCODE(opcode) \ + ((opcode) == POP_JUMP_IF_FALSE || \ + (opcode) == POP_JUMP_IF_TRUE || \ + (opcode) == POP_JUMP_IF_NONE || \ + (opcode) == POP_JUMP_IF_NOT_NONE) + +#define IS_SCOPE_EXIT_OPCODE(opcode) \ + ((opcode) == RETURN_VALUE || \ + (opcode) == RAISE_VARARGS || \ + (opcode) == RERAISE) + +#define IS_RETURN_OPCODE(opcode) \ + (opcode == RETURN_VALUE) +#define IS_RAISE_OPCODE(opcode) \ + (opcode == RAISE_VARARGS || opcode == RERAISE) + + +/* Flags used in the oparg for MAKE_FUNCTION */ +#define MAKE_FUNCTION_DEFAULTS 0x01 +#define MAKE_FUNCTION_KWDEFAULTS 0x02 +#define MAKE_FUNCTION_ANNOTATIONS 0x04 +#define MAKE_FUNCTION_CLOSURE 0x08 +#define MAKE_FUNCTION_ANNOTATE 0x10 + +/* Values used as the oparg for LOAD_COMMON_CONSTANT */ +#define CONSTANT_ASSERTIONERROR 0 +#define CONSTANT_NOTIMPLEMENTEDERROR 1 +#define CONSTANT_BUILTIN_TUPLE 2 +#define CONSTANT_BUILTIN_ALL 3 +#define CONSTANT_BUILTIN_ANY 4 +#define NUM_COMMON_CONSTANTS 5 + +/* Values used in the oparg for RESUME */ +#define RESUME_AT_FUNC_START 0 +#define RESUME_AFTER_YIELD 1 +#define RESUME_AFTER_YIELD_FROM 2 +#define RESUME_AFTER_AWAIT 3 + +#define RESUME_OPARG_LOCATION_MASK 0x3 +#define RESUME_OPARG_DEPTH1_MASK 0x4 + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_OPCODE_UTILS_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_optimizer.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_optimizer.h new file mode 100644 index 0000000000000000000000000000000000000000..d3674726997f6afab3103c554462fda8fb71a5c8 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_optimizer.h @@ -0,0 +1,318 @@ +#ifndef Py_INTERNAL_OPTIMIZER_H +#define Py_INTERNAL_OPTIMIZER_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_typedefs.h" // _PyInterpreterFrame +#include "pycore_uop_ids.h" +#include + + +typedef struct _PyExecutorLinkListNode { + struct _PyExecutorObject *next; + struct _PyExecutorObject *previous; +} _PyExecutorLinkListNode; + + +/* Bloom filter with m = 256 + * https://en.wikipedia.org/wiki/Bloom_filter */ +#define _Py_BLOOM_FILTER_WORDS 8 + +typedef struct { + uint32_t bits[_Py_BLOOM_FILTER_WORDS]; +} _PyBloomFilter; + +typedef struct { + uint8_t opcode; + uint8_t oparg; + uint8_t valid:1; + uint8_t linked:1; + uint8_t chain_depth:6; // Must be big enough for MAX_CHAIN_DEPTH - 1. + bool warm; + int index; // Index of ENTER_EXECUTOR (if code isn't NULL, below). + _PyBloomFilter bloom; + _PyExecutorLinkListNode links; + PyCodeObject *code; // Weak (NULL if no corresponding ENTER_EXECUTOR). +} _PyVMData; + +/* Depending on the format, + * the 32 bits between the oparg and operand are: + * UOP_FORMAT_TARGET: + * uint32_t target; + * UOP_FORMAT_JUMP + * uint16_t jump_target; + * uint16_t error_target; + */ +typedef struct { + uint16_t opcode:15; + uint16_t format:1; + uint16_t oparg; + union { + uint32_t target; + struct { + uint16_t jump_target; + uint16_t error_target; + }; + }; + uint64_t operand0; // A cache entry + uint64_t operand1; +#ifdef Py_STATS + uint64_t execution_count; +#endif +} _PyUOpInstruction; + +typedef struct { + uint32_t target; + _Py_BackoffCounter temperature; + struct _PyExecutorObject *executor; +} _PyExitData; + +typedef struct _PyExecutorObject { + PyObject_VAR_HEAD + const _PyUOpInstruction *trace; + _PyVMData vm_data; /* Used by the VM, but opaque to the optimizer */ + uint32_t exit_count; + uint32_t code_size; + size_t jit_size; + void *jit_code; + void *jit_side_entry; + _PyExitData exits[1]; +} _PyExecutorObject; + +/* If pending deletion list gets large enough, then scan, + * and free any executors that aren't executing + * i.e. any that aren't a thread's current_executor. */ +#define EXECUTOR_DELETE_LIST_MAX 100 + +// Export for '_opcode' shared extension (JIT compiler). +PyAPI_FUNC(_PyExecutorObject*) _Py_GetExecutor(PyCodeObject *code, int offset); + +void _Py_ExecutorInit(_PyExecutorObject *, const _PyBloomFilter *); +void _Py_ExecutorDetach(_PyExecutorObject *); +void _Py_BloomFilter_Init(_PyBloomFilter *); +void _Py_BloomFilter_Add(_PyBloomFilter *bloom, void *obj); +PyAPI_FUNC(void) _Py_Executor_DependsOn(_PyExecutorObject *executor, void *obj); + +#define _Py_MAX_ALLOWED_BUILTINS_MODIFICATIONS 3 +#define _Py_MAX_ALLOWED_GLOBALS_MODIFICATIONS 6 + +#ifdef _Py_TIER2 +PyAPI_FUNC(void) _Py_Executors_InvalidateDependency(PyInterpreterState *interp, void *obj, int is_invalidation); +PyAPI_FUNC(void) _Py_Executors_InvalidateAll(PyInterpreterState *interp, int is_invalidation); +PyAPI_FUNC(void) _Py_Executors_InvalidateCold(PyInterpreterState *interp); + +#else +# define _Py_Executors_InvalidateDependency(A, B, C) ((void)0) +# define _Py_Executors_InvalidateAll(A, B) ((void)0) +# define _Py_Executors_InvalidateCold(A) ((void)0) + +#endif + +// Used as the threshold to trigger executor invalidation when +// trace_run_counter is greater than this value. +#define JIT_CLEANUP_THRESHOLD 100000 + +// This is the length of the trace we project initially. +#define UOP_MAX_TRACE_LENGTH 800 + +#define TRACE_STACK_SIZE 5 + +int _Py_uop_analyze_and_optimize(_PyInterpreterFrame *frame, + _PyUOpInstruction *trace, int trace_len, int curr_stackentries, + _PyBloomFilter *dependencies); + +extern PyTypeObject _PyUOpExecutor_Type; + + +#define UOP_FORMAT_TARGET 0 +#define UOP_FORMAT_JUMP 1 + +static inline uint32_t uop_get_target(const _PyUOpInstruction *inst) +{ + assert(inst->format == UOP_FORMAT_TARGET); + return inst->target; +} + +static inline uint16_t uop_get_jump_target(const _PyUOpInstruction *inst) +{ + assert(inst->format == UOP_FORMAT_JUMP); + return inst->jump_target; +} + +static inline uint16_t uop_get_error_target(const _PyUOpInstruction *inst) +{ + assert(inst->format != UOP_FORMAT_TARGET); + return inst->error_target; +} + +// Holds locals, stack, locals, stack ... co_consts (in that order) +#define MAX_ABSTRACT_INTERP_SIZE 4096 + +#define TY_ARENA_SIZE (UOP_MAX_TRACE_LENGTH * 5) + +// Need extras for root frame and for overflow frame (see TRACE_STACK_PUSH()) +#define MAX_ABSTRACT_FRAME_DEPTH (TRACE_STACK_SIZE + 2) + +// The maximum number of side exits that we can take before requiring forward +// progress (and inserting a new ENTER_EXECUTOR instruction). In practice, this +// is the "maximum amount of polymorphism" that an isolated trace tree can +// handle before rejoining the rest of the program. +#define MAX_CHAIN_DEPTH 4 + +/* Symbols */ +/* See explanation in optimizer_symbols.c */ + + +typedef enum _JitSymType { + JIT_SYM_UNKNOWN_TAG = 1, + JIT_SYM_NULL_TAG = 2, + JIT_SYM_NON_NULL_TAG = 3, + JIT_SYM_BOTTOM_TAG = 4, + JIT_SYM_TYPE_VERSION_TAG = 5, + JIT_SYM_KNOWN_CLASS_TAG = 6, + JIT_SYM_KNOWN_VALUE_TAG = 7, + JIT_SYM_TUPLE_TAG = 8, + JIT_SYM_TRUTHINESS_TAG = 9, +} JitSymType; + +typedef struct _jit_opt_known_class { + uint8_t tag; + uint32_t version; + PyTypeObject *type; +} JitOptKnownClass; + +typedef struct _jit_opt_known_version { + uint8_t tag; + uint32_t version; +} JitOptKnownVersion; + +typedef struct _jit_opt_known_value { + uint8_t tag; + PyObject *value; +} JitOptKnownValue; + +#define MAX_SYMBOLIC_TUPLE_SIZE 7 + +typedef struct _jit_opt_tuple { + uint8_t tag; + uint8_t length; + uint16_t items[MAX_SYMBOLIC_TUPLE_SIZE]; +} JitOptTuple; + +typedef struct { + uint8_t tag; + bool invert; + uint16_t value; +} JitOptTruthiness; + +typedef union _jit_opt_symbol { + uint8_t tag; + JitOptKnownClass cls; + JitOptKnownValue value; + JitOptKnownVersion version; + JitOptTuple tuple; + JitOptTruthiness truthiness; +} JitOptSymbol; + + + +struct _Py_UOpsAbstractFrame { + // Max stacklen + int stack_len; + int locals_len; + + JitOptSymbol **stack_pointer; + JitOptSymbol **stack; + JitOptSymbol **locals; +}; + +typedef struct _Py_UOpsAbstractFrame _Py_UOpsAbstractFrame; + +typedef struct ty_arena { + int ty_curr_number; + int ty_max_number; + JitOptSymbol arena[TY_ARENA_SIZE]; +} ty_arena; + +typedef struct _JitOptContext { + char done; + char out_of_space; + bool contradiction; + // The current "executing" frame. + _Py_UOpsAbstractFrame *frame; + _Py_UOpsAbstractFrame frames[MAX_ABSTRACT_FRAME_DEPTH]; + int curr_frame_depth; + + // Arena for the symbolic types. + ty_arena t_arena; + + JitOptSymbol **n_consumed; + JitOptSymbol **limit; + JitOptSymbol *locals_and_stack[MAX_ABSTRACT_INTERP_SIZE]; +} JitOptContext; + +extern bool _Py_uop_sym_is_null(JitOptSymbol *sym); +extern bool _Py_uop_sym_is_not_null(JitOptSymbol *sym); +extern bool _Py_uop_sym_is_const(JitOptContext *ctx, JitOptSymbol *sym); +extern PyObject *_Py_uop_sym_get_const(JitOptContext *ctx, JitOptSymbol *sym); +extern JitOptSymbol *_Py_uop_sym_new_unknown(JitOptContext *ctx); +extern JitOptSymbol *_Py_uop_sym_new_not_null(JitOptContext *ctx); +extern JitOptSymbol *_Py_uop_sym_new_type( + JitOptContext *ctx, PyTypeObject *typ); +extern JitOptSymbol *_Py_uop_sym_new_const(JitOptContext *ctx, PyObject *const_val); +extern JitOptSymbol *_Py_uop_sym_new_null(JitOptContext *ctx); +extern bool _Py_uop_sym_has_type(JitOptSymbol *sym); +extern bool _Py_uop_sym_matches_type(JitOptSymbol *sym, PyTypeObject *typ); +extern bool _Py_uop_sym_matches_type_version(JitOptSymbol *sym, unsigned int version); +extern void _Py_uop_sym_set_null(JitOptContext *ctx, JitOptSymbol *sym); +extern void _Py_uop_sym_set_non_null(JitOptContext *ctx, JitOptSymbol *sym); +extern void _Py_uop_sym_set_type(JitOptContext *ctx, JitOptSymbol *sym, PyTypeObject *typ); +extern bool _Py_uop_sym_set_type_version(JitOptContext *ctx, JitOptSymbol *sym, unsigned int version); +extern void _Py_uop_sym_set_const(JitOptContext *ctx, JitOptSymbol *sym, PyObject *const_val); +extern bool _Py_uop_sym_is_bottom(JitOptSymbol *sym); +extern int _Py_uop_sym_truthiness(JitOptContext *ctx, JitOptSymbol *sym); +extern PyTypeObject *_Py_uop_sym_get_type(JitOptSymbol *sym); +extern bool _Py_uop_sym_is_immortal(JitOptSymbol *sym); +extern JitOptSymbol *_Py_uop_sym_new_tuple(JitOptContext *ctx, int size, JitOptSymbol **args); +extern JitOptSymbol *_Py_uop_sym_tuple_getitem(JitOptContext *ctx, JitOptSymbol *sym, int item); +extern int _Py_uop_sym_tuple_length(JitOptSymbol *sym); +extern JitOptSymbol *_Py_uop_sym_new_truthiness(JitOptContext *ctx, JitOptSymbol *value, bool truthy); + +extern void _Py_uop_abstractcontext_init(JitOptContext *ctx); +extern void _Py_uop_abstractcontext_fini(JitOptContext *ctx); + +extern _Py_UOpsAbstractFrame *_Py_uop_frame_new( + JitOptContext *ctx, + PyCodeObject *co, + int curr_stackentries, + JitOptSymbol **args, + int arg_len); +extern int _Py_uop_frame_pop(JitOptContext *ctx); + +PyAPI_FUNC(PyObject *) _Py_uop_symbols_test(PyObject *self, PyObject *ignored); + +PyAPI_FUNC(int) _PyOptimizer_Optimize(_PyInterpreterFrame *frame, _Py_CODEUNIT *start, _PyExecutorObject **exec_ptr, int chain_depth); + +static inline int is_terminator(const _PyUOpInstruction *uop) +{ + int opcode = uop->opcode; + return ( + opcode == _EXIT_TRACE || + opcode == _JUMP_TO_TOP + ); +} + +PyAPI_FUNC(int) _PyDumpExecutors(FILE *out); +#ifdef _Py_TIER2 +extern void _Py_ClearExecutorDeletionList(PyInterpreterState *interp); +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_OPTIMIZER_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_parking_lot.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_parking_lot.h new file mode 100644 index 0000000000000000000000000000000000000000..8c9260e2636fbc7ec0396ac443bdd6fdbafb67df --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_parking_lot.h @@ -0,0 +1,97 @@ +// ParkingLot is an internal API for building efficient synchronization +// primitives like mutexes and events. +// +// The API and name is inspired by WebKit's WTF::ParkingLot, which in turn +// is inspired Linux's futex API. +// See https://webkit.org/blog/6161/locking-in-webkit/. +// +// The core functionality is an atomic "compare-and-sleep" operation along with +// an atomic "wake-up" operation. + +#ifndef Py_INTERNAL_PARKING_LOT_H +#define Py_INTERNAL_PARKING_LOT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + + +enum { + // The thread was unparked by another thread. + Py_PARK_OK = 0, + + // The value of `address` did not match `expected`. + Py_PARK_AGAIN = -1, + + // The thread was unparked due to a timeout. + Py_PARK_TIMEOUT = -2, + + // The thread was interrupted by a signal. + Py_PARK_INTR = -3, +}; + +// Checks that `*address == *expected` and puts the thread to sleep until an +// unpark operation is called on the same `address`. Otherwise, the function +// returns `Py_PARK_AGAIN`. The comparison behaves like memcmp, but is +// performed atomically with respect to unpark operations. +// +// The `address_size` argument is the size of the data pointed to by the +// `address` and `expected` pointers (i.e., sizeof(*address)). It must be +// 1, 2, 4, or 8. +// +// The `timeout_ns` argument specifies the maximum amount of time to wait, with +// -1 indicating an infinite wait. +// +// `park_arg`, which can be NULL, is passed to the unpark operation. +// +// If `detach` is true, then the thread will detach/release the GIL while +// waiting. +// +// Example usage: +// +// if (_Py_atomic_compare_exchange_uint8(address, &expected, new_value)) { +// int res = _PyParkingLot_Park(address, &new_value, sizeof(*address), +// timeout_ns, NULL, 1); +// ... +// } +PyAPI_FUNC(int) +_PyParkingLot_Park(const void *address, const void *expected, + size_t address_size, PyTime_t timeout_ns, + void *park_arg, int detach); + +// Callback for _PyParkingLot_Unpark: +// +// `arg` is the data of the same name provided to the _PyParkingLot_Unpark() +// call. +// `park_arg` is the data provided to _PyParkingLot_Park() call or NULL if +// no waiting thread was found. +// `has_more_waiters` is true if there are more threads waiting on the same +// address. May be true in cases where threads are waiting on a different +// address that map to the same internal bucket. +typedef void _Py_unpark_fn_t(void *arg, void *park_arg, int has_more_waiters); + +// Unparks a single thread waiting on `address`. +// +// Note that fn() is called regardless of whether a thread was unparked. If +// no threads are waiting on `address` then the `park_arg` argument to fn() +// will be NULL. +// +// Example usage: +// void callback(void *arg, void *park_arg, int has_more_waiters); +// _PyParkingLot_Unpark(address, &callback, arg); +PyAPI_FUNC(void) +_PyParkingLot_Unpark(const void *address, _Py_unpark_fn_t *fn, void *arg); + +// Unparks all threads waiting on `address`. +PyAPI_FUNC(void) _PyParkingLot_UnparkAll(const void *address); + +// Resets the parking lot state after a fork. Forgets all parked threads. +PyAPI_FUNC(void) _PyParkingLot_AfterFork(void); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_PARKING_LOT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_parser.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_parser.h new file mode 100644 index 0000000000000000000000000000000000000000..2885dee63dcf94b028062a196353d1fc2d02a34f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_parser.h @@ -0,0 +1,78 @@ +#ifndef Py_INTERNAL_PARSER_H +#define Py_INTERNAL_PARSER_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + + +#include "pycore_ast.h" // struct _expr +#include "pycore_global_strings.h" // _Py_DECLARE_STR() +#include "pycore_pyarena.h" // PyArena + +_Py_DECLARE_STR(empty, "") +#if defined(Py_DEBUG) && defined(Py_GIL_DISABLED) +#define _parser_runtime_state_INIT \ + { \ + .mutex = {0}, \ + .dummy_name = { \ + .kind = Name_kind, \ + .v.Name.id = &_Py_STR(empty), \ + .v.Name.ctx = Load, \ + .lineno = 1, \ + .col_offset = 0, \ + .end_lineno = 1, \ + .end_col_offset = 0, \ + }, \ + } +#else +#define _parser_runtime_state_INIT \ + { \ + .dummy_name = { \ + .kind = Name_kind, \ + .v.Name.id = &_Py_STR(empty), \ + .v.Name.ctx = Load, \ + .lineno = 1, \ + .col_offset = 0, \ + .end_lineno = 1, \ + .end_col_offset = 0, \ + }, \ + } +#endif + +extern struct _mod* _PyParser_ASTFromString( + const char *str, + PyObject* filename, + int mode, + PyCompilerFlags *flags, + PyArena *arena); + +extern struct _mod* _PyParser_ASTFromFile( + FILE *fp, + PyObject *filename_ob, + const char *enc, + int mode, + const char *ps1, + const char *ps2, + PyCompilerFlags *flags, + int *errcode, + PyArena *arena); +extern struct _mod* _PyParser_InteractiveASTFromFile( + FILE *fp, + PyObject *filename_ob, + const char *enc, + int mode, + const char *ps1, + const char *ps2, + PyCompilerFlags *flags, + int *errcode, + PyObject **interactive_src, + PyArena *arena); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_PARSER_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pathconfig.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pathconfig.h new file mode 100644 index 0000000000000000000000000000000000000000..a1ce1b19a00283292f09cdd59cb12ad2b6edaac9 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pathconfig.h @@ -0,0 +1,26 @@ +#ifndef Py_INTERNAL_PATHCONFIG_H +#define Py_INTERNAL_PATHCONFIG_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +// Export for '_testinternalcapi' shared extension +PyAPI_FUNC(void) _PyPathConfig_ClearGlobal(void); + +extern PyStatus _PyPathConfig_ReadGlobal(PyConfig *config); +extern PyStatus _PyPathConfig_UpdateGlobal(const PyConfig *config); +extern const wchar_t * _PyPathConfig_GetGlobalModuleSearchPath(void); + +extern int _PyPathConfig_ComputeSysPath0( + const PyWideStringList *argv, + PyObject **path0); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_PATHCONFIG_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pyarena.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pyarena.h new file mode 100644 index 0000000000000000000000000000000000000000..1f07479fb2ca27ff2adcf2c6e1f9fa3a75096a61 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pyarena.h @@ -0,0 +1,68 @@ +// An arena-like memory interface for the compiler. + +#ifndef Py_INTERNAL_PYARENA_H +#define Py_INTERNAL_PYARENA_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +typedef struct _arena PyArena; + +// _PyArena_New() and _PyArena_Free() create a new arena and free it, +// respectively. Once an arena has been created, it can be used +// to allocate memory via _PyArena_Malloc(). Pointers to PyObject can +// also be registered with the arena via _PyArena_AddPyObject(), and the +// arena will ensure that the PyObjects stay alive at least until +// _PyArena_Free() is called. When an arena is freed, all the memory it +// allocated is freed, the arena releases internal references to registered +// PyObject*, and none of its pointers are valid. +// XXX (tim) What does "none of its pointers are valid" mean? Does it +// XXX mean that pointers previously obtained via _PyArena_Malloc() are +// XXX no longer valid? (That's clearly true, but not sure that's what +// XXX the text is trying to say.) +// +// _PyArena_New() returns an arena pointer. On error, it +// returns a negative number and sets an exception. +// XXX (tim): Not true. On error, _PyArena_New() actually returns NULL, +// XXX and looks like it may or may not set an exception (e.g., if the +// XXX internal PyList_New(0) returns NULL, _PyArena_New() passes that on +// XXX and an exception is set; OTOH, if the internal +// XXX block_new(DEFAULT_BLOCK_SIZE) returns NULL, that's passed on but +// XXX an exception is not set in that case). +// +// Export for test_peg_generator +PyAPI_FUNC(PyArena*) _PyArena_New(void); + +// Export for test_peg_generator +PyAPI_FUNC(void) _PyArena_Free(PyArena *); + +// Mostly like malloc(), return the address of a block of memory spanning +// `size` bytes, or return NULL (without setting an exception) if enough +// new memory can't be obtained. Unlike malloc(0), _PyArena_Malloc() with +// size=0 does not guarantee to return a unique pointer (the pointer +// returned may equal one or more other pointers obtained from +// _PyArena_Malloc()). +// Note that pointers obtained via _PyArena_Malloc() must never be passed to +// the system free() or realloc(), or to any of Python's similar memory- +// management functions. _PyArena_Malloc()-obtained pointers remain valid +// until _PyArena_Free(ar) is called, at which point all pointers obtained +// from the arena `ar` become invalid simultaneously. +// +// Export for test_peg_generator +PyAPI_FUNC(void*) _PyArena_Malloc(PyArena *, size_t size); + +// This routine isn't a proper arena allocation routine. It takes +// a PyObject* and records it so that it can be DECREFed when the +// arena is freed. +// +// Export for test_peg_generator +PyAPI_FUNC(int) _PyArena_AddPyObject(PyArena *, PyObject *); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_PYARENA_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pyatomic_ft_wrappers.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pyatomic_ft_wrappers.h new file mode 100644 index 0000000000000000000000000000000000000000..be0335a2389c0af19aaaecbb968c9767d81b040b --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pyatomic_ft_wrappers.h @@ -0,0 +1,187 @@ +// This header file provides wrappers around the atomic operations found in +// `pyatomic.h` that are only atomic in free-threaded builds. +// +// These are intended to be used in places where atomics are required in +// free-threaded builds, but not in the default build, and we don't want to +// introduce the potential performance overhead of an atomic operation in the +// default build. +// +// All usages of these macros should be replaced with unconditionally atomic or +// non-atomic versions, and this file should be removed, once the dust settles +// on free threading. +#ifndef Py_ATOMIC_FT_WRAPPERS_H +#define Py_ATOMIC_FT_WRAPPERS_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +#error "this header requires Py_BUILD_CORE define" +#endif + +#ifdef Py_GIL_DISABLED +#define FT_ATOMIC_LOAD_PTR(value) _Py_atomic_load_ptr(&value) +#define FT_ATOMIC_STORE_PTR(value, new_value) _Py_atomic_store_ptr(&value, new_value) +#define FT_ATOMIC_LOAD_SSIZE(value) _Py_atomic_load_ssize(&value) +#define FT_ATOMIC_LOAD_SSIZE_ACQUIRE(value) \ + _Py_atomic_load_ssize_acquire(&value) +#define FT_ATOMIC_LOAD_SSIZE_RELAXED(value) \ + _Py_atomic_load_ssize_relaxed(&value) +#define FT_ATOMIC_STORE_PTR(value, new_value) \ + _Py_atomic_store_ptr(&value, new_value) +#define FT_ATOMIC_LOAD_PTR_ACQUIRE(value) \ + _Py_atomic_load_ptr_acquire(&value) +#define FT_ATOMIC_LOAD_PTR_CONSUME(value) \ + _Py_atomic_load_ptr_consume(&value) +#define FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(value) \ + _Py_atomic_load_uintptr_acquire(&value) +#define FT_ATOMIC_LOAD_PTR_RELAXED(value) \ + _Py_atomic_load_ptr_relaxed(&value) +#define FT_ATOMIC_LOAD_UINT8(value) \ + _Py_atomic_load_uint8(&value) +#define FT_ATOMIC_STORE_UINT8(value, new_value) \ + _Py_atomic_store_uint8(&value, new_value) +#define FT_ATOMIC_LOAD_UINT8_RELAXED(value) \ + _Py_atomic_load_uint8_relaxed(&value) +#define FT_ATOMIC_LOAD_UINT16_RELAXED(value) \ + _Py_atomic_load_uint16_relaxed(&value) +#define FT_ATOMIC_LOAD_UINT32_RELAXED(value) \ + _Py_atomic_load_uint32_relaxed(&value) +#define FT_ATOMIC_LOAD_ULONG_RELAXED(value) \ + _Py_atomic_load_ulong_relaxed(&value) +#define FT_ATOMIC_STORE_PTR_RELAXED(value, new_value) \ + _Py_atomic_store_ptr_relaxed(&value, new_value) +#define FT_ATOMIC_STORE_PTR_RELEASE(value, new_value) \ + _Py_atomic_store_ptr_release(&value, new_value) +#define FT_ATOMIC_STORE_UINTPTR_RELEASE(value, new_value) \ + _Py_atomic_store_uintptr_release(&value, new_value) +#define FT_ATOMIC_STORE_SSIZE_RELAXED(value, new_value) \ + _Py_atomic_store_ssize_relaxed(&value, new_value) +#define FT_ATOMIC_STORE_UINT8_RELAXED(value, new_value) \ + _Py_atomic_store_uint8_relaxed(&value, new_value) +#define FT_ATOMIC_STORE_UINT16_RELAXED(value, new_value) \ + _Py_atomic_store_uint16_relaxed(&value, new_value) +#define FT_ATOMIC_STORE_UINT32_RELAXED(value, new_value) \ + _Py_atomic_store_uint32_relaxed(&value, new_value) +#define FT_ATOMIC_STORE_CHAR_RELAXED(value, new_value) \ + _Py_atomic_store_char_relaxed(&value, new_value) +#define FT_ATOMIC_LOAD_CHAR_RELAXED(value) \ + _Py_atomic_load_char_relaxed(&value) +#define FT_ATOMIC_STORE_UCHAR_RELAXED(value, new_value) \ + _Py_atomic_store_uchar_relaxed(&value, new_value) +#define FT_ATOMIC_LOAD_UCHAR_RELAXED(value) \ + _Py_atomic_load_uchar_relaxed(&value) +#define FT_ATOMIC_STORE_SHORT_RELAXED(value, new_value) \ + _Py_atomic_store_short_relaxed(&value, new_value) +#define FT_ATOMIC_LOAD_SHORT_RELAXED(value) \ + _Py_atomic_load_short_relaxed(&value) +#define FT_ATOMIC_STORE_USHORT_RELAXED(value, new_value) \ + _Py_atomic_store_ushort_relaxed(&value, new_value) +#define FT_ATOMIC_LOAD_USHORT_RELAXED(value) \ + _Py_atomic_load_ushort_relaxed(&value) +#define FT_ATOMIC_LOAD_INT(value) \ + _Py_atomic_load_int(&value) +#define FT_ATOMIC_STORE_INT(value, new_value) \ + _Py_atomic_store_int(&value, new_value) +#define FT_ATOMIC_STORE_INT_RELAXED(value, new_value) \ + _Py_atomic_store_int_relaxed(&value, new_value) +#define FT_ATOMIC_LOAD_INT_RELAXED(value) \ + _Py_atomic_load_int_relaxed(&value) +#define FT_ATOMIC_LOAD_UINT(value) \ + _Py_atomic_load_uint(&value) +#define FT_ATOMIC_STORE_UINT_RELAXED(value, new_value) \ + _Py_atomic_store_uint_relaxed(&value, new_value) +#define FT_ATOMIC_LOAD_UINT_RELAXED(value) \ + _Py_atomic_load_uint_relaxed(&value) +#define FT_ATOMIC_STORE_LONG_RELAXED(value, new_value) \ + _Py_atomic_store_long_relaxed(&value, new_value) +#define FT_ATOMIC_LOAD_LONG_RELAXED(value) \ + _Py_atomic_load_long_relaxed(&value) +#define FT_ATOMIC_STORE_ULONG_RELAXED(value, new_value) \ + _Py_atomic_store_ulong_relaxed(&value, new_value) +#define FT_ATOMIC_STORE_SSIZE_RELAXED(value, new_value) \ + _Py_atomic_store_ssize_relaxed(&value, new_value) +#define FT_ATOMIC_STORE_SSIZE_RELEASE(value, new_value) \ + _Py_atomic_store_ssize_release(&value, new_value) +#define FT_ATOMIC_STORE_FLOAT_RELAXED(value, new_value) \ + _Py_atomic_store_float_relaxed(&value, new_value) +#define FT_ATOMIC_LOAD_FLOAT_RELAXED(value) \ + _Py_atomic_load_float_relaxed(&value) +#define FT_ATOMIC_STORE_DOUBLE_RELAXED(value, new_value) \ + _Py_atomic_store_double_relaxed(&value, new_value) +#define FT_ATOMIC_LOAD_DOUBLE_RELAXED(value) \ + _Py_atomic_load_double_relaxed(&value) +#define FT_ATOMIC_STORE_LLONG_RELAXED(value, new_value) \ + _Py_atomic_store_llong_relaxed(&value, new_value) +#define FT_ATOMIC_LOAD_LLONG_RELAXED(value) \ + _Py_atomic_load_llong_relaxed(&value) +#define FT_ATOMIC_STORE_ULLONG_RELAXED(value, new_value) \ + _Py_atomic_store_ullong_relaxed(&value, new_value) +#define FT_ATOMIC_LOAD_ULLONG_RELAXED(value) \ + _Py_atomic_load_ullong_relaxed(&value) +#define FT_ATOMIC_ADD_SSIZE(value, new_value) \ + (void)_Py_atomic_add_ssize(&value, new_value) +#define FT_MUTEX_LOCK(lock) PyMutex_Lock(lock) +#define FT_MUTEX_UNLOCK(lock) PyMutex_Unlock(lock) + +#else +#define FT_ATOMIC_LOAD_PTR(value) value +#define FT_ATOMIC_STORE_PTR(value, new_value) value = new_value +#define FT_ATOMIC_LOAD_SSIZE(value) value +#define FT_ATOMIC_LOAD_SSIZE_ACQUIRE(value) value +#define FT_ATOMIC_LOAD_SSIZE_RELAXED(value) value +#define FT_ATOMIC_LOAD_PTR_ACQUIRE(value) value +#define FT_ATOMIC_LOAD_PTR_CONSUME(value) value +#define FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(value) value +#define FT_ATOMIC_LOAD_PTR_RELAXED(value) value +#define FT_ATOMIC_LOAD_UINT8(value) value +#define FT_ATOMIC_STORE_UINT8(value, new_value) value = new_value +#define FT_ATOMIC_LOAD_UINT8_RELAXED(value) value +#define FT_ATOMIC_LOAD_UINT16_RELAXED(value) value +#define FT_ATOMIC_LOAD_UINT32_RELAXED(value) value +#define FT_ATOMIC_LOAD_ULONG_RELAXED(value) value +#define FT_ATOMIC_STORE_PTR_RELAXED(value, new_value) value = new_value +#define FT_ATOMIC_STORE_PTR_RELEASE(value, new_value) value = new_value +#define FT_ATOMIC_STORE_UINTPTR_RELEASE(value, new_value) value = new_value +#define FT_ATOMIC_STORE_SSIZE_RELAXED(value, new_value) value = new_value +#define FT_ATOMIC_STORE_SSIZE_RELEASE(value, new_value) value = new_value +#define FT_ATOMIC_STORE_UINT8_RELAXED(value, new_value) value = new_value +#define FT_ATOMIC_STORE_UINT16_RELAXED(value, new_value) value = new_value +#define FT_ATOMIC_STORE_UINT32_RELAXED(value, new_value) value = new_value +#define FT_ATOMIC_LOAD_CHAR_RELAXED(value) value +#define FT_ATOMIC_STORE_CHAR_RELAXED(value, new_value) value = new_value +#define FT_ATOMIC_LOAD_UCHAR_RELAXED(value) value +#define FT_ATOMIC_STORE_UCHAR_RELAXED(value, new_value) value = new_value +#define FT_ATOMIC_LOAD_SHORT_RELAXED(value) value +#define FT_ATOMIC_STORE_SHORT_RELAXED(value, new_value) value = new_value +#define FT_ATOMIC_LOAD_USHORT_RELAXED(value) value +#define FT_ATOMIC_STORE_USHORT_RELAXED(value, new_value) value = new_value +#define FT_ATOMIC_LOAD_INT(value) value +#define FT_ATOMIC_STORE_INT(value, new_value) value = new_value +#define FT_ATOMIC_LOAD_INT_RELAXED(value) value +#define FT_ATOMIC_STORE_INT_RELAXED(value, new_value) value = new_value +#define FT_ATOMIC_LOAD_UINT(value) value +#define FT_ATOMIC_LOAD_UINT_RELAXED(value) value +#define FT_ATOMIC_STORE_UINT_RELAXED(value, new_value) value = new_value +#define FT_ATOMIC_LOAD_LONG_RELAXED(value) value +#define FT_ATOMIC_STORE_LONG_RELAXED(value, new_value) value = new_value +#define FT_ATOMIC_STORE_ULONG_RELAXED(value, new_value) value = new_value +#define FT_ATOMIC_STORE_SSIZE_RELAXED(value, new_value) value = new_value +#define FT_ATOMIC_LOAD_FLOAT_RELAXED(value) value +#define FT_ATOMIC_STORE_FLOAT_RELAXED(value, new_value) value = new_value +#define FT_ATOMIC_LOAD_DOUBLE_RELAXED(value) value +#define FT_ATOMIC_STORE_DOUBLE_RELAXED(value, new_value) value = new_value +#define FT_ATOMIC_LOAD_LLONG_RELAXED(value) value +#define FT_ATOMIC_STORE_LLONG_RELAXED(value, new_value) value = new_value +#define FT_ATOMIC_LOAD_ULLONG_RELAXED(value) value +#define FT_ATOMIC_STORE_ULLONG_RELAXED(value, new_value) value = new_value +#define FT_ATOMIC_ADD_SSIZE(value, new_value) (void)(value += new_value) +#define FT_MUTEX_LOCK(lock) do {} while (0) +#define FT_MUTEX_UNLOCK(lock) do {} while (0) + +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_ATOMIC_FT_WRAPPERS_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pybuffer.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pybuffer.h new file mode 100644 index 0000000000000000000000000000000000000000..9439d2bd770587d6c22620635254cfa5bf727b40 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pybuffer.h @@ -0,0 +1,21 @@ +#ifndef Py_INTERNAL_PYBUFFER_H +#define Py_INTERNAL_PYBUFFER_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + + +// Exported for the _interpchannels module. +PyAPI_FUNC(int) _PyBuffer_ReleaseInInterpreter( + PyInterpreterState *interp, Py_buffer *view); +PyAPI_FUNC(int) _PyBuffer_ReleaseInInterpreterAndRawFree( + PyInterpreterState *interp, Py_buffer *view); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_PYBUFFER_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pyerrors.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pyerrors.h new file mode 100644 index 0000000000000000000000000000000000000000..2c2048f7e1272a3d3b6088b38742af233a210fc2 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pyerrors.h @@ -0,0 +1,213 @@ +#ifndef Py_INTERNAL_PYERRORS_H +#define Py_INTERNAL_PYERRORS_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + + +/* Error handling definitions */ + +extern _PyErr_StackItem* _PyErr_GetTopmostException(PyThreadState *tstate); +extern PyObject* _PyErr_GetHandledException(PyThreadState *); +extern void _PyErr_SetHandledException(PyThreadState *, PyObject *); +extern void _PyErr_GetExcInfo(PyThreadState *, PyObject **, PyObject **, PyObject **); + +// Export for '_testinternalcapi' shared extension +PyAPI_FUNC(void) _PyErr_SetKeyError(PyObject *); + + +// Like PyErr_Format(), but saves current exception as __context__ and +// __cause__. +// Export for '_sqlite3' shared extension. +PyAPI_FUNC(PyObject*) _PyErr_FormatFromCause( + PyObject *exception, + const char *format, /* ASCII-encoded string */ + ... + ); + +extern int _PyException_AddNote( + PyObject *exc, + PyObject *note); + +extern int _PyErr_CheckSignals(void); + +/* Support for adding program text to SyntaxErrors */ + +// Export for test_peg_generator +PyAPI_FUNC(PyObject*) _PyErr_ProgramDecodedTextObject( + PyObject *filename, + int lineno, + const char* encoding); + +extern PyObject* _PyUnicodeTranslateError_Create( + PyObject *object, + Py_ssize_t start, + Py_ssize_t end, + const char *reason /* UTF-8 encoded string */ + ); + +extern void _Py_NO_RETURN _Py_FatalErrorFormat( + const char *func, + const char *format, + ...); + +extern PyObject* _PyErr_SetImportErrorWithNameFrom( + PyObject *, + PyObject *, + PyObject *, + PyObject *); +extern int _PyErr_SetModuleNotFoundError(PyObject *name); + + +/* runtime lifecycle */ + +extern PyStatus _PyErr_InitTypes(PyInterpreterState *); +extern void _PyErr_FiniTypes(PyInterpreterState *); + + +/* other API */ + +static inline PyObject* _PyErr_Occurred(PyThreadState *tstate) +{ + assert(tstate != NULL); + if (tstate->current_exception == NULL) { + return NULL; + } + return (PyObject *)Py_TYPE(tstate->current_exception); +} + +static inline void _PyErr_ClearExcState(_PyErr_StackItem *exc_state) +{ + Py_CLEAR(exc_state->exc_value); +} + +extern PyObject* _PyErr_StackItemToExcInfoTuple( + _PyErr_StackItem *err_info); + +extern void _PyErr_Fetch( + PyThreadState *tstate, + PyObject **type, + PyObject **value, + PyObject **traceback); + +PyAPI_FUNC(PyObject*) _PyErr_GetRaisedException(PyThreadState *tstate); + +PyAPI_FUNC(int) _PyErr_ExceptionMatches( + PyThreadState *tstate, + PyObject *exc); + +PyAPI_FUNC(void) _PyErr_SetRaisedException(PyThreadState *tstate, PyObject *exc); + +extern void _PyErr_Restore( + PyThreadState *tstate, + PyObject *type, + PyObject *value, + PyObject *traceback); + +extern void _PyErr_SetObject( + PyThreadState *tstate, + PyObject *type, + PyObject *value); + +extern void _PyErr_ChainStackItem(void); +extern void _PyErr_ChainExceptions1Tstate(PyThreadState *, PyObject *); + +PyAPI_FUNC(void) _PyErr_Clear(PyThreadState *tstate); + +extern void _PyErr_SetNone(PyThreadState *tstate, PyObject *exception); + +extern PyObject* _PyErr_NoMemory(PyThreadState *tstate); + +extern int _PyErr_EmitSyntaxWarning(PyObject *msg, PyObject *filename, int lineno, int col_offset, + int end_lineno, int end_col_offset); +extern void _PyErr_RaiseSyntaxError(PyObject *msg, PyObject *filename, int lineno, int col_offset, + int end_lineno, int end_col_offset); + +PyAPI_FUNC(void) _PyErr_SetString( + PyThreadState *tstate, + PyObject *exception, + const char *string); + +/* + * Set an exception with the error message decoded from the current locale + * encoding (LC_CTYPE). + * + * Exceptions occurring in decoding take priority over the desired exception. + * + * Exported for '_ctypes' shared extensions. + */ +PyAPI_FUNC(void) _PyErr_SetLocaleString( + PyObject *exception, + const char *string); + +PyAPI_FUNC(PyObject*) _PyErr_Format( + PyThreadState *tstate, + PyObject *exception, + const char *format, + ...); + +PyAPI_FUNC(PyObject*) _PyErr_FormatV( + PyThreadState *tstate, + PyObject *exception, + const char *format, + va_list vargs); + +extern void _PyErr_NormalizeException( + PyThreadState *tstate, + PyObject **exc, + PyObject **val, + PyObject **tb); + +extern PyObject* _PyErr_FormatFromCauseTstate( + PyThreadState *tstate, + PyObject *exception, + const char *format, + ...); + +extern PyObject* _PyExc_CreateExceptionGroup( + const char *msg, + PyObject *excs); + +extern PyObject* _PyExc_PrepReraiseStar( + PyObject *orig, + PyObject *excs); + +extern int _PyErr_CheckSignalsTstate(PyThreadState *tstate); + +extern void _Py_DumpExtensionModules(int fd, PyInterpreterState *interp); +extern PyObject* _Py_CalculateSuggestions(PyObject *dir, PyObject *name); +extern PyObject* _Py_Offer_Suggestions(PyObject* exception); + +// Export for '_testinternalcapi' shared extension +PyAPI_FUNC(Py_ssize_t) _Py_UTF8_Edit_Cost(PyObject *str_a, PyObject *str_b, + Py_ssize_t max_cost); + +// Export for '_json' shared extension +PyAPI_FUNC(void) _PyErr_FormatNote(const char *format, ...); + +/* Context manipulation (PEP 3134) */ + +Py_DEPRECATED(3.12) extern void _PyErr_ChainExceptions(PyObject *, PyObject *, PyObject *); + +// implementation detail for the codeop module. +// Exported for test.test_peg_generator.test_c_parser +PyAPI_DATA(PyTypeObject) _PyExc_IncompleteInputError; +#define PyExc_IncompleteInputError ((PyObject *)(&_PyExc_IncompleteInputError)) + +extern int _PyUnicodeError_GetParams( + PyObject *self, + PyObject **obj, + Py_ssize_t *objlen, + Py_ssize_t *start, + Py_ssize_t *end, + Py_ssize_t *slen, + int as_bytes); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_PYERRORS_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pyhash.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pyhash.h new file mode 100644 index 0000000000000000000000000000000000000000..84cb72fa6fd1b26e9413f1b6efe568164204651d --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pyhash.h @@ -0,0 +1,91 @@ +#ifndef Py_INTERNAL_PYHASH_H +#define Py_INTERNAL_PYHASH_H + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +// Similar to Py_HashPointer(), but don't replace -1 with -2. +static inline Py_hash_t +_Py_HashPointerRaw(const void *ptr) +{ + uintptr_t x = (uintptr_t)ptr; + Py_BUILD_ASSERT(sizeof(x) == sizeof(ptr)); + + // Bottom 3 or 4 bits are likely to be 0; rotate x by 4 to the right + // to avoid excessive hash collisions for dicts and sets. + x = (x >> 4) | (x << (8 * sizeof(uintptr_t) - 4)); + + Py_BUILD_ASSERT(sizeof(x) == sizeof(Py_hash_t)); + return (Py_hash_t)x; +} + +/* Hash secret + * + * memory layout on 64 bit systems + * cccccccc cccccccc cccccccc uc -- unsigned char[24] + * pppppppp ssssssss ........ fnv -- two Py_hash_t + * k0k0k0k0 k1k1k1k1 ........ siphash -- two uint64_t + * ........ ........ ssssssss djbx33a -- 16 bytes padding + one Py_hash_t + * ........ ........ eeeeeeee pyexpat XML hash salt + * + * memory layout on 32 bit systems + * cccccccc cccccccc cccccccc uc + * ppppssss ........ ........ fnv -- two Py_hash_t + * k0k0k0k0 k1k1k1k1 ........ siphash -- two uint64_t (*) + * ........ ........ ssss.... djbx33a -- 16 bytes padding + one Py_hash_t + * ........ ........ eeee.... pyexpat XML hash salt + * + * (*) The siphash member may not be available on 32 bit platforms without + * an unsigned int64 data type. + */ +typedef union { + /* ensure 24 bytes */ + unsigned char uc[24]; + /* two Py_hash_t for FNV */ + struct { + Py_hash_t prefix; + Py_hash_t suffix; + } fnv; + /* two uint64 for SipHash24 */ + struct { + uint64_t k0; + uint64_t k1; + } siphash; + /* a different (!) Py_hash_t for small string optimization */ + struct { + unsigned char padding[16]; + Py_hash_t suffix; + } djbx33a; + struct { + unsigned char padding[16]; + Py_hash_t hashsalt; + } expat; +} _Py_HashSecret_t; + +// Export for '_elementtree' shared extension +PyAPI_DATA(_Py_HashSecret_t) _Py_HashSecret; + +#ifdef Py_DEBUG +extern int _Py_HashSecret_Initialized; +#endif + + +#ifndef MS_WINDOWS +# define _py_urandom_cache_INIT \ + { \ + .fd = -1, \ + } +#else +# define _py_urandom_cache_INIT {0} +#endif + +#define pyhash_state_INIT \ + { \ + .urandom_cache = _py_urandom_cache_INIT, \ + } + + +extern uint64_t _Py_KeyedHash(uint64_t key, const void *src, Py_ssize_t src_sz); + +#endif // !Py_INTERNAL_PYHASH_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pylifecycle.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pylifecycle.h new file mode 100644 index 0000000000000000000000000000000000000000..8faf7a4d403f846c9afc7cf5d448e1380331f232 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pylifecycle.h @@ -0,0 +1,136 @@ +#ifndef Py_INTERNAL_LIFECYCLE_H +#define Py_INTERNAL_LIFECYCLE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_typedefs.h" // _PyRuntimeState + +/* Forward declarations */ +struct _PyArgv; + +extern int _Py_SetFileSystemEncoding( + const char *encoding, + const char *errors); +extern void _Py_ClearFileSystemEncoding(void); +extern PyStatus _PyUnicode_InitEncodings(PyThreadState *tstate); +#ifdef MS_WINDOWS +extern int _PyUnicode_EnableLegacyWindowsFSEncoding(void); +#endif + +extern int _Py_IsLocaleCoercionTarget(const char *ctype_loc); + +/* Various one-time initializers */ + +extern void _Py_InitVersion(void); +extern PyStatus _PyFaulthandler_Init(int enable); +extern PyObject * _PyBuiltin_Init(PyInterpreterState *interp); +extern PyStatus _PySys_Create( + PyThreadState *tstate, + PyObject **sysmod_p); +extern PyStatus _PySys_ReadPreinitWarnOptions(PyWideStringList *options); +extern PyStatus _PySys_ReadPreinitXOptions(PyConfig *config); +extern int _PySys_UpdateConfig(PyThreadState *tstate); +extern void _PySys_FiniTypes(PyInterpreterState *interp); +extern int _PyBuiltins_AddExceptions(PyObject * bltinmod); +extern PyStatus _Py_HashRandomization_Init(const PyConfig *); + +extern PyStatus _PyGC_Init(PyInterpreterState *interp); +extern PyStatus _PyAtExit_Init(PyInterpreterState *interp); +extern PyStatus _PyDateTime_InitTypes(PyInterpreterState *interp); + +/* Various internal finalizers */ + +extern int _PySignal_Init(int install_signal_handlers); +extern void _PySignal_Fini(void); + +extern void _PyGC_Fini(PyInterpreterState *interp); +extern void _Py_HashRandomization_Fini(void); +extern void _PyFaulthandler_Fini(void); +extern void _PyHash_Fini(void); +extern void _PyTraceMalloc_Fini(void); +extern void _PyWarnings_Fini(PyInterpreterState *interp); +extern void _PyAST_Fini(PyInterpreterState *interp); +extern void _PyAtExit_Fini(PyInterpreterState *interp); +extern void _PyThread_FiniType(PyInterpreterState *interp); +extern void _PyArg_Fini(void); +extern void _Py_FinalizeAllocatedBlocks(_PyRuntimeState *); + +extern PyStatus _PyGILState_Init(PyInterpreterState *interp); +extern void _PyGILState_SetTstate(PyThreadState *tstate); +extern void _PyGILState_Fini(PyInterpreterState *interp); + +extern void _PyGC_DumpShutdownStats(PyInterpreterState *interp); + +extern PyStatus _Py_PreInitializeFromPyArgv( + const PyPreConfig *src_config, + const struct _PyArgv *args); +extern PyStatus _Py_PreInitializeFromConfig( + const PyConfig *config, + const struct _PyArgv *args); + +extern wchar_t * _Py_GetStdlibDir(void); + +extern int _Py_HandleSystemExitAndKeyboardInterrupt(int *exitcode_p); + +extern PyObject* _PyErr_WriteUnraisableDefaultHook(PyObject *unraisable); + +extern void _PyErr_Print(PyThreadState *tstate); +extern void _PyErr_Display(PyObject *file, PyObject *exception, + PyObject *value, PyObject *tb); +extern void _PyErr_DisplayException(PyObject *file, PyObject *exc); + +extern void _PyThreadState_DeleteCurrent(PyThreadState *tstate); + +extern void _PyAtExit_Call(PyInterpreterState *interp); + +extern int _Py_IsCoreInitialized(void); + +extern int _Py_FdIsInteractive(FILE *fp, PyObject *filename); + +extern const char* _Py_gitidentifier(void); +extern const char* _Py_gitversion(void); + +// Export for '_asyncio' shared extension +PyAPI_FUNC(int) _Py_IsInterpreterFinalizing(PyInterpreterState *interp); + +/* Random */ +extern int _PyOS_URandom(void *buffer, Py_ssize_t size); + +// Export for '_random' shared extension +PyAPI_FUNC(int) _PyOS_URandomNonblock(void *buffer, Py_ssize_t size); + +/* Legacy locale support */ +extern int _Py_CoerceLegacyLocale(int warn); +extern int _Py_LegacyLocaleDetected(int warn); + +// Export for 'readline' shared extension +PyAPI_FUNC(char*) _Py_SetLocaleFromEnv(int category); + +// Export for special main.c string compiling with source tracebacks +int _PyRun_SimpleStringFlagsWithName(const char *command, const char* name, PyCompilerFlags *flags); + + +/* interpreter config */ + +// Export for _testinternalcapi shared extension +PyAPI_FUNC(int) _PyInterpreterConfig_InitFromState( + PyInterpreterConfig *, + PyInterpreterState *); +PyAPI_FUNC(PyObject *) _PyInterpreterConfig_AsDict(PyInterpreterConfig *); +PyAPI_FUNC(int) _PyInterpreterConfig_InitFromDict( + PyInterpreterConfig *, + PyObject *); +PyAPI_FUNC(int) _PyInterpreterConfig_UpdateFromDict( + PyInterpreterConfig *, + PyObject *); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_LIFECYCLE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pymath.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pymath.h new file mode 100644 index 0000000000000000000000000000000000000000..5bbbdaab8f42dcd0dad0a2c82be1840f9632cb69 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pymath.h @@ -0,0 +1,205 @@ +#ifndef Py_INTERNAL_PYMATH_H +#define Py_INTERNAL_PYMATH_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + + +/* _Py_ADJUST_ERANGE1(x) + * _Py_ADJUST_ERANGE2(x, y) + * Set errno to 0 before calling a libm function, and invoke one of these + * macros after, passing the function result(s) (_Py_ADJUST_ERANGE2 is useful + * for functions returning complex results). This makes two kinds of + * adjustments to errno: (A) If it looks like the platform libm set + * errno=ERANGE due to underflow, clear errno. (B) If it looks like the + * platform libm overflowed but didn't set errno, force errno to ERANGE. In + * effect, we're trying to force a useful implementation of C89 errno + * behavior. + * Caution: + * This isn't reliable. C99 no longer requires libm to set errno under + * any exceptional condition, but does require +- HUGE_VAL return + * values on overflow. A 754 box *probably* maps HUGE_VAL to a + * double infinity, and we're cool if that's so, unless the input + * was an infinity and an infinity is the expected result. A C89 + * system sets errno to ERANGE, so we check for that too. We're + * out of luck if a C99 754 box doesn't map HUGE_VAL to +Inf, or + * if the returned result is a NaN, or if a C89 box returns HUGE_VAL + * in non-overflow cases. + */ +static inline void _Py_ADJUST_ERANGE1(double x) +{ + if (errno == 0) { + if (x == Py_INFINITY || x == -Py_INFINITY) { + errno = ERANGE; + } + } + else if (errno == ERANGE && x == 0.0) { + errno = 0; + } +} + +static inline void _Py_ADJUST_ERANGE2(double x, double y) +{ + if (x == Py_INFINITY || x == -Py_INFINITY || + y == Py_INFINITY || y == -Py_INFINITY) + { + if (errno == 0) { + errno = ERANGE; + } + } + else if (errno == ERANGE) { + errno = 0; + } +} + + +//--- HAVE_PY_SET_53BIT_PRECISION macro ------------------------------------ +// +// The functions _Py_dg_strtod() and _Py_dg_dtoa() in Python/dtoa.c (which are +// required to support the short float repr introduced in Python 3.1) require +// that the floating-point unit that's being used for arithmetic operations on +// C doubles is set to use 53-bit precision. It also requires that the FPU +// rounding mode is round-half-to-even, but that's less often an issue. +// +// If your FPU isn't already set to 53-bit precision/round-half-to-even, and +// you want to make use of _Py_dg_strtod() and _Py_dg_dtoa(), then you should: +// +// #define HAVE_PY_SET_53BIT_PRECISION 1 +// +// and also give appropriate definitions for the following three macros: +// +// * _Py_SET_53BIT_PRECISION_HEADER: any variable declarations needed to +// use the two macros below. +// * _Py_SET_53BIT_PRECISION_START: store original FPU settings, and +// set FPU to 53-bit precision/round-half-to-even +// * _Py_SET_53BIT_PRECISION_END: restore original FPU settings +// +// The macros are designed to be used within a single C function: see +// Python/pystrtod.c for an example of their use. + + +// Get and set x87 control word for gcc/x86 +#ifdef HAVE_GCC_ASM_FOR_X87 +#define HAVE_PY_SET_53BIT_PRECISION 1 + +// Functions defined in Python/pymath.c +extern unsigned short _Py_get_387controlword(void); +extern void _Py_set_387controlword(unsigned short); + +#define _Py_SET_53BIT_PRECISION_HEADER \ + unsigned short old_387controlword, new_387controlword +#define _Py_SET_53BIT_PRECISION_START \ + do { \ + old_387controlword = _Py_get_387controlword(); \ + new_387controlword = (old_387controlword & ~0x0f00) | 0x0200; \ + if (new_387controlword != old_387controlword) { \ + _Py_set_387controlword(new_387controlword); \ + } \ + } while (0) +#define _Py_SET_53BIT_PRECISION_END \ + do { \ + if (new_387controlword != old_387controlword) { \ + _Py_set_387controlword(old_387controlword); \ + } \ + } while (0) +#endif + +// Get and set x87 control word for VisualStudio/x86. +// x87 is not supported in 64-bit or ARM. +#if defined(_MSC_VER) && !defined(_WIN64) && !defined(_M_ARM) +#define HAVE_PY_SET_53BIT_PRECISION 1 + +#include // __control87_2() + +#define _Py_SET_53BIT_PRECISION_HEADER \ + unsigned int old_387controlword, new_387controlword, out_387controlword + // We use the __control87_2 function to set only the x87 control word. + // The SSE control word is unaffected. +#define _Py_SET_53BIT_PRECISION_START \ + do { \ + __control87_2(0, 0, &old_387controlword, NULL); \ + new_387controlword = \ + (old_387controlword & ~(_MCW_PC | _MCW_RC)) | (_PC_53 | _RC_NEAR); \ + if (new_387controlword != old_387controlword) { \ + __control87_2(new_387controlword, _MCW_PC | _MCW_RC, \ + &out_387controlword, NULL); \ + } \ + } while (0) +#define _Py_SET_53BIT_PRECISION_END \ + do { \ + if (new_387controlword != old_387controlword) { \ + __control87_2(old_387controlword, _MCW_PC | _MCW_RC, \ + &out_387controlword, NULL); \ + } \ + } while (0) +#endif + + +// MC68881 +#ifdef HAVE_GCC_ASM_FOR_MC68881 +#define HAVE_PY_SET_53BIT_PRECISION 1 +#define _Py_SET_53BIT_PRECISION_HEADER \ + unsigned int old_fpcr, new_fpcr +#define _Py_SET_53BIT_PRECISION_START \ + do { \ + __asm__ ("fmove.l %%fpcr,%0" : "=dm" (old_fpcr)); \ + /* Set double precision / round to nearest. */ \ + new_fpcr = (old_fpcr & ~0xf0) | 0x80; \ + if (new_fpcr != old_fpcr) { \ + __asm__ volatile ("fmove.l %0,%%fpcr" : : "dm" (new_fpcr)); \ + } \ + } while (0) +#define _Py_SET_53BIT_PRECISION_END \ + do { \ + if (new_fpcr != old_fpcr) { \ + __asm__ volatile ("fmove.l %0,%%fpcr" : : "dm" (old_fpcr)); \ + } \ + } while (0) +#endif + +// Default definitions are empty +#ifndef _Py_SET_53BIT_PRECISION_HEADER +# define _Py_SET_53BIT_PRECISION_HEADER +# define _Py_SET_53BIT_PRECISION_START +# define _Py_SET_53BIT_PRECISION_END +#endif + + +//--- _PY_SHORT_FLOAT_REPR macro ------------------------------------------- + +// If we can't guarantee 53-bit precision, don't use the code +// in Python/dtoa.c, but fall back to standard code. This +// means that repr of a float will be long (17 significant digits). +// +// Realistically, there are two things that could go wrong: +// +// (1) doubles aren't IEEE 754 doubles, or +// (2) we're on x86 with the rounding precision set to 64-bits +// (extended precision), and we don't know how to change +// the rounding precision. +#if !defined(DOUBLE_IS_LITTLE_ENDIAN_IEEE754) && \ + !defined(DOUBLE_IS_BIG_ENDIAN_IEEE754) && \ + !defined(DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754) +# define _PY_SHORT_FLOAT_REPR 0 +#endif + +// Double rounding is symptomatic of use of extended precision on x86. +// If we're seeing double rounding, and we don't have any mechanism available +// for changing the FPU rounding precision, then don't use Python/dtoa.c. +#if defined(X87_DOUBLE_ROUNDING) && !defined(HAVE_PY_SET_53BIT_PRECISION) +# define _PY_SHORT_FLOAT_REPR 0 +#endif + +#ifndef _PY_SHORT_FLOAT_REPR +# define _PY_SHORT_FLOAT_REPR 1 +#endif + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_PYMATH_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pymem.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pymem.h new file mode 100644 index 0000000000000000000000000000000000000000..f0b90a25597d0d87689392e8a6bd6cf78742479f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pymem.h @@ -0,0 +1,145 @@ +#ifndef Py_INTERNAL_PYMEM_H +#define Py_INTERNAL_PYMEM_H + +#include "pycore_llist.h" // struct llist_node + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +// Try to get the allocators name set by _PyMem_SetupAllocators(). +// Return NULL if unknown. +// Export for '_testinternalcapi' shared extension. +PyAPI_FUNC(const char*) _PyMem_GetCurrentAllocatorName(void); + +// strdup() using PyMem_RawMalloc() +extern char* _PyMem_RawStrdup(const char *str); + +// strdup() using PyMem_Malloc(). +// Export for '_pickle ' shared extension. +PyAPI_FUNC(char*) _PyMem_Strdup(const char *str); + +// wcsdup() using PyMem_RawMalloc() +extern wchar_t* _PyMem_RawWcsdup(const wchar_t *str); + +/* Special bytes broadcast into debug memory blocks at appropriate times. + Strings of these are unlikely to be valid addresses, floats, ints or + 7-bit ASCII. + + - PYMEM_CLEANBYTE: clean (newly allocated) memory + - PYMEM_DEADBYTE dead (newly freed) memory + - PYMEM_FORBIDDENBYTE: untouchable bytes at each end of a block + + Byte patterns 0xCB, 0xDB and 0xFB have been replaced with 0xCD, 0xDD and + 0xFD to use the same values as Windows CRT debug malloc() and free(). + If modified, _PyMem_IsPtrFreed() should be updated as well. */ +#define PYMEM_CLEANBYTE 0xCD +#define PYMEM_DEADBYTE 0xDD +#define PYMEM_FORBIDDENBYTE 0xFD + +/* Heuristic checking if a pointer value is newly allocated + (uninitialized), newly freed or NULL (is equal to zero). + + The pointer is not dereferenced, only the pointer value is checked. + + The heuristic relies on the debug hooks on Python memory allocators which + fills newly allocated memory with CLEANBYTE (0xCD) and newly freed memory + with DEADBYTE (0xDD). Detect also "untouchable bytes" marked + with FORBIDDENBYTE (0xFD). */ +static inline int _PyMem_IsPtrFreed(const void *ptr) +{ + uintptr_t value = (uintptr_t)ptr; +#if SIZEOF_VOID_P == 8 + return (value <= 0xff // NULL, 0x1, 0x2, ..., 0xff + || value == (uintptr_t)0xCDCDCDCDCDCDCDCD + || value == (uintptr_t)0xDDDDDDDDDDDDDDDD + || value == (uintptr_t)0xFDFDFDFDFDFDFDFD + || value >= (uintptr_t)0xFFFFFFFFFFFFFF00); // -0xff, ..., -2, -1 +#elif SIZEOF_VOID_P == 4 + return (value <= 0xff + || value == (uintptr_t)0xCDCDCDCD + || value == (uintptr_t)0xDDDDDDDD + || value == (uintptr_t)0xFDFDFDFD + || value >= (uintptr_t)0xFFFFFF00); +#else +# error "unknown pointer size" +#endif +} + +// Similar to _PyMem_IsPtrFreed() but expects an 'unsigned long' instead of a +// pointer. +static inline int _PyMem_IsULongFreed(unsigned long value) +{ +#if SIZEOF_LONG == 8 + return (value == 0 + || value == (unsigned long)0xCDCDCDCDCDCDCDCD + || value == (unsigned long)0xDDDDDDDDDDDDDDDD + || value == (unsigned long)0xFDFDFDFDFDFDFDFD + || value == (unsigned long)0xFFFFFFFFFFFFFFFF); +#elif SIZEOF_LONG == 4 + return (value == 0 + || value == (unsigned long)0xCDCDCDCD + || value == (unsigned long)0xDDDDDDDD + || value == (unsigned long)0xFDFDFDFD + || value == (unsigned long)0xFFFFFFFF); +#else +# error "unknown long size" +#endif +} + +extern int _PyMem_GetAllocatorName( + const char *name, + PyMemAllocatorName *allocator); + +/* Configure the Python memory allocators. + Pass PYMEM_ALLOCATOR_DEFAULT to use default allocators. + PYMEM_ALLOCATOR_NOT_SET does nothing. */ +extern int _PyMem_SetupAllocators(PyMemAllocatorName allocator); + +// Default raw memory allocator that is not affected by PyMem_SetAllocator() +extern void *_PyMem_DefaultRawMalloc(size_t); +extern void *_PyMem_DefaultRawCalloc(size_t, size_t); +extern void *_PyMem_DefaultRawRealloc(void *, size_t); +extern void _PyMem_DefaultRawFree(void *); +extern wchar_t *_PyMem_DefaultRawWcsdup(const wchar_t *str); + +/* Is the debug allocator enabled? */ +extern int _PyMem_DebugEnabled(void); + +// Enqueue a pointer to be freed possibly after some delay. +extern void _PyMem_FreeDelayed(void *ptr, size_t size); + +// Enqueue an object to be freed possibly after some delay +#ifdef Py_GIL_DISABLED +PyAPI_FUNC(void) _PyObject_XDecRefDelayed(PyObject *obj); +#else +static inline void _PyObject_XDecRefDelayed(PyObject *obj) +{ + Py_XDECREF(obj); +} +#endif + +// Periodically process delayed free requests. +extern void _PyMem_ProcessDelayed(PyThreadState *tstate); + +// Periodically process delayed free requests when the world is stopped. +// Notify of any objects whic should be freeed. +typedef void (*delayed_dealloc_cb)(PyObject *, void *); +extern void _PyMem_ProcessDelayedNoDealloc(PyThreadState *tstate, + delayed_dealloc_cb cb, void *state); + +// Abandon all thread-local delayed free requests and push them to the +// interpreter's queue. +extern void _PyMem_AbandonDelayed(PyThreadState *tstate); + +// On interpreter shutdown, frees all delayed free requests. +extern void _PyMem_FiniDelayed(PyInterpreterState *interp); + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_PYMEM_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pymem_init.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pymem_init.h new file mode 100644 index 0000000000000000000000000000000000000000..c593edc86d9952aa9b001006122460ee6f215c44 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pymem_init.h @@ -0,0 +1,103 @@ +#ifndef Py_INTERNAL_PYMEM_INIT_H +#define Py_INTERNAL_PYMEM_INIT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + + +/********************************/ +/* the allocators' initializers */ + +extern void * _PyMem_RawMalloc(void *, size_t); +extern void * _PyMem_RawCalloc(void *, size_t, size_t); +extern void * _PyMem_RawRealloc(void *, void *, size_t); +extern void _PyMem_RawFree(void *, void *); +#define PYRAW_ALLOC {NULL, _PyMem_RawMalloc, _PyMem_RawCalloc, _PyMem_RawRealloc, _PyMem_RawFree} + +#ifdef Py_GIL_DISABLED +// Py_GIL_DISABLED requires mimalloc +extern void* _PyObject_MiMalloc(void *, size_t); +extern void* _PyObject_MiCalloc(void *, size_t, size_t); +extern void _PyObject_MiFree(void *, void *); +extern void* _PyObject_MiRealloc(void *, void *, size_t); +# define PYOBJ_ALLOC {NULL, _PyObject_MiMalloc, _PyObject_MiCalloc, _PyObject_MiRealloc, _PyObject_MiFree} +extern void* _PyMem_MiMalloc(void *, size_t); +extern void* _PyMem_MiCalloc(void *, size_t, size_t); +extern void _PyMem_MiFree(void *, void *); +extern void* _PyMem_MiRealloc(void *, void *, size_t); +# define PYMEM_ALLOC {NULL, _PyMem_MiMalloc, _PyMem_MiCalloc, _PyMem_MiRealloc, _PyMem_MiFree} +#elif defined(WITH_PYMALLOC) +extern void* _PyObject_Malloc(void *, size_t); +extern void* _PyObject_Calloc(void *, size_t, size_t); +extern void _PyObject_Free(void *, void *); +extern void* _PyObject_Realloc(void *, void *, size_t); +# define PYOBJ_ALLOC {NULL, _PyObject_Malloc, _PyObject_Calloc, _PyObject_Realloc, _PyObject_Free} +# define PYMEM_ALLOC PYOBJ_ALLOC +#else +# define PYOBJ_ALLOC PYRAW_ALLOC +# define PYMEM_ALLOC PYOBJ_ALLOC +#endif // WITH_PYMALLOC + + +extern void* _PyMem_DebugRawMalloc(void *, size_t); +extern void* _PyMem_DebugRawCalloc(void *, size_t, size_t); +extern void* _PyMem_DebugRawRealloc(void *, void *, size_t); +extern void _PyMem_DebugRawFree(void *, void *); + +extern void* _PyMem_DebugMalloc(void *, size_t); +extern void* _PyMem_DebugCalloc(void *, size_t, size_t); +extern void* _PyMem_DebugRealloc(void *, void *, size_t); +extern void _PyMem_DebugFree(void *, void *); + +#define PYDBGRAW_ALLOC(runtime) \ + {&(runtime).allocators.debug.raw, _PyMem_DebugRawMalloc, _PyMem_DebugRawCalloc, _PyMem_DebugRawRealloc, _PyMem_DebugRawFree} +#define PYDBGMEM_ALLOC(runtime) \ + {&(runtime).allocators.debug.mem, _PyMem_DebugMalloc, _PyMem_DebugCalloc, _PyMem_DebugRealloc, _PyMem_DebugFree} +#define PYDBGOBJ_ALLOC(runtime) \ + {&(runtime).allocators.debug.obj, _PyMem_DebugMalloc, _PyMem_DebugCalloc, _PyMem_DebugRealloc, _PyMem_DebugFree} + +extern void * _PyMem_ArenaAlloc(void *, size_t); +extern void _PyMem_ArenaFree(void *, void *, size_t); + +#ifdef Py_DEBUG +# define _pymem_allocators_standard_INIT(runtime) \ + { \ + PYDBGRAW_ALLOC(runtime), \ + PYDBGMEM_ALLOC(runtime), \ + PYDBGOBJ_ALLOC(runtime), \ + } +# define _pymem_is_debug_enabled_INIT 1 +#else +# define _pymem_allocators_standard_INIT(runtime) \ + { \ + PYRAW_ALLOC, \ + PYMEM_ALLOC, \ + PYOBJ_ALLOC, \ + } +# define _pymem_is_debug_enabled_INIT 0 +#endif + +#define _pymem_allocators_debug_INIT \ + { \ + {'r', PYRAW_ALLOC}, \ + {'m', PYMEM_ALLOC}, \ + {'o', PYOBJ_ALLOC}, \ + } + +# define _pymem_allocators_obj_arena_INIT \ + { NULL, _PyMem_ArenaAlloc, _PyMem_ArenaFree } + + +#define _Py_mem_free_queue_INIT(queue) \ + { \ + .head = LLIST_INIT(queue.head), \ + } + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_PYMEM_INIT_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pystate.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pystate.h new file mode 100644 index 0000000000000000000000000000000000000000..7f1b0b7523b20d9c3fce71dc9df73fde26a209cc --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pystate.h @@ -0,0 +1,339 @@ +#ifndef Py_INTERNAL_PYSTATE_H +#define Py_INTERNAL_PYSTATE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_pythonrun.h" // _PyOS_STACK_MARGIN_SHIFT +#include "pycore_typedefs.h" // _PyRuntimeState +#include "pycore_tstate.h" + + +// Values for PyThreadState.state. A thread must be in the "attached" state +// before calling most Python APIs. If the GIL is enabled, then "attached" +// implies that the thread holds the GIL and "detached" implies that the +// thread does not hold the GIL (or is in the process of releasing it). In +// `--disable-gil` builds, multiple threads may be "attached" to the same +// interpreter at the same time. Only the "bound" thread may perform the +// transitions between "attached" and "detached" on its own PyThreadState. +// +// The "suspended" state is used to implement stop-the-world pauses, such as +// for cyclic garbage collection. It is only used in `--disable-gil` builds. +// The "suspended" state is similar to the "detached" state in that in both +// states the thread is not allowed to call most Python APIs. However, unlike +// the "detached" state, a thread may not transition itself out from the +// "suspended" state. Only the thread performing a stop-the-world pause may +// transition a thread from the "suspended" state back to the "detached" state. +// +// The "shutting down" state is used when the interpreter is being finalized. +// Threads in this state can't do anything other than block the OS thread. +// (See _PyThreadState_HangThread). +// +// State transition diagram: +// +// (bound thread) (stop-the-world thread) +// [attached] <-> [detached] <-> [suspended] +// | ^ +// +---------------------------->---------------------------+ +// (bound thread) +// +// The (bound thread) and (stop-the-world thread) labels indicate which thread +// is allowed to perform the transition. +#define _Py_THREAD_DETACHED 0 +#define _Py_THREAD_ATTACHED 1 +#define _Py_THREAD_SUSPENDED 2 +#define _Py_THREAD_SHUTTING_DOWN 3 + + +/* Check if the current thread is the main thread. + Use _Py_IsMainInterpreter() to check if it's the main interpreter. */ +extern int _Py_IsMainThread(void); + +// Export for '_testinternalcapi' shared extension +PyAPI_FUNC(PyInterpreterState*) _PyInterpreterState_Main(void); + +static inline int +_Py_IsMainInterpreter(PyInterpreterState *interp) +{ + return (interp == _PyInterpreterState_Main()); +} + +extern int _Py_IsMainInterpreterFinalizing(PyInterpreterState *interp); + +// Export for _interpreters module. +PyAPI_FUNC(PyObject *) _PyInterpreterState_GetIDObject(PyInterpreterState *); + +// Export for _interpreters module. +PyAPI_FUNC(int) _PyInterpreterState_SetRunningMain(PyInterpreterState *); +PyAPI_FUNC(void) _PyInterpreterState_SetNotRunningMain(PyInterpreterState *); +PyAPI_FUNC(int) _PyInterpreterState_IsRunningMain(PyInterpreterState *); +PyAPI_FUNC(void) _PyErr_SetInterpreterAlreadyRunning(void); + +extern int _PyThreadState_IsRunningMain(PyThreadState *); +extern void _PyInterpreterState_ReinitRunningMain(PyThreadState *); +extern const PyConfig* _Py_GetMainConfig(void); + + +/* Only handle signals on the main thread of the main interpreter. */ +static inline int +_Py_ThreadCanHandleSignals(PyInterpreterState *interp) +{ + return (_Py_IsMainThread() && _Py_IsMainInterpreter(interp)); +} + + +/* Variable and static inline functions for in-line access to current thread + and interpreter state */ + +#if defined(HAVE_THREAD_LOCAL) && !defined(Py_BUILD_CORE_MODULE) +extern _Py_thread_local PyThreadState *_Py_tss_tstate; +#endif + +#ifndef NDEBUG +extern int _PyThreadState_CheckConsistency(PyThreadState *tstate); +#endif + +extern int _PyThreadState_MustExit(PyThreadState *tstate); +extern void _PyThreadState_HangThread(PyThreadState *tstate); + +// Export for most shared extensions, used via _PyThreadState_GET() static +// inline function. +PyAPI_FUNC(PyThreadState *) _PyThreadState_GetCurrent(void); + +/* Get the current Python thread state. + + This function is unsafe: it does not check for error and it can return NULL. + + The caller must hold the GIL. + + See also PyThreadState_Get() and PyThreadState_GetUnchecked(). */ +static inline PyThreadState* +_PyThreadState_GET(void) +{ +#if defined(HAVE_THREAD_LOCAL) && !defined(Py_BUILD_CORE_MODULE) + return _Py_tss_tstate; +#else + return _PyThreadState_GetCurrent(); +#endif +} + +static inline int +_PyThreadState_IsAttached(PyThreadState *tstate) +{ + return (_Py_atomic_load_int_relaxed(&tstate->state) == _Py_THREAD_ATTACHED); +} + +// Attaches the current thread to the interpreter. +// +// This may block while acquiring the GIL (if the GIL is enabled) or while +// waiting for a stop-the-world pause (if the GIL is disabled). +// +// High-level code should generally call PyEval_RestoreThread() instead, which +// calls this function. +extern void _PyThreadState_Attach(PyThreadState *tstate); + +// Detaches the current thread from the interpreter. +// +// High-level code should generally call PyEval_SaveThread() instead, which +// calls this function. +extern void _PyThreadState_Detach(PyThreadState *tstate); + +// Detaches the current thread to the "suspended" state if a stop-the-world +// pause is in progress. +// +// If there is no stop-the-world pause in progress, then the thread switches +// to the "detached" state. +extern void _PyThreadState_Suspend(PyThreadState *tstate); + +// Mark the thread state as "shutting down". This is used during interpreter +// and runtime finalization. The thread may no longer attach to the +// interpreter and will instead block via _PyThreadState_HangThread(). +extern void _PyThreadState_SetShuttingDown(PyThreadState *tstate); + +// Perform a stop-the-world pause for all threads in the all interpreters. +// +// Threads in the "attached" state are paused and transitioned to the "GC" +// state. Threads in the "detached" state switch to the "GC" state, preventing +// them from reattaching until the stop-the-world pause is complete. +// +// NOTE: This is a no-op outside of Py_GIL_DISABLED builds. +extern void _PyEval_StopTheWorldAll(_PyRuntimeState *runtime); +extern void _PyEval_StartTheWorldAll(_PyRuntimeState *runtime); + +// Perform a stop-the-world pause for threads in the specified interpreter. +// +// NOTE: This is a no-op outside of Py_GIL_DISABLED builds. +extern PyAPI_FUNC(void) _PyEval_StopTheWorld(PyInterpreterState *interp); +extern PyAPI_FUNC(void) _PyEval_StartTheWorld(PyInterpreterState *interp); + + +static inline void +_Py_EnsureFuncTstateNotNULL(const char *func, PyThreadState *tstate) +{ + if (tstate == NULL) { +#ifndef Py_GIL_DISABLED + _Py_FatalErrorFunc(func, + "the function must be called with the GIL held, " + "after Python initialization and before Python finalization, " + "but the GIL is released (the current Python thread state is NULL)"); +#else + _Py_FatalErrorFunc(func, + "the function must be called with an active thread state, " + "after Python initialization and before Python finalization, " + "but it was called without an active thread state. " + "Are you trying to call the C API inside of a Py_BEGIN_ALLOW_THREADS block?"); +#endif + } +} + +// Call Py_FatalError() if tstate is NULL +#define _Py_EnsureTstateNotNULL(tstate) \ + _Py_EnsureFuncTstateNotNULL(__func__, (tstate)) + + +/* Get the current interpreter state. + + The function is unsafe: it does not check for error and it can return NULL. + + The caller must hold the GIL. + + See also PyInterpreterState_Get() + and _PyGILState_GetInterpreterStateUnsafe(). */ +static inline PyInterpreterState* _PyInterpreterState_GET(void) { + PyThreadState *tstate = _PyThreadState_GET(); +#ifdef Py_DEBUG + _Py_EnsureTstateNotNULL(tstate); +#endif + return tstate->interp; +} + + +// PyThreadState functions + +// Export for _testinternalcapi +PyAPI_FUNC(PyThreadState *) _PyThreadState_New( + PyInterpreterState *interp, + int whence); +extern void _PyThreadState_Bind(PyThreadState *tstate); +PyAPI_FUNC(PyThreadState *) _PyThreadState_NewBound( + PyInterpreterState *interp, + int whence); +extern PyThreadState * _PyThreadState_RemoveExcept(PyThreadState *tstate); +extern void _PyThreadState_DeleteList(PyThreadState *list, int is_after_fork); +extern void _PyThreadState_ClearMimallocHeaps(PyThreadState *tstate); + +// Export for '_testinternalcapi' shared extension +PyAPI_FUNC(PyObject*) _PyThreadState_GetDict(PyThreadState *tstate); + +/* The implementation of sys._current_exceptions() Returns a dict mapping + thread id to that thread's current exception. +*/ +extern PyObject* _PyThread_CurrentExceptions(void); + + +/* Other */ + +extern PyThreadState * _PyThreadState_Swap( + _PyRuntimeState *runtime, + PyThreadState *newts); + +extern PyStatus _PyInterpreterState_Enable(_PyRuntimeState *runtime); + +#ifdef HAVE_FORK +extern PyStatus _PyInterpreterState_DeleteExceptMain(_PyRuntimeState *runtime); +extern void _PySignal_AfterFork(void); +#endif + +// Export for the stable ABI +PyAPI_FUNC(int) _PyState_AddModule( + PyThreadState *tstate, + PyObject* module, + PyModuleDef* def); + + +extern int _PyOS_InterruptOccurred(PyThreadState *tstate); + +#define HEAD_LOCK(runtime) \ + PyMutex_LockFlags(&(runtime)->interpreters.mutex, _Py_LOCK_DONT_DETACH) +#define HEAD_UNLOCK(runtime) \ + PyMutex_Unlock(&(runtime)->interpreters.mutex) + +#define _Py_FOR_EACH_TSTATE_UNLOCKED(interp, t) \ + for (PyThreadState *t = interp->threads.head; t; t = t->next) +#define _Py_FOR_EACH_TSTATE_BEGIN(interp, t) \ + HEAD_LOCK(interp->runtime); \ + _Py_FOR_EACH_TSTATE_UNLOCKED(interp, t) +#define _Py_FOR_EACH_TSTATE_END(interp) \ + HEAD_UNLOCK(interp->runtime) + + +// Get the configuration of the current interpreter. +// The caller must hold the GIL. +// Export for test_peg_generator. +PyAPI_FUNC(const PyConfig*) _Py_GetConfig(void); + +// Get the single PyInterpreterState used by this process' GILState +// implementation. +// +// This function doesn't check for error. Return NULL before _PyGILState_Init() +// is called and after _PyGILState_Fini() is called. +// +// See also PyInterpreterState_Get() and _PyInterpreterState_GET(). +extern PyInterpreterState* _PyGILState_GetInterpreterStateUnsafe(void); + +extern PyObject * _Py_GetMainModule(PyThreadState *); +extern int _Py_CheckMainModule(PyObject *module); + +#ifndef NDEBUG +/* Modern equivalent of assert(PyGILState_Check()) */ +static inline void +_Py_AssertHoldsTstateFunc(const char *func) +{ + PyThreadState *tstate = _PyThreadState_GET(); + _Py_EnsureFuncTstateNotNULL(func, tstate); +} +#define _Py_AssertHoldsTstate() _Py_AssertHoldsTstateFunc(__func__) +#else +#define _Py_AssertHoldsTstate() +#endif + +#if !_Py__has_builtin(__builtin_frame_address) && !defined(__GNUC__) && !defined(_MSC_VER) +static uintptr_t return_pointer_as_int(char* p) { + return (uintptr_t)p; +} +#endif + +static inline uintptr_t +_Py_get_machine_stack_pointer(void) { +#if _Py__has_builtin(__builtin_frame_address) || defined(__GNUC__) + return (uintptr_t)__builtin_frame_address(0); +#elif defined(_MSC_VER) + return (uintptr_t)_AddressOfReturnAddress(); +#else + char here; + /* Avoid compiler warning about returning stack address */ + return return_pointer_as_int(&here); +#endif +} + +static inline intptr_t +_Py_RecursionLimit_GetMargin(PyThreadState *tstate) +{ + _PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate; + assert(_tstate->c_stack_hard_limit != 0); + intptr_t here_addr = _Py_get_machine_stack_pointer(); +#if _Py_STACK_GROWS_DOWN + return Py_ARITHMETIC_RIGHT_SHIFT(intptr_t, here_addr - (intptr_t)_tstate->c_stack_soft_limit, _PyOS_STACK_MARGIN_SHIFT); +#else + return Py_ARITHMETIC_RIGHT_SHIFT(intptr_t, (intptr_t)_tstate->c_stack_soft_limit - here_addr, _PyOS_STACK_MARGIN_SHIFT); +#endif +} + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_PYSTATE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pystats.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pystats.h new file mode 100644 index 0000000000000000000000000000000000000000..f8af398a56058619c35842f2a4f5c6f9a9dada97 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pystats.h @@ -0,0 +1,21 @@ +#ifndef Py_INTERNAL_PYSTATS_H +#define Py_INTERNAL_PYSTATS_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#ifdef Py_STATS +extern void _Py_StatsOn(void); +extern void _Py_StatsOff(void); +extern void _Py_StatsClear(void); +extern int _Py_PrintSpecializationStats(int to_file); +#endif + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_PYSTATS_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pythonrun.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pythonrun.h new file mode 100644 index 0000000000000000000000000000000000000000..b25abb4f64c688f095b538c1cf61e7eb4513429b --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pythonrun.h @@ -0,0 +1,68 @@ +#ifndef Py_INTERNAL_PYTHONRUN_H +#define Py_INTERNAL_PYTHONRUN_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +extern int _PyRun_SimpleFileObject( + FILE *fp, + PyObject *filename, + int closeit, + PyCompilerFlags *flags); + +extern int _PyRun_AnyFileObject( + FILE *fp, + PyObject *filename, + int closeit, + PyCompilerFlags *flags); + +extern int _PyRun_InteractiveLoopObject( + FILE *fp, + PyObject *filename, + PyCompilerFlags *flags); + +extern int _PyObject_SupportedAsScript(PyObject *); +extern const char* _Py_SourceAsString( + PyObject *cmd, + const char *funcname, + const char *what, + PyCompilerFlags *cf, + PyObject **cmd_copy); + + +/* Stack size, in "pointers". This must be large enough, so + * no two calls to check recursion depth are more than this far + * apart. In practice, that means it must be larger than the C + * stack consumption of PyEval_EvalDefault */ +#if (defined(Py_DEBUG) \ + || defined(_Py_ADDRESS_SANITIZER) \ + || defined(_Py_THREAD_SANITIZER)) +# define _PyOS_LOG2_STACK_MARGIN 12 +#else +# define _PyOS_LOG2_STACK_MARGIN 11 +#endif +#define _PyOS_STACK_MARGIN (1 << _PyOS_LOG2_STACK_MARGIN) +#define _PyOS_STACK_MARGIN_BYTES (_PyOS_STACK_MARGIN * sizeof(void *)) + +#if SIZEOF_VOID_P == 8 +# define _PyOS_STACK_MARGIN_SHIFT (_PyOS_LOG2_STACK_MARGIN + 3) +#else +# define _PyOS_STACK_MARGIN_SHIFT (_PyOS_LOG2_STACK_MARGIN + 2) +#endif + +#ifdef _Py_THREAD_SANITIZER +# define _PyOS_MIN_STACK_SIZE (_PyOS_STACK_MARGIN_BYTES * 6) +#else +# define _PyOS_MIN_STACK_SIZE (_PyOS_STACK_MARGIN_BYTES * 3) +#endif + + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_PYTHONRUN_H + diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pythread.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pythread.h new file mode 100644 index 0000000000000000000000000000000000000000..8457b07340f8ddfd8cac18b755b63a90e2ace517 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_pythread.h @@ -0,0 +1,172 @@ +#ifndef Py_INTERNAL_PYTHREAD_H +#define Py_INTERNAL_PYTHREAD_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "dynamic_annotations.h" // _Py_ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX +#include "pycore_llist.h" // struct llist_node + +// Get _POSIX_THREADS and _POSIX_SEMAPHORES macros if available +#if (defined(HAVE_UNISTD_H) && !defined(_POSIX_THREADS) \ + && !defined(_POSIX_SEMAPHORES)) +# include // _POSIX_THREADS, _POSIX_SEMAPHORES +#endif +#if (defined(HAVE_PTHREAD_H) && !defined(_POSIX_THREADS) \ + && !defined(_POSIX_SEMAPHORES)) + // This means pthreads are not implemented in libc headers, hence the macro + // not present in . But they still can be implemented as an + // external library (e.g. gnu pth in pthread emulation) +# include // _POSIX_THREADS, _POSIX_SEMAPHORES +#endif +#if !defined(_POSIX_THREADS) && defined(__hpux) && defined(_SC_THREADS) + // Check if we're running on HP-UX and _SC_THREADS is defined. If so, then + // enough of the POSIX threads package is implemented to support Python + // threads. + // + // This is valid for HP-UX 11.23 running on an ia64 system. If needed, add + // a check of __ia64 to verify that we're running on an ia64 system instead + // of a pa-risc system. +# define _POSIX_THREADS +#endif + + +#if defined(_POSIX_THREADS) || defined(HAVE_PTHREAD_STUBS) +# define _USE_PTHREADS +#endif + +#if defined(_USE_PTHREADS) && defined(HAVE_PTHREAD_CONDATTR_SETCLOCK) && defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC) +// monotonic is supported statically. It doesn't mean it works on runtime. +# define CONDATTR_MONOTONIC +#endif + + +#if defined(HAVE_PTHREAD_STUBS) +#include "cpython/pthread_stubs.h" // PTHREAD_KEYS_MAX +#include // bool + +// pthread_key +struct py_stub_tls_entry { + bool in_use; + void *value; +}; +#endif + +struct _pythread_runtime_state { + int initialized; + +#ifdef _USE_PTHREADS + // This matches when thread_pthread.h is used. + struct { + /* NULL when pthread_condattr_setclock(CLOCK_MONOTONIC) is not supported. */ + pthread_condattr_t *ptr; +# ifdef CONDATTR_MONOTONIC + /* The value to which condattr_monotonic is set. */ + pthread_condattr_t val; +# endif + } _condattr_monotonic; + +#endif // USE_PTHREADS + +#if defined(HAVE_PTHREAD_STUBS) + struct { + struct py_stub_tls_entry tls_entries[PTHREAD_KEYS_MAX]; + } stubs; +#endif + + // Linked list of ThreadHandles + struct llist_node handles; +}; + +#define _pythread_RUNTIME_INIT(pythread) \ + { \ + .handles = LLIST_INIT(pythread.handles), \ + } + +#ifdef HAVE_FORK +/* Private function to reinitialize a lock at fork in the child process. + Reset the lock to the unlocked state. + Return 0 on success, return -1 on error. */ +extern int _PyThread_at_fork_reinit(PyThread_type_lock *lock); +extern void _PyThread_AfterFork(struct _pythread_runtime_state *state); +#endif /* HAVE_FORK */ + + +// unset: -1 seconds, in nanoseconds +#define PyThread_UNSET_TIMEOUT ((PyTime_t)(-1 * 1000 * 1000 * 1000)) + +// Exported for the _interpchannels module. +PyAPI_FUNC(int) PyThread_ParseTimeoutArg( + PyObject *arg, + int blocking, + PY_TIMEOUT_T *timeout); + +/* Helper to acquire an interruptible lock with a timeout. If the lock acquire + * is interrupted, signal handlers are run, and if they raise an exception, + * PY_LOCK_INTR is returned. Otherwise, PY_LOCK_ACQUIRED or PY_LOCK_FAILURE + * are returned, depending on whether the lock can be acquired within the + * timeout. + */ +// Exported for the _interpchannels module. +PyAPI_FUNC(PyLockStatus) PyThread_acquire_lock_timed_with_retries( + PyThread_type_lock, + PY_TIMEOUT_T microseconds); + +typedef unsigned long long PyThread_ident_t; +typedef Py_uintptr_t PyThread_handle_t; + +#define PY_FORMAT_THREAD_IDENT_T "llu" +#define Py_PARSE_THREAD_IDENT_T "K" + +PyAPI_FUNC(PyThread_ident_t) PyThread_get_thread_ident_ex(void); + +/* Thread joining APIs. + * + * These APIs have a strict contract: + * - Either PyThread_join_thread or PyThread_detach_thread must be called + * exactly once with the given handle. + * - Calling neither PyThread_join_thread nor PyThread_detach_thread results + * in a resource leak until the end of the process. + * - Any other usage, such as calling both PyThread_join_thread and + * PyThread_detach_thread, or calling them more than once (including + * simultaneously), results in undefined behavior. + */ +PyAPI_FUNC(int) PyThread_start_joinable_thread(void (*func)(void *), + void *arg, + PyThread_ident_t* ident, + PyThread_handle_t* handle); +/* + * Join a thread started with `PyThread_start_joinable_thread`. + * This function cannot be interrupted. It returns 0 on success, + * a non-zero value on failure. + */ +PyAPI_FUNC(int) PyThread_join_thread(PyThread_handle_t); +/* + * Detach a thread started with `PyThread_start_joinable_thread`, such + * that its resources are released as soon as it exits. + * This function cannot be interrupted. It returns 0 on success, + * a non-zero value on failure. + */ +PyAPI_FUNC(int) PyThread_detach_thread(PyThread_handle_t); +/* + * Hangs the thread indefinitely without exiting it. + * + * gh-87135: There is no safe way to exit a thread other than returning + * normally from its start function. This is used during finalization in lieu + * of actually exiting the thread. Since the program is expected to terminate + * soon anyway, it does not matter if the thread stack stays around until then. + * + * This is unfortunate for embedders who may not be terminating their process + * when they're done with the interpreter, but our C API design does not allow + * for safely exiting threads attempting to re-enter Python post finalization. + */ +void _Py_NO_RETURN PyThread_hang_thread(void); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_PYTHREAD_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_qsbr.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_qsbr.h new file mode 100644 index 0000000000000000000000000000000000000000..eeca6fc472be37ba9f06758afd5a617c9f23f7f7 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_qsbr.h @@ -0,0 +1,173 @@ +// The QSBR APIs (quiescent state-based reclamation) provide a mechanism for +// the free-threaded build to safely reclaim memory when there may be +// concurrent accesses. +// +// Many operations in the free-threaded build are protected by locks. However, +// in some cases, we want to allow reads to happen concurrently with updates. +// In this case, we need to delay freeing ("reclaiming") any memory that may be +// concurrently accessed by a reader. The QSBR APIs provide a way to do this. +#ifndef Py_INTERNAL_QSBR_H +#define Py_INTERNAL_QSBR_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +// The shared write sequence is always odd and incremented by two. Detached +// threads are indicated by a read sequence of zero. This avoids collisions +// between the offline state and any valid sequence number even if the +// sequences numbers wrap around. +#define QSBR_OFFLINE 0 +#define QSBR_INITIAL 1 +#define QSBR_INCR 2 + +// Wrap-around safe comparison. This is a holdover from the FreeBSD +// implementation, which uses 32-bit sequence numbers. We currently use 64-bit +// sequence numbers, so wrap-around is unlikely. +#define QSBR_LT(a, b) ((int64_t)((a)-(b)) < 0) +#define QSBR_LEQ(a, b) ((int64_t)((a)-(b)) <= 0) + +struct _qsbr_shared; +struct _PyThreadStateImpl; // forward declare to avoid circular dependency + +// Per-thread state +struct _qsbr_thread_state { + // Last observed write sequence (or 0 if detached) + uint64_t seq; + + // Shared (per-interpreter) QSBR state + struct _qsbr_shared *shared; + + // Thread state (or NULL) + PyThreadState *tstate; + + // Number of held items added by this thread since the last write sequence + // advance + int deferred_count; + + // Estimate for the amount of memory that is held by this thread since + // the last write sequence advance + size_t deferred_memory; + + // Amount of memory in mimalloc pages deferred from collection. When + // deferred, they are prevented from being used for a different size class + // and in a different thread. + size_t deferred_page_memory; + + // True if the deferred memory frees should be processed. + bool should_process; + + // Is this thread state allocated? + bool allocated; + struct _qsbr_thread_state *freelist_next; +}; + +// Padding to avoid false sharing +struct _qsbr_pad { + struct _qsbr_thread_state qsbr; + char __padding[64 - sizeof(struct _qsbr_thread_state)]; +}; + +// Per-interpreter state +struct _qsbr_shared { + // Write sequence: always odd, incremented by two + uint64_t wr_seq; + + // Minimum observed read sequence of all QSBR thread states + uint64_t rd_seq; + + // Array of QSBR thread states (aligned to 64 bytes). + struct _qsbr_pad *array; + void *array_raw; // raw allocation pointer (for free) + Py_ssize_t size; + + // Freelist of unused _qsbr_thread_states (protected by mutex) + PyMutex mutex; + struct _qsbr_thread_state *freelist; +}; + +static inline uint64_t +_Py_qsbr_shared_current(struct _qsbr_shared *shared) +{ + return _Py_atomic_load_uint64_acquire(&shared->wr_seq); +} + +// Reports a quiescent state: the caller no longer holds any pointer to shared +// data not protected by locks or reference counts. +static inline void +_Py_qsbr_quiescent_state(struct _qsbr_thread_state *qsbr) +{ + uint64_t seq = _Py_qsbr_shared_current(qsbr->shared); + _Py_atomic_store_uint64_release(&qsbr->seq, seq); +} + +// Have the read sequences advanced to the given goal? Like `_Py_qsbr_poll()`, +// but does not perform a scan of threads. +static inline bool +_Py_qbsr_goal_reached(struct _qsbr_thread_state *qsbr, uint64_t goal) +{ + uint64_t rd_seq = _Py_atomic_load_uint64(&qsbr->shared->rd_seq); + return QSBR_LEQ(goal, rd_seq); +} + +// Advance the write sequence and return the new goal. This should be called +// after data is removed. The returned goal is used with `_Py_qsbr_poll()` to +// determine when it is safe to reclaim (free) the memory. +extern uint64_t +_Py_qsbr_advance(struct _qsbr_shared *shared); + +// Return the next value for the write sequence (current plus the increment). +extern uint64_t +_Py_qsbr_shared_next(struct _qsbr_shared *shared); + +// Return true if deferred memory frees held by QSBR should be processed to +// determine if they can be safely freed. +static inline bool +_Py_qsbr_should_process(struct _qsbr_thread_state *qsbr) +{ + return qsbr->should_process; +} + +// Have the read sequences advanced to the given goal? If this returns true, +// it safe to reclaim any memory tagged with the goal (or earlier goal). +extern bool +_Py_qsbr_poll(struct _qsbr_thread_state *qsbr, uint64_t goal); + +// Called when thread attaches to interpreter +extern void +_Py_qsbr_attach(struct _qsbr_thread_state *qsbr); + +// Called when thread detaches from interpreter +extern void +_Py_qsbr_detach(struct _qsbr_thread_state *qsbr); + +// Reserves (allocates) a QSBR state and returns its index. +extern Py_ssize_t +_Py_qsbr_reserve(PyInterpreterState *interp); + +// Associates a PyThreadState with the QSBR state at the given index +extern void +_Py_qsbr_register(struct _PyThreadStateImpl *tstate, + PyInterpreterState *interp, Py_ssize_t index); + +// Disassociates a PyThreadState from the QSBR state and frees the QSBR state. +extern void +_Py_qsbr_unregister(PyThreadState *tstate); + +extern void +_Py_qsbr_fini(PyInterpreterState *interp); + +extern void +_Py_qsbr_after_fork(struct _PyThreadStateImpl *tstate); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_QSBR_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_range.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_range.h new file mode 100644 index 0000000000000000000000000000000000000000..bf045ec4fd8332de7d13c72558099f5db8bee086 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_range.h @@ -0,0 +1,21 @@ +#ifndef Py_INTERNAL_RANGE_H +#define Py_INTERNAL_RANGE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +typedef struct { + PyObject_HEAD + long start; + long step; + long len; +} _PyRangeIterObject; + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_RANGE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_runtime.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_runtime.h new file mode 100644 index 0000000000000000000000000000000000000000..7fc7f343fe600f8692da44c2ccfee11a33d26bdf --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_runtime.h @@ -0,0 +1,63 @@ +#ifndef Py_INTERNAL_RUNTIME_H +#define Py_INTERNAL_RUNTIME_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_runtime_structs.h" // _PyRuntimeState + + +/* API */ + +// Export _PyRuntime for shared extensions which use it in static inline +// functions for best performance, like _Py_IsMainThread() or _Py_ID(). +// It's also made accessible for debuggers and profilers. +PyAPI_DATA(_PyRuntimeState) _PyRuntime; + +extern PyStatus _PyRuntimeState_Init(_PyRuntimeState *runtime); +extern void _PyRuntimeState_Fini(_PyRuntimeState *runtime); + +#ifdef HAVE_FORK +extern PyStatus _PyRuntimeState_ReInitThreads(_PyRuntimeState *runtime); +#endif + +/* Initialize _PyRuntimeState. + Return NULL on success, or return an error message on failure. */ +extern PyStatus _PyRuntime_Initialize(void); + +extern void _PyRuntime_Finalize(void); + + +static inline PyThreadState* +_PyRuntimeState_GetFinalizing(_PyRuntimeState *runtime) { + return (PyThreadState*)_Py_atomic_load_ptr_relaxed(&runtime->_finalizing); +} + +static inline unsigned long +_PyRuntimeState_GetFinalizingID(_PyRuntimeState *runtime) { + return _Py_atomic_load_ulong_relaxed(&runtime->_finalizing_id); +} + +static inline void +_PyRuntimeState_SetFinalizing(_PyRuntimeState *runtime, PyThreadState *tstate) { + _Py_atomic_store_ptr_relaxed(&runtime->_finalizing, tstate); + if (tstate == NULL) { + _Py_atomic_store_ulong_relaxed(&runtime->_finalizing_id, 0); + } + else { + // XXX Re-enable this assert once gh-109860 is fixed. + //assert(tstate->thread_id == PyThread_get_thread_ident()); + _Py_atomic_store_ulong_relaxed(&runtime->_finalizing_id, + tstate->thread_id); + } +} + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_RUNTIME_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_runtime_init.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_runtime_init.h new file mode 100644 index 0000000000000000000000000000000000000000..4200d91a2fcd9d2e265d00adec861384a1909dad --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_runtime_init.h @@ -0,0 +1,239 @@ +#ifndef Py_INTERNAL_RUNTIME_INIT_H +#define Py_INTERNAL_RUNTIME_INIT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_structs.h" +#include "pycore_ceval_state.h" // _PyEval_RUNTIME_PERF_INIT +#include "pycore_debug_offsets.h" // _Py_DebugOffsets_INIT() +#include "pycore_dtoa.h" // _dtoa_state_INIT() +#include "pycore_faulthandler.h" // _faulthandler_runtime_state_INIT +#include "pycore_floatobject.h" // _py_float_format_unknown +#include "pycore_function.h" +#include "pycore_hamt.h" // _PyHamt_BitmapNode_Type +#include "pycore_import.h" // IMPORTS_INIT +#include "pycore_object.h" // _PyObject_HEAD_INIT +#include "pycore_obmalloc_init.h" // _obmalloc_global_state_INIT +#include "pycore_parser.h" // _parser_runtime_state_INIT +#include "pycore_pyhash.h" // pyhash_state_INIT +#include "pycore_pymem_init.h" // _pymem_allocators_standard_INIT +#include "pycore_pythread.h" // _pythread_RUNTIME_INIT +#include "pycore_qsbr.h" // QSBR_INITIAL +#include "pycore_runtime_init_generated.h" // _Py_bytes_characters_INIT +#include "pycore_signal.h" // _signals_RUNTIME_INIT +#include "pycore_tracemalloc.h" // _tracemalloc_runtime_state_INIT +#include "pycore_tuple.h" // _PyTuple_HASH_EMPTY + + +extern PyTypeObject _PyExc_MemoryError; + + +/* The static initializers defined here should only be used + in the runtime init code (in pystate.c and pylifecycle.c). */ + +#define _PyRuntimeState_INIT(runtime, debug_cookie) \ + { \ + .debug_offsets = _Py_DebugOffsets_INIT(debug_cookie), \ + .allocators = { \ + .standard = _pymem_allocators_standard_INIT(runtime), \ + .debug = _pymem_allocators_debug_INIT, \ + .obj_arena = _pymem_allocators_obj_arena_INIT, \ + .is_debug_enabled = _pymem_is_debug_enabled_INIT, \ + }, \ + .obmalloc = _obmalloc_global_state_INIT, \ + .pyhash_state = pyhash_state_INIT, \ + .threads = _pythread_RUNTIME_INIT(runtime.threads), \ + .signals = _signals_RUNTIME_INIT, \ + .interpreters = { \ + /* This prevents interpreters from getting created \ + until _PyInterpreterState_Enable() is called. */ \ + .next_id = -1, \ + }, \ + .xi = { \ + .data_lookup = { \ + .registry = { \ + .global = 1, \ + }, \ + }, \ + }, \ + /* A TSS key must be initialized with Py_tss_NEEDS_INIT \ + in accordance with the specification. */ \ + .autoTSSkey = Py_tss_NEEDS_INIT, \ + .parser = _parser_runtime_state_INIT, \ + .ceval = { \ + .pending_mainthread = { \ + .max = MAXPENDINGCALLS_MAIN, \ + .maxloop = MAXPENDINGCALLSLOOP_MAIN, \ + }, \ + .perf = _PyEval_RUNTIME_PERF_INIT, \ + }, \ + .gilstate = { \ + .check_enabled = 1, \ + }, \ + .fileutils = { \ + .force_ascii = -1, \ + }, \ + .faulthandler = _faulthandler_runtime_state_INIT, \ + .tracemalloc = _tracemalloc_runtime_state_INIT, \ + .ref_tracer = { \ + .tracer_func = NULL, \ + .tracer_data = NULL, \ + }, \ + .stoptheworld = { \ + .is_global = 1, \ + }, \ + .float_state = { \ + .float_format = _py_float_format_unknown, \ + .double_format = _py_float_format_unknown, \ + }, \ + .types = { \ + .next_version_tag = _Py_TYPE_VERSION_NEXT, \ + }, \ + .static_objects = { \ + .singletons = { \ + .small_ints = _Py_small_ints_INIT, \ + .bytes_empty = _PyBytes_SIMPLE_INIT(0, 0), \ + .bytes_characters = _Py_bytes_characters_INIT, \ + .strings = { \ + .literals = _Py_str_literals_INIT, \ + .identifiers = _Py_str_identifiers_INIT, \ + .ascii = _Py_str_ascii_INIT, \ + .latin1 = _Py_str_latin1_INIT, \ + }, \ + .tuple_empty = { \ + .ob_base = _PyVarObject_HEAD_INIT(&PyTuple_Type, 0), \ + .ob_hash = _PyTuple_HASH_EMPTY, \ + }, \ + .hamt_bitmap_node_empty = { \ + .ob_base = _PyVarObject_HEAD_INIT(&_PyHamt_BitmapNode_Type, 0), \ + }, \ + .context_token_missing = { \ + .ob_base = _PyObject_HEAD_INIT(&_PyContextTokenMissing_Type), \ + }, \ + }, \ + }, \ + ._main_interpreter = _PyInterpreterState_INIT(runtime._main_interpreter), \ + } + +#define _PyInterpreterState_INIT(INTERP) \ + { \ + .id_refcount = -1, \ + ._whence = _PyInterpreterState_WHENCE_NOTSET, \ + .threads = { \ + .preallocated = &(INTERP)._initial_thread, \ + }, \ + .imports = IMPORTS_INIT, \ + .ceval = { \ + .recursion_limit = Py_DEFAULT_RECURSION_LIMIT, \ + .pending = { \ + .max = MAXPENDINGCALLS, \ + .maxloop = MAXPENDINGCALLSLOOP, \ + }, \ + }, \ + .gc = { \ + .enabled = 1, \ + .young = { .threshold = 2000, }, \ + .old = { \ + { .threshold = 10, }, \ + { .threshold = 0, }, \ + }, \ + .work_to_do = -5000, \ + .phase = GC_PHASE_MARK, \ + }, \ + .qsbr = { \ + .wr_seq = QSBR_INITIAL, \ + .rd_seq = QSBR_INITIAL, \ + }, \ + .dtoa = _dtoa_state_INIT(&(INTERP)), \ + .dict_state = _dict_state_INIT, \ + .mem_free_queue = _Py_mem_free_queue_INIT(INTERP.mem_free_queue), \ + .func_state = { \ + .next_version = FUNC_VERSION_FIRST_VALID, \ + }, \ + .types = { \ + .next_version_tag = _Py_TYPE_BASE_VERSION_TAG, \ + }, \ + .static_objects = { \ + .singletons = { \ + ._not_used = 1, \ + .hamt_empty = { \ + .ob_base = _PyObject_HEAD_INIT(&_PyHamt_Type), \ + .h_root = (PyHamtNode*)&_Py_SINGLETON(hamt_bitmap_node_empty), \ + }, \ + .last_resort_memory_error = { \ + _PyObject_HEAD_INIT(&_PyExc_MemoryError), \ + .args = (PyObject*)&_Py_SINGLETON(tuple_empty) \ + }, \ + }, \ + }, \ + ._initial_thread = _PyThreadStateImpl_INIT, \ + } + +#define _PyThreadStateImpl_INIT \ + { \ + .base = _PyThreadState_INIT, \ + /* The thread and the interpreter's linked list hold a reference */ \ + .refcount = 2, \ + } + +#define _PyThreadState_INIT \ + { \ + ._whence = _PyThreadState_WHENCE_NOTSET, \ + .py_recursion_limit = Py_DEFAULT_RECURSION_LIMIT, \ + .context_ver = 1, \ + } + + +// global objects + +#define _PyBytes_SIMPLE_INIT(CH, LEN) \ + { \ + _PyVarObject_HEAD_INIT(&PyBytes_Type, (LEN)), \ + .ob_shash = -1, \ + .ob_sval = { (CH) }, \ + } +#define _PyBytes_CHAR_INIT(CH) \ + { \ + _PyBytes_SIMPLE_INIT((CH), 1) \ + } + +#define _PyUnicode_ASCII_BASE_INIT(LITERAL, ASCII) \ + { \ + .ob_base = _PyObject_HEAD_INIT(&PyUnicode_Type), \ + .length = sizeof(LITERAL) - 1, \ + .hash = -1, \ + .state = { \ + .kind = 1, \ + .compact = 1, \ + .ascii = (ASCII), \ + .statically_allocated = 1, \ + }, \ + } +#define _PyASCIIObject_INIT(LITERAL) \ + { \ + ._ascii = _PyUnicode_ASCII_BASE_INIT((LITERAL), 1), \ + ._data = (LITERAL) \ + } +#define INIT_STR(NAME, LITERAL) \ + ._py_ ## NAME = _PyASCIIObject_INIT(LITERAL) +#define INIT_ID(NAME) \ + ._py_ ## NAME = _PyASCIIObject_INIT(#NAME) +#define _PyUnicode_LATIN1_INIT(LITERAL, UTF8) \ + { \ + ._latin1 = { \ + ._base = _PyUnicode_ASCII_BASE_INIT((LITERAL), 0), \ + .utf8 = (UTF8), \ + .utf8_length = sizeof(UTF8) - 1, \ + }, \ + ._data = (LITERAL), \ + } + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_RUNTIME_INIT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_runtime_init_generated.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_runtime_init_generated.h new file mode 100644 index 0000000000000000000000000000000000000000..e642a42bbfc3e417245a3d00c6842c64c03b7293 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_runtime_init_generated.h @@ -0,0 +1,1589 @@ +#ifndef Py_INTERNAL_RUNTIME_INIT_GENERATED_H +#define Py_INTERNAL_RUNTIME_INIT_GENERATED_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_long.h" // _PyLong_DIGIT_INIT() + + +/* The following is auto-generated by Tools/build/generate_global_objects.py. */ +#define _Py_small_ints_INIT { \ + _PyLong_DIGIT_INIT(-5), \ + _PyLong_DIGIT_INIT(-4), \ + _PyLong_DIGIT_INIT(-3), \ + _PyLong_DIGIT_INIT(-2), \ + _PyLong_DIGIT_INIT(-1), \ + _PyLong_DIGIT_INIT(0), \ + _PyLong_DIGIT_INIT(1), \ + _PyLong_DIGIT_INIT(2), \ + _PyLong_DIGIT_INIT(3), \ + _PyLong_DIGIT_INIT(4), \ + _PyLong_DIGIT_INIT(5), \ + _PyLong_DIGIT_INIT(6), \ + _PyLong_DIGIT_INIT(7), \ + _PyLong_DIGIT_INIT(8), \ + _PyLong_DIGIT_INIT(9), \ + _PyLong_DIGIT_INIT(10), \ + _PyLong_DIGIT_INIT(11), \ + _PyLong_DIGIT_INIT(12), \ + _PyLong_DIGIT_INIT(13), \ + _PyLong_DIGIT_INIT(14), \ + _PyLong_DIGIT_INIT(15), \ + _PyLong_DIGIT_INIT(16), \ + _PyLong_DIGIT_INIT(17), \ + _PyLong_DIGIT_INIT(18), \ + _PyLong_DIGIT_INIT(19), \ + _PyLong_DIGIT_INIT(20), \ + _PyLong_DIGIT_INIT(21), \ + _PyLong_DIGIT_INIT(22), \ + _PyLong_DIGIT_INIT(23), \ + _PyLong_DIGIT_INIT(24), \ + _PyLong_DIGIT_INIT(25), \ + _PyLong_DIGIT_INIT(26), \ + _PyLong_DIGIT_INIT(27), \ + _PyLong_DIGIT_INIT(28), \ + _PyLong_DIGIT_INIT(29), \ + _PyLong_DIGIT_INIT(30), \ + _PyLong_DIGIT_INIT(31), \ + _PyLong_DIGIT_INIT(32), \ + _PyLong_DIGIT_INIT(33), \ + _PyLong_DIGIT_INIT(34), \ + _PyLong_DIGIT_INIT(35), \ + _PyLong_DIGIT_INIT(36), \ + _PyLong_DIGIT_INIT(37), \ + _PyLong_DIGIT_INIT(38), \ + _PyLong_DIGIT_INIT(39), \ + _PyLong_DIGIT_INIT(40), \ + _PyLong_DIGIT_INIT(41), \ + _PyLong_DIGIT_INIT(42), \ + _PyLong_DIGIT_INIT(43), \ + _PyLong_DIGIT_INIT(44), \ + _PyLong_DIGIT_INIT(45), \ + _PyLong_DIGIT_INIT(46), \ + _PyLong_DIGIT_INIT(47), \ + _PyLong_DIGIT_INIT(48), \ + _PyLong_DIGIT_INIT(49), \ + _PyLong_DIGIT_INIT(50), \ + _PyLong_DIGIT_INIT(51), \ + _PyLong_DIGIT_INIT(52), \ + _PyLong_DIGIT_INIT(53), \ + _PyLong_DIGIT_INIT(54), \ + _PyLong_DIGIT_INIT(55), \ + _PyLong_DIGIT_INIT(56), \ + _PyLong_DIGIT_INIT(57), \ + _PyLong_DIGIT_INIT(58), \ + _PyLong_DIGIT_INIT(59), \ + _PyLong_DIGIT_INIT(60), \ + _PyLong_DIGIT_INIT(61), \ + _PyLong_DIGIT_INIT(62), \ + _PyLong_DIGIT_INIT(63), \ + _PyLong_DIGIT_INIT(64), \ + _PyLong_DIGIT_INIT(65), \ + _PyLong_DIGIT_INIT(66), \ + _PyLong_DIGIT_INIT(67), \ + _PyLong_DIGIT_INIT(68), \ + _PyLong_DIGIT_INIT(69), \ + _PyLong_DIGIT_INIT(70), \ + _PyLong_DIGIT_INIT(71), \ + _PyLong_DIGIT_INIT(72), \ + _PyLong_DIGIT_INIT(73), \ + _PyLong_DIGIT_INIT(74), \ + _PyLong_DIGIT_INIT(75), \ + _PyLong_DIGIT_INIT(76), \ + _PyLong_DIGIT_INIT(77), \ + _PyLong_DIGIT_INIT(78), \ + _PyLong_DIGIT_INIT(79), \ + _PyLong_DIGIT_INIT(80), \ + _PyLong_DIGIT_INIT(81), \ + _PyLong_DIGIT_INIT(82), \ + _PyLong_DIGIT_INIT(83), \ + _PyLong_DIGIT_INIT(84), \ + _PyLong_DIGIT_INIT(85), \ + _PyLong_DIGIT_INIT(86), \ + _PyLong_DIGIT_INIT(87), \ + _PyLong_DIGIT_INIT(88), \ + _PyLong_DIGIT_INIT(89), \ + _PyLong_DIGIT_INIT(90), \ + _PyLong_DIGIT_INIT(91), \ + _PyLong_DIGIT_INIT(92), \ + _PyLong_DIGIT_INIT(93), \ + _PyLong_DIGIT_INIT(94), \ + _PyLong_DIGIT_INIT(95), \ + _PyLong_DIGIT_INIT(96), \ + _PyLong_DIGIT_INIT(97), \ + _PyLong_DIGIT_INIT(98), \ + _PyLong_DIGIT_INIT(99), \ + _PyLong_DIGIT_INIT(100), \ + _PyLong_DIGIT_INIT(101), \ + _PyLong_DIGIT_INIT(102), \ + _PyLong_DIGIT_INIT(103), \ + _PyLong_DIGIT_INIT(104), \ + _PyLong_DIGIT_INIT(105), \ + _PyLong_DIGIT_INIT(106), \ + _PyLong_DIGIT_INIT(107), \ + _PyLong_DIGIT_INIT(108), \ + _PyLong_DIGIT_INIT(109), \ + _PyLong_DIGIT_INIT(110), \ + _PyLong_DIGIT_INIT(111), \ + _PyLong_DIGIT_INIT(112), \ + _PyLong_DIGIT_INIT(113), \ + _PyLong_DIGIT_INIT(114), \ + _PyLong_DIGIT_INIT(115), \ + _PyLong_DIGIT_INIT(116), \ + _PyLong_DIGIT_INIT(117), \ + _PyLong_DIGIT_INIT(118), \ + _PyLong_DIGIT_INIT(119), \ + _PyLong_DIGIT_INIT(120), \ + _PyLong_DIGIT_INIT(121), \ + _PyLong_DIGIT_INIT(122), \ + _PyLong_DIGIT_INIT(123), \ + _PyLong_DIGIT_INIT(124), \ + _PyLong_DIGIT_INIT(125), \ + _PyLong_DIGIT_INIT(126), \ + _PyLong_DIGIT_INIT(127), \ + _PyLong_DIGIT_INIT(128), \ + _PyLong_DIGIT_INIT(129), \ + _PyLong_DIGIT_INIT(130), \ + _PyLong_DIGIT_INIT(131), \ + _PyLong_DIGIT_INIT(132), \ + _PyLong_DIGIT_INIT(133), \ + _PyLong_DIGIT_INIT(134), \ + _PyLong_DIGIT_INIT(135), \ + _PyLong_DIGIT_INIT(136), \ + _PyLong_DIGIT_INIT(137), \ + _PyLong_DIGIT_INIT(138), \ + _PyLong_DIGIT_INIT(139), \ + _PyLong_DIGIT_INIT(140), \ + _PyLong_DIGIT_INIT(141), \ + _PyLong_DIGIT_INIT(142), \ + _PyLong_DIGIT_INIT(143), \ + _PyLong_DIGIT_INIT(144), \ + _PyLong_DIGIT_INIT(145), \ + _PyLong_DIGIT_INIT(146), \ + _PyLong_DIGIT_INIT(147), \ + _PyLong_DIGIT_INIT(148), \ + _PyLong_DIGIT_INIT(149), \ + _PyLong_DIGIT_INIT(150), \ + _PyLong_DIGIT_INIT(151), \ + _PyLong_DIGIT_INIT(152), \ + _PyLong_DIGIT_INIT(153), \ + _PyLong_DIGIT_INIT(154), \ + _PyLong_DIGIT_INIT(155), \ + _PyLong_DIGIT_INIT(156), \ + _PyLong_DIGIT_INIT(157), \ + _PyLong_DIGIT_INIT(158), \ + _PyLong_DIGIT_INIT(159), \ + _PyLong_DIGIT_INIT(160), \ + _PyLong_DIGIT_INIT(161), \ + _PyLong_DIGIT_INIT(162), \ + _PyLong_DIGIT_INIT(163), \ + _PyLong_DIGIT_INIT(164), \ + _PyLong_DIGIT_INIT(165), \ + _PyLong_DIGIT_INIT(166), \ + _PyLong_DIGIT_INIT(167), \ + _PyLong_DIGIT_INIT(168), \ + _PyLong_DIGIT_INIT(169), \ + _PyLong_DIGIT_INIT(170), \ + _PyLong_DIGIT_INIT(171), \ + _PyLong_DIGIT_INIT(172), \ + _PyLong_DIGIT_INIT(173), \ + _PyLong_DIGIT_INIT(174), \ + _PyLong_DIGIT_INIT(175), \ + _PyLong_DIGIT_INIT(176), \ + _PyLong_DIGIT_INIT(177), \ + _PyLong_DIGIT_INIT(178), \ + _PyLong_DIGIT_INIT(179), \ + _PyLong_DIGIT_INIT(180), \ + _PyLong_DIGIT_INIT(181), \ + _PyLong_DIGIT_INIT(182), \ + _PyLong_DIGIT_INIT(183), \ + _PyLong_DIGIT_INIT(184), \ + _PyLong_DIGIT_INIT(185), \ + _PyLong_DIGIT_INIT(186), \ + _PyLong_DIGIT_INIT(187), \ + _PyLong_DIGIT_INIT(188), \ + _PyLong_DIGIT_INIT(189), \ + _PyLong_DIGIT_INIT(190), \ + _PyLong_DIGIT_INIT(191), \ + _PyLong_DIGIT_INIT(192), \ + _PyLong_DIGIT_INIT(193), \ + _PyLong_DIGIT_INIT(194), \ + _PyLong_DIGIT_INIT(195), \ + _PyLong_DIGIT_INIT(196), \ + _PyLong_DIGIT_INIT(197), \ + _PyLong_DIGIT_INIT(198), \ + _PyLong_DIGIT_INIT(199), \ + _PyLong_DIGIT_INIT(200), \ + _PyLong_DIGIT_INIT(201), \ + _PyLong_DIGIT_INIT(202), \ + _PyLong_DIGIT_INIT(203), \ + _PyLong_DIGIT_INIT(204), \ + _PyLong_DIGIT_INIT(205), \ + _PyLong_DIGIT_INIT(206), \ + _PyLong_DIGIT_INIT(207), \ + _PyLong_DIGIT_INIT(208), \ + _PyLong_DIGIT_INIT(209), \ + _PyLong_DIGIT_INIT(210), \ + _PyLong_DIGIT_INIT(211), \ + _PyLong_DIGIT_INIT(212), \ + _PyLong_DIGIT_INIT(213), \ + _PyLong_DIGIT_INIT(214), \ + _PyLong_DIGIT_INIT(215), \ + _PyLong_DIGIT_INIT(216), \ + _PyLong_DIGIT_INIT(217), \ + _PyLong_DIGIT_INIT(218), \ + _PyLong_DIGIT_INIT(219), \ + _PyLong_DIGIT_INIT(220), \ + _PyLong_DIGIT_INIT(221), \ + _PyLong_DIGIT_INIT(222), \ + _PyLong_DIGIT_INIT(223), \ + _PyLong_DIGIT_INIT(224), \ + _PyLong_DIGIT_INIT(225), \ + _PyLong_DIGIT_INIT(226), \ + _PyLong_DIGIT_INIT(227), \ + _PyLong_DIGIT_INIT(228), \ + _PyLong_DIGIT_INIT(229), \ + _PyLong_DIGIT_INIT(230), \ + _PyLong_DIGIT_INIT(231), \ + _PyLong_DIGIT_INIT(232), \ + _PyLong_DIGIT_INIT(233), \ + _PyLong_DIGIT_INIT(234), \ + _PyLong_DIGIT_INIT(235), \ + _PyLong_DIGIT_INIT(236), \ + _PyLong_DIGIT_INIT(237), \ + _PyLong_DIGIT_INIT(238), \ + _PyLong_DIGIT_INIT(239), \ + _PyLong_DIGIT_INIT(240), \ + _PyLong_DIGIT_INIT(241), \ + _PyLong_DIGIT_INIT(242), \ + _PyLong_DIGIT_INIT(243), \ + _PyLong_DIGIT_INIT(244), \ + _PyLong_DIGIT_INIT(245), \ + _PyLong_DIGIT_INIT(246), \ + _PyLong_DIGIT_INIT(247), \ + _PyLong_DIGIT_INIT(248), \ + _PyLong_DIGIT_INIT(249), \ + _PyLong_DIGIT_INIT(250), \ + _PyLong_DIGIT_INIT(251), \ + _PyLong_DIGIT_INIT(252), \ + _PyLong_DIGIT_INIT(253), \ + _PyLong_DIGIT_INIT(254), \ + _PyLong_DIGIT_INIT(255), \ + _PyLong_DIGIT_INIT(256), \ +} + +#define _Py_bytes_characters_INIT { \ + _PyBytes_CHAR_INIT(0), \ + _PyBytes_CHAR_INIT(1), \ + _PyBytes_CHAR_INIT(2), \ + _PyBytes_CHAR_INIT(3), \ + _PyBytes_CHAR_INIT(4), \ + _PyBytes_CHAR_INIT(5), \ + _PyBytes_CHAR_INIT(6), \ + _PyBytes_CHAR_INIT(7), \ + _PyBytes_CHAR_INIT(8), \ + _PyBytes_CHAR_INIT(9), \ + _PyBytes_CHAR_INIT(10), \ + _PyBytes_CHAR_INIT(11), \ + _PyBytes_CHAR_INIT(12), \ + _PyBytes_CHAR_INIT(13), \ + _PyBytes_CHAR_INIT(14), \ + _PyBytes_CHAR_INIT(15), \ + _PyBytes_CHAR_INIT(16), \ + _PyBytes_CHAR_INIT(17), \ + _PyBytes_CHAR_INIT(18), \ + _PyBytes_CHAR_INIT(19), \ + _PyBytes_CHAR_INIT(20), \ + _PyBytes_CHAR_INIT(21), \ + _PyBytes_CHAR_INIT(22), \ + _PyBytes_CHAR_INIT(23), \ + _PyBytes_CHAR_INIT(24), \ + _PyBytes_CHAR_INIT(25), \ + _PyBytes_CHAR_INIT(26), \ + _PyBytes_CHAR_INIT(27), \ + _PyBytes_CHAR_INIT(28), \ + _PyBytes_CHAR_INIT(29), \ + _PyBytes_CHAR_INIT(30), \ + _PyBytes_CHAR_INIT(31), \ + _PyBytes_CHAR_INIT(32), \ + _PyBytes_CHAR_INIT(33), \ + _PyBytes_CHAR_INIT(34), \ + _PyBytes_CHAR_INIT(35), \ + _PyBytes_CHAR_INIT(36), \ + _PyBytes_CHAR_INIT(37), \ + _PyBytes_CHAR_INIT(38), \ + _PyBytes_CHAR_INIT(39), \ + _PyBytes_CHAR_INIT(40), \ + _PyBytes_CHAR_INIT(41), \ + _PyBytes_CHAR_INIT(42), \ + _PyBytes_CHAR_INIT(43), \ + _PyBytes_CHAR_INIT(44), \ + _PyBytes_CHAR_INIT(45), \ + _PyBytes_CHAR_INIT(46), \ + _PyBytes_CHAR_INIT(47), \ + _PyBytes_CHAR_INIT(48), \ + _PyBytes_CHAR_INIT(49), \ + _PyBytes_CHAR_INIT(50), \ + _PyBytes_CHAR_INIT(51), \ + _PyBytes_CHAR_INIT(52), \ + _PyBytes_CHAR_INIT(53), \ + _PyBytes_CHAR_INIT(54), \ + _PyBytes_CHAR_INIT(55), \ + _PyBytes_CHAR_INIT(56), \ + _PyBytes_CHAR_INIT(57), \ + _PyBytes_CHAR_INIT(58), \ + _PyBytes_CHAR_INIT(59), \ + _PyBytes_CHAR_INIT(60), \ + _PyBytes_CHAR_INIT(61), \ + _PyBytes_CHAR_INIT(62), \ + _PyBytes_CHAR_INIT(63), \ + _PyBytes_CHAR_INIT(64), \ + _PyBytes_CHAR_INIT(65), \ + _PyBytes_CHAR_INIT(66), \ + _PyBytes_CHAR_INIT(67), \ + _PyBytes_CHAR_INIT(68), \ + _PyBytes_CHAR_INIT(69), \ + _PyBytes_CHAR_INIT(70), \ + _PyBytes_CHAR_INIT(71), \ + _PyBytes_CHAR_INIT(72), \ + _PyBytes_CHAR_INIT(73), \ + _PyBytes_CHAR_INIT(74), \ + _PyBytes_CHAR_INIT(75), \ + _PyBytes_CHAR_INIT(76), \ + _PyBytes_CHAR_INIT(77), \ + _PyBytes_CHAR_INIT(78), \ + _PyBytes_CHAR_INIT(79), \ + _PyBytes_CHAR_INIT(80), \ + _PyBytes_CHAR_INIT(81), \ + _PyBytes_CHAR_INIT(82), \ + _PyBytes_CHAR_INIT(83), \ + _PyBytes_CHAR_INIT(84), \ + _PyBytes_CHAR_INIT(85), \ + _PyBytes_CHAR_INIT(86), \ + _PyBytes_CHAR_INIT(87), \ + _PyBytes_CHAR_INIT(88), \ + _PyBytes_CHAR_INIT(89), \ + _PyBytes_CHAR_INIT(90), \ + _PyBytes_CHAR_INIT(91), \ + _PyBytes_CHAR_INIT(92), \ + _PyBytes_CHAR_INIT(93), \ + _PyBytes_CHAR_INIT(94), \ + _PyBytes_CHAR_INIT(95), \ + _PyBytes_CHAR_INIT(96), \ + _PyBytes_CHAR_INIT(97), \ + _PyBytes_CHAR_INIT(98), \ + _PyBytes_CHAR_INIT(99), \ + _PyBytes_CHAR_INIT(100), \ + _PyBytes_CHAR_INIT(101), \ + _PyBytes_CHAR_INIT(102), \ + _PyBytes_CHAR_INIT(103), \ + _PyBytes_CHAR_INIT(104), \ + _PyBytes_CHAR_INIT(105), \ + _PyBytes_CHAR_INIT(106), \ + _PyBytes_CHAR_INIT(107), \ + _PyBytes_CHAR_INIT(108), \ + _PyBytes_CHAR_INIT(109), \ + _PyBytes_CHAR_INIT(110), \ + _PyBytes_CHAR_INIT(111), \ + _PyBytes_CHAR_INIT(112), \ + _PyBytes_CHAR_INIT(113), \ + _PyBytes_CHAR_INIT(114), \ + _PyBytes_CHAR_INIT(115), \ + _PyBytes_CHAR_INIT(116), \ + _PyBytes_CHAR_INIT(117), \ + _PyBytes_CHAR_INIT(118), \ + _PyBytes_CHAR_INIT(119), \ + _PyBytes_CHAR_INIT(120), \ + _PyBytes_CHAR_INIT(121), \ + _PyBytes_CHAR_INIT(122), \ + _PyBytes_CHAR_INIT(123), \ + _PyBytes_CHAR_INIT(124), \ + _PyBytes_CHAR_INIT(125), \ + _PyBytes_CHAR_INIT(126), \ + _PyBytes_CHAR_INIT(127), \ + _PyBytes_CHAR_INIT(128), \ + _PyBytes_CHAR_INIT(129), \ + _PyBytes_CHAR_INIT(130), \ + _PyBytes_CHAR_INIT(131), \ + _PyBytes_CHAR_INIT(132), \ + _PyBytes_CHAR_INIT(133), \ + _PyBytes_CHAR_INIT(134), \ + _PyBytes_CHAR_INIT(135), \ + _PyBytes_CHAR_INIT(136), \ + _PyBytes_CHAR_INIT(137), \ + _PyBytes_CHAR_INIT(138), \ + _PyBytes_CHAR_INIT(139), \ + _PyBytes_CHAR_INIT(140), \ + _PyBytes_CHAR_INIT(141), \ + _PyBytes_CHAR_INIT(142), \ + _PyBytes_CHAR_INIT(143), \ + _PyBytes_CHAR_INIT(144), \ + _PyBytes_CHAR_INIT(145), \ + _PyBytes_CHAR_INIT(146), \ + _PyBytes_CHAR_INIT(147), \ + _PyBytes_CHAR_INIT(148), \ + _PyBytes_CHAR_INIT(149), \ + _PyBytes_CHAR_INIT(150), \ + _PyBytes_CHAR_INIT(151), \ + _PyBytes_CHAR_INIT(152), \ + _PyBytes_CHAR_INIT(153), \ + _PyBytes_CHAR_INIT(154), \ + _PyBytes_CHAR_INIT(155), \ + _PyBytes_CHAR_INIT(156), \ + _PyBytes_CHAR_INIT(157), \ + _PyBytes_CHAR_INIT(158), \ + _PyBytes_CHAR_INIT(159), \ + _PyBytes_CHAR_INIT(160), \ + _PyBytes_CHAR_INIT(161), \ + _PyBytes_CHAR_INIT(162), \ + _PyBytes_CHAR_INIT(163), \ + _PyBytes_CHAR_INIT(164), \ + _PyBytes_CHAR_INIT(165), \ + _PyBytes_CHAR_INIT(166), \ + _PyBytes_CHAR_INIT(167), \ + _PyBytes_CHAR_INIT(168), \ + _PyBytes_CHAR_INIT(169), \ + _PyBytes_CHAR_INIT(170), \ + _PyBytes_CHAR_INIT(171), \ + _PyBytes_CHAR_INIT(172), \ + _PyBytes_CHAR_INIT(173), \ + _PyBytes_CHAR_INIT(174), \ + _PyBytes_CHAR_INIT(175), \ + _PyBytes_CHAR_INIT(176), \ + _PyBytes_CHAR_INIT(177), \ + _PyBytes_CHAR_INIT(178), \ + _PyBytes_CHAR_INIT(179), \ + _PyBytes_CHAR_INIT(180), \ + _PyBytes_CHAR_INIT(181), \ + _PyBytes_CHAR_INIT(182), \ + _PyBytes_CHAR_INIT(183), \ + _PyBytes_CHAR_INIT(184), \ + _PyBytes_CHAR_INIT(185), \ + _PyBytes_CHAR_INIT(186), \ + _PyBytes_CHAR_INIT(187), \ + _PyBytes_CHAR_INIT(188), \ + _PyBytes_CHAR_INIT(189), \ + _PyBytes_CHAR_INIT(190), \ + _PyBytes_CHAR_INIT(191), \ + _PyBytes_CHAR_INIT(192), \ + _PyBytes_CHAR_INIT(193), \ + _PyBytes_CHAR_INIT(194), \ + _PyBytes_CHAR_INIT(195), \ + _PyBytes_CHAR_INIT(196), \ + _PyBytes_CHAR_INIT(197), \ + _PyBytes_CHAR_INIT(198), \ + _PyBytes_CHAR_INIT(199), \ + _PyBytes_CHAR_INIT(200), \ + _PyBytes_CHAR_INIT(201), \ + _PyBytes_CHAR_INIT(202), \ + _PyBytes_CHAR_INIT(203), \ + _PyBytes_CHAR_INIT(204), \ + _PyBytes_CHAR_INIT(205), \ + _PyBytes_CHAR_INIT(206), \ + _PyBytes_CHAR_INIT(207), \ + _PyBytes_CHAR_INIT(208), \ + _PyBytes_CHAR_INIT(209), \ + _PyBytes_CHAR_INIT(210), \ + _PyBytes_CHAR_INIT(211), \ + _PyBytes_CHAR_INIT(212), \ + _PyBytes_CHAR_INIT(213), \ + _PyBytes_CHAR_INIT(214), \ + _PyBytes_CHAR_INIT(215), \ + _PyBytes_CHAR_INIT(216), \ + _PyBytes_CHAR_INIT(217), \ + _PyBytes_CHAR_INIT(218), \ + _PyBytes_CHAR_INIT(219), \ + _PyBytes_CHAR_INIT(220), \ + _PyBytes_CHAR_INIT(221), \ + _PyBytes_CHAR_INIT(222), \ + _PyBytes_CHAR_INIT(223), \ + _PyBytes_CHAR_INIT(224), \ + _PyBytes_CHAR_INIT(225), \ + _PyBytes_CHAR_INIT(226), \ + _PyBytes_CHAR_INIT(227), \ + _PyBytes_CHAR_INIT(228), \ + _PyBytes_CHAR_INIT(229), \ + _PyBytes_CHAR_INIT(230), \ + _PyBytes_CHAR_INIT(231), \ + _PyBytes_CHAR_INIT(232), \ + _PyBytes_CHAR_INIT(233), \ + _PyBytes_CHAR_INIT(234), \ + _PyBytes_CHAR_INIT(235), \ + _PyBytes_CHAR_INIT(236), \ + _PyBytes_CHAR_INIT(237), \ + _PyBytes_CHAR_INIT(238), \ + _PyBytes_CHAR_INIT(239), \ + _PyBytes_CHAR_INIT(240), \ + _PyBytes_CHAR_INIT(241), \ + _PyBytes_CHAR_INIT(242), \ + _PyBytes_CHAR_INIT(243), \ + _PyBytes_CHAR_INIT(244), \ + _PyBytes_CHAR_INIT(245), \ + _PyBytes_CHAR_INIT(246), \ + _PyBytes_CHAR_INIT(247), \ + _PyBytes_CHAR_INIT(248), \ + _PyBytes_CHAR_INIT(249), \ + _PyBytes_CHAR_INIT(250), \ + _PyBytes_CHAR_INIT(251), \ + _PyBytes_CHAR_INIT(252), \ + _PyBytes_CHAR_INIT(253), \ + _PyBytes_CHAR_INIT(254), \ + _PyBytes_CHAR_INIT(255), \ +} + +#define _Py_str_literals_INIT { \ + INIT_STR(anon_dictcomp, ""), \ + INIT_STR(anon_genexpr, ""), \ + INIT_STR(anon_lambda, ""), \ + INIT_STR(anon_listcomp, ""), \ + INIT_STR(anon_module, ""), \ + INIT_STR(anon_null, ""), \ + INIT_STR(anon_setcomp, ""), \ + INIT_STR(anon_string, ""), \ + INIT_STR(anon_unknown, ""), \ + INIT_STR(dbl_close_br, "}}"), \ + INIT_STR(dbl_open_br, "{{"), \ + INIT_STR(dbl_percent, "%%"), \ + INIT_STR(defaults, ".defaults"), \ + INIT_STR(dot_locals, "."), \ + INIT_STR(empty, ""), \ + INIT_STR(format, ".format"), \ + INIT_STR(generic_base, ".generic_base"), \ + INIT_STR(json_decoder, "json.decoder"), \ + INIT_STR(kwdefaults, ".kwdefaults"), \ + INIT_STR(list_err, "list index out of range"), \ + INIT_STR(str_replace_inf, "1e309"), \ + INIT_STR(type_params, ".type_params"), \ + INIT_STR(utf_8, "utf-8"), \ +} + +#define _Py_str_identifiers_INIT { \ + INIT_ID(CANCELLED), \ + INIT_ID(FINISHED), \ + INIT_ID(False), \ + INIT_ID(JSONDecodeError), \ + INIT_ID(PENDING), \ + INIT_ID(Py_Repr), \ + INIT_ID(TextIOWrapper), \ + INIT_ID(True), \ + INIT_ID(WarningMessage), \ + INIT_ID(_WindowsConsoleIO), \ + INIT_ID(__IOBase_closed), \ + INIT_ID(__abc_tpflags__), \ + INIT_ID(__abs__), \ + INIT_ID(__abstractmethods__), \ + INIT_ID(__add__), \ + INIT_ID(__aenter__), \ + INIT_ID(__aexit__), \ + INIT_ID(__aiter__), \ + INIT_ID(__all__), \ + INIT_ID(__and__), \ + INIT_ID(__anext__), \ + INIT_ID(__annotate__), \ + INIT_ID(__annotate_func__), \ + INIT_ID(__annotations__), \ + INIT_ID(__annotations_cache__), \ + INIT_ID(__args__), \ + INIT_ID(__await__), \ + INIT_ID(__bases__), \ + INIT_ID(__bool__), \ + INIT_ID(__buffer__), \ + INIT_ID(__build_class__), \ + INIT_ID(__builtins__), \ + INIT_ID(__bytes__), \ + INIT_ID(__call__), \ + INIT_ID(__cantrace__), \ + INIT_ID(__ceil__), \ + INIT_ID(__class__), \ + INIT_ID(__class_getitem__), \ + INIT_ID(__classcell__), \ + INIT_ID(__classdict__), \ + INIT_ID(__classdictcell__), \ + INIT_ID(__complex__), \ + INIT_ID(__conditional_annotations__), \ + INIT_ID(__contains__), \ + INIT_ID(__ctypes_from_outparam__), \ + INIT_ID(__del__), \ + INIT_ID(__delattr__), \ + INIT_ID(__delete__), \ + INIT_ID(__delitem__), \ + INIT_ID(__dict__), \ + INIT_ID(__dictoffset__), \ + INIT_ID(__dir__), \ + INIT_ID(__divmod__), \ + INIT_ID(__doc__), \ + INIT_ID(__enter__), \ + INIT_ID(__eq__), \ + INIT_ID(__exit__), \ + INIT_ID(__file__), \ + INIT_ID(__firstlineno__), \ + INIT_ID(__float__), \ + INIT_ID(__floor__), \ + INIT_ID(__floordiv__), \ + INIT_ID(__format__), \ + INIT_ID(__fspath__), \ + INIT_ID(__ge__), \ + INIT_ID(__get__), \ + INIT_ID(__getattr__), \ + INIT_ID(__getattribute__), \ + INIT_ID(__getinitargs__), \ + INIT_ID(__getitem__), \ + INIT_ID(__getnewargs__), \ + INIT_ID(__getnewargs_ex__), \ + INIT_ID(__getstate__), \ + INIT_ID(__gt__), \ + INIT_ID(__hash__), \ + INIT_ID(__iadd__), \ + INIT_ID(__iand__), \ + INIT_ID(__ifloordiv__), \ + INIT_ID(__ilshift__), \ + INIT_ID(__imatmul__), \ + INIT_ID(__imod__), \ + INIT_ID(__import__), \ + INIT_ID(__imul__), \ + INIT_ID(__index__), \ + INIT_ID(__init__), \ + INIT_ID(__init_subclass__), \ + INIT_ID(__instancecheck__), \ + INIT_ID(__int__), \ + INIT_ID(__invert__), \ + INIT_ID(__ior__), \ + INIT_ID(__ipow__), \ + INIT_ID(__irshift__), \ + INIT_ID(__isabstractmethod__), \ + INIT_ID(__isub__), \ + INIT_ID(__iter__), \ + INIT_ID(__itruediv__), \ + INIT_ID(__ixor__), \ + INIT_ID(__le__), \ + INIT_ID(__len__), \ + INIT_ID(__length_hint__), \ + INIT_ID(__lltrace__), \ + INIT_ID(__loader__), \ + INIT_ID(__lshift__), \ + INIT_ID(__lt__), \ + INIT_ID(__main__), \ + INIT_ID(__match_args__), \ + INIT_ID(__matmul__), \ + INIT_ID(__missing__), \ + INIT_ID(__mod__), \ + INIT_ID(__module__), \ + INIT_ID(__mro_entries__), \ + INIT_ID(__mul__), \ + INIT_ID(__name__), \ + INIT_ID(__ne__), \ + INIT_ID(__neg__), \ + INIT_ID(__new__), \ + INIT_ID(__newobj__), \ + INIT_ID(__newobj_ex__), \ + INIT_ID(__next__), \ + INIT_ID(__notes__), \ + INIT_ID(__or__), \ + INIT_ID(__orig_class__), \ + INIT_ID(__origin__), \ + INIT_ID(__package__), \ + INIT_ID(__parameters__), \ + INIT_ID(__path__), \ + INIT_ID(__pos__), \ + INIT_ID(__pow__), \ + INIT_ID(__prepare__), \ + INIT_ID(__qualname__), \ + INIT_ID(__radd__), \ + INIT_ID(__rand__), \ + INIT_ID(__rdivmod__), \ + INIT_ID(__reduce__), \ + INIT_ID(__reduce_ex__), \ + INIT_ID(__release_buffer__), \ + INIT_ID(__repr__), \ + INIT_ID(__reversed__), \ + INIT_ID(__rfloordiv__), \ + INIT_ID(__rlshift__), \ + INIT_ID(__rmatmul__), \ + INIT_ID(__rmod__), \ + INIT_ID(__rmul__), \ + INIT_ID(__ror__), \ + INIT_ID(__round__), \ + INIT_ID(__rpow__), \ + INIT_ID(__rrshift__), \ + INIT_ID(__rshift__), \ + INIT_ID(__rsub__), \ + INIT_ID(__rtruediv__), \ + INIT_ID(__rxor__), \ + INIT_ID(__set__), \ + INIT_ID(__set_name__), \ + INIT_ID(__setattr__), \ + INIT_ID(__setitem__), \ + INIT_ID(__setstate__), \ + INIT_ID(__sizeof__), \ + INIT_ID(__slotnames__), \ + INIT_ID(__slots__), \ + INIT_ID(__spec__), \ + INIT_ID(__static_attributes__), \ + INIT_ID(__str__), \ + INIT_ID(__sub__), \ + INIT_ID(__subclasscheck__), \ + INIT_ID(__subclasshook__), \ + INIT_ID(__truediv__), \ + INIT_ID(__trunc__), \ + INIT_ID(__type_params__), \ + INIT_ID(__typing_is_unpacked_typevartuple__), \ + INIT_ID(__typing_prepare_subst__), \ + INIT_ID(__typing_subst__), \ + INIT_ID(__typing_unpacked_tuple_args__), \ + INIT_ID(__warningregistry__), \ + INIT_ID(__weaklistoffset__), \ + INIT_ID(__weakref__), \ + INIT_ID(__xor__), \ + INIT_ID(_abc_impl), \ + INIT_ID(_abstract_), \ + INIT_ID(_active), \ + INIT_ID(_anonymous_), \ + INIT_ID(_argtypes_), \ + INIT_ID(_as_parameter_), \ + INIT_ID(_asyncio_future_blocking), \ + INIT_ID(_blksize), \ + INIT_ID(_bootstrap), \ + INIT_ID(_check_retval_), \ + INIT_ID(_dealloc_warn), \ + INIT_ID(_feature_version), \ + INIT_ID(_field_types), \ + INIT_ID(_fields_), \ + INIT_ID(_filters), \ + INIT_ID(_finalizing), \ + INIT_ID(_find_and_load), \ + INIT_ID(_fix_up_module), \ + INIT_ID(_flags_), \ + INIT_ID(_get_sourcefile), \ + INIT_ID(_handle_fromlist), \ + INIT_ID(_initializing), \ + INIT_ID(_internal_use), \ + INIT_ID(_io), \ + INIT_ID(_is_text_encoding), \ + INIT_ID(_isatty_open_only), \ + INIT_ID(_length_), \ + INIT_ID(_limbo), \ + INIT_ID(_lock_unlock_module), \ + INIT_ID(_loop), \ + INIT_ID(_needs_com_addref_), \ + INIT_ID(_only_immortal), \ + INIT_ID(_restype_), \ + INIT_ID(_showwarnmsg), \ + INIT_ID(_shutdown), \ + INIT_ID(_slotnames), \ + INIT_ID(_strptime), \ + INIT_ID(_strptime_datetime_date), \ + INIT_ID(_strptime_datetime_datetime), \ + INIT_ID(_strptime_datetime_time), \ + INIT_ID(_type_), \ + INIT_ID(_uninitialized_submodules), \ + INIT_ID(_warn_unawaited_coroutine), \ + INIT_ID(_xoptions), \ + INIT_ID(abs_tol), \ + INIT_ID(access), \ + INIT_ID(aclose), \ + INIT_ID(add), \ + INIT_ID(add_done_callback), \ + INIT_ID(after_in_child), \ + INIT_ID(after_in_parent), \ + INIT_ID(aggregate_class), \ + INIT_ID(alias), \ + INIT_ID(align), \ + INIT_ID(all), \ + INIT_ID(all_threads), \ + INIT_ID(allow_code), \ + INIT_ID(any), \ + INIT_ID(append), \ + INIT_ID(arg), \ + INIT_ID(argdefs), \ + INIT_ID(args), \ + INIT_ID(arguments), \ + INIT_ID(argv), \ + INIT_ID(as_integer_ratio), \ + INIT_ID(asend), \ + INIT_ID(ast), \ + INIT_ID(athrow), \ + INIT_ID(attribute), \ + INIT_ID(authorizer_callback), \ + INIT_ID(autocommit), \ + INIT_ID(backtick), \ + INIT_ID(base), \ + INIT_ID(before), \ + INIT_ID(big), \ + INIT_ID(binary_form), \ + INIT_ID(bit_offset), \ + INIT_ID(bit_size), \ + INIT_ID(block), \ + INIT_ID(bound), \ + INIT_ID(buffer), \ + INIT_ID(buffer_callback), \ + INIT_ID(buffer_size), \ + INIT_ID(buffering), \ + INIT_ID(buffers), \ + INIT_ID(bufsize), \ + INIT_ID(builtins), \ + INIT_ID(byte_offset), \ + INIT_ID(byte_size), \ + INIT_ID(byteorder), \ + INIT_ID(bytes), \ + INIT_ID(bytes_per_sep), \ + INIT_ID(c_call), \ + INIT_ID(c_exception), \ + INIT_ID(c_parameter_type), \ + INIT_ID(c_return), \ + INIT_ID(cached_datetime_module), \ + INIT_ID(cached_statements), \ + INIT_ID(cadata), \ + INIT_ID(cafile), \ + INIT_ID(call), \ + INIT_ID(call_exception_handler), \ + INIT_ID(call_soon), \ + INIT_ID(callback), \ + INIT_ID(cancel), \ + INIT_ID(capath), \ + INIT_ID(category), \ + INIT_ID(cb_type), \ + INIT_ID(certfile), \ + INIT_ID(check_same_thread), \ + INIT_ID(clear), \ + INIT_ID(close), \ + INIT_ID(closed), \ + INIT_ID(closefd), \ + INIT_ID(closure), \ + INIT_ID(co_argcount), \ + INIT_ID(co_cellvars), \ + INIT_ID(co_code), \ + INIT_ID(co_consts), \ + INIT_ID(co_exceptiontable), \ + INIT_ID(co_filename), \ + INIT_ID(co_firstlineno), \ + INIT_ID(co_flags), \ + INIT_ID(co_freevars), \ + INIT_ID(co_kwonlyargcount), \ + INIT_ID(co_linetable), \ + INIT_ID(co_name), \ + INIT_ID(co_names), \ + INIT_ID(co_nlocals), \ + INIT_ID(co_posonlyargcount), \ + INIT_ID(co_qualname), \ + INIT_ID(co_stacksize), \ + INIT_ID(co_varnames), \ + INIT_ID(code), \ + INIT_ID(col_offset), \ + INIT_ID(command), \ + INIT_ID(comment_factory), \ + INIT_ID(compile_mode), \ + INIT_ID(consts), \ + INIT_ID(context), \ + INIT_ID(contravariant), \ + INIT_ID(conversion), \ + INIT_ID(cookie), \ + INIT_ID(copy), \ + INIT_ID(copyreg), \ + INIT_ID(coro), \ + INIT_ID(count), \ + INIT_ID(covariant), \ + INIT_ID(cwd), \ + INIT_ID(d_parameter_type), \ + INIT_ID(data), \ + INIT_ID(database), \ + INIT_ID(day), \ + INIT_ID(debug), \ + INIT_ID(decode), \ + INIT_ID(decoder), \ + INIT_ID(default), \ + INIT_ID(defaultaction), \ + INIT_ID(delete), \ + INIT_ID(depth), \ + INIT_ID(desired_access), \ + INIT_ID(detect_types), \ + INIT_ID(deterministic), \ + INIT_ID(device), \ + INIT_ID(dict), \ + INIT_ID(dictcomp), \ + INIT_ID(difference_update), \ + INIT_ID(digest), \ + INIT_ID(digest_size), \ + INIT_ID(digestmod), \ + INIT_ID(dir_fd), \ + INIT_ID(discard), \ + INIT_ID(dispatch_table), \ + INIT_ID(displayhook), \ + INIT_ID(dklen), \ + INIT_ID(doc), \ + INIT_ID(done), \ + INIT_ID(dont_inherit), \ + INIT_ID(dst), \ + INIT_ID(dst_dir_fd), \ + INIT_ID(eager_start), \ + INIT_ID(effective_ids), \ + INIT_ID(element_factory), \ + INIT_ID(encode), \ + INIT_ID(encoding), \ + INIT_ID(end), \ + INIT_ID(end_col_offset), \ + INIT_ID(end_lineno), \ + INIT_ID(end_offset), \ + INIT_ID(endpos), \ + INIT_ID(entrypoint), \ + INIT_ID(env), \ + INIT_ID(errors), \ + INIT_ID(event), \ + INIT_ID(eventmask), \ + INIT_ID(exc_type), \ + INIT_ID(exc_value), \ + INIT_ID(excepthook), \ + INIT_ID(exception), \ + INIT_ID(existing_file_name), \ + INIT_ID(exp), \ + INIT_ID(expression), \ + INIT_ID(extend), \ + INIT_ID(extra_tokens), \ + INIT_ID(facility), \ + INIT_ID(factory), \ + INIT_ID(false), \ + INIT_ID(family), \ + INIT_ID(fanout), \ + INIT_ID(fd), \ + INIT_ID(fd2), \ + INIT_ID(fdel), \ + INIT_ID(fget), \ + INIT_ID(fields), \ + INIT_ID(file), \ + INIT_ID(file_actions), \ + INIT_ID(filename), \ + INIT_ID(fileno), \ + INIT_ID(filepath), \ + INIT_ID(fillvalue), \ + INIT_ID(filter), \ + INIT_ID(filters), \ + INIT_ID(final), \ + INIT_ID(find_class), \ + INIT_ID(fix_imports), \ + INIT_ID(flags), \ + INIT_ID(flush), \ + INIT_ID(fold), \ + INIT_ID(follow_symlinks), \ + INIT_ID(format), \ + INIT_ID(format_spec), \ + INIT_ID(frame_buffer), \ + INIT_ID(from_param), \ + INIT_ID(fromlist), \ + INIT_ID(fromtimestamp), \ + INIT_ID(fromutc), \ + INIT_ID(fset), \ + INIT_ID(func), \ + INIT_ID(future), \ + INIT_ID(generation), \ + INIT_ID(genexpr), \ + INIT_ID(get), \ + INIT_ID(get_debug), \ + INIT_ID(get_event_loop), \ + INIT_ID(get_loop), \ + INIT_ID(get_source), \ + INIT_ID(getattr), \ + INIT_ID(getstate), \ + INIT_ID(gid), \ + INIT_ID(globals), \ + INIT_ID(groupindex), \ + INIT_ID(groups), \ + INIT_ID(handle), \ + INIT_ID(handle_seq), \ + INIT_ID(has_location), \ + INIT_ID(hash_name), \ + INIT_ID(header), \ + INIT_ID(headers), \ + INIT_ID(hi), \ + INIT_ID(hook), \ + INIT_ID(hour), \ + INIT_ID(id), \ + INIT_ID(ident), \ + INIT_ID(identity_hint), \ + INIT_ID(ignore), \ + INIT_ID(imag), \ + INIT_ID(importlib), \ + INIT_ID(in_fd), \ + INIT_ID(incoming), \ + INIT_ID(index), \ + INIT_ID(indexgroup), \ + INIT_ID(inf), \ + INIT_ID(infer_variance), \ + INIT_ID(inherit_handle), \ + INIT_ID(inheritable), \ + INIT_ID(initial), \ + INIT_ID(initial_bytes), \ + INIT_ID(initial_owner), \ + INIT_ID(initial_state), \ + INIT_ID(initial_value), \ + INIT_ID(initval), \ + INIT_ID(inner_size), \ + INIT_ID(input), \ + INIT_ID(insert_comments), \ + INIT_ID(insert_pis), \ + INIT_ID(instructions), \ + INIT_ID(intern), \ + INIT_ID(intersection), \ + INIT_ID(interval), \ + INIT_ID(io), \ + INIT_ID(is_compress), \ + INIT_ID(is_raw), \ + INIT_ID(is_running), \ + INIT_ID(is_struct), \ + INIT_ID(isatty), \ + INIT_ID(isinstance), \ + INIT_ID(isoformat), \ + INIT_ID(isolation_level), \ + INIT_ID(istext), \ + INIT_ID(item), \ + INIT_ID(items), \ + INIT_ID(iter), \ + INIT_ID(iterable), \ + INIT_ID(iterations), \ + INIT_ID(join), \ + INIT_ID(jump), \ + INIT_ID(keepends), \ + INIT_ID(key), \ + INIT_ID(keyfile), \ + INIT_ID(keys), \ + INIT_ID(kind), \ + INIT_ID(kw), \ + INIT_ID(kw1), \ + INIT_ID(kw2), \ + INIT_ID(kwdefaults), \ + INIT_ID(label), \ + INIT_ID(lambda), \ + INIT_ID(last), \ + INIT_ID(last_exc), \ + INIT_ID(last_node), \ + INIT_ID(last_traceback), \ + INIT_ID(last_type), \ + INIT_ID(last_value), \ + INIT_ID(latin1), \ + INIT_ID(leaf_size), \ + INIT_ID(len), \ + INIT_ID(length), \ + INIT_ID(level), \ + INIT_ID(limit), \ + INIT_ID(line), \ + INIT_ID(line_buffering), \ + INIT_ID(lineno), \ + INIT_ID(listcomp), \ + INIT_ID(little), \ + INIT_ID(lo), \ + INIT_ID(locale), \ + INIT_ID(locals), \ + INIT_ID(logoption), \ + INIT_ID(loop), \ + INIT_ID(manual_reset), \ + INIT_ID(mapping), \ + INIT_ID(match), \ + INIT_ID(max_length), \ + INIT_ID(maxdigits), \ + INIT_ID(maxevents), \ + INIT_ID(maxlen), \ + INIT_ID(maxmem), \ + INIT_ID(maxsplit), \ + INIT_ID(maxvalue), \ + INIT_ID(memLevel), \ + INIT_ID(memlimit), \ + INIT_ID(message), \ + INIT_ID(metaclass), \ + INIT_ID(metadata), \ + INIT_ID(method), \ + INIT_ID(microsecond), \ + INIT_ID(milliseconds), \ + INIT_ID(minute), \ + INIT_ID(mod), \ + INIT_ID(mode), \ + INIT_ID(module), \ + INIT_ID(module_globals), \ + INIT_ID(modules), \ + INIT_ID(month), \ + INIT_ID(mro), \ + INIT_ID(msg), \ + INIT_ID(mutex), \ + INIT_ID(mycmp), \ + INIT_ID(n_arg), \ + INIT_ID(n_fields), \ + INIT_ID(n_sequence_fields), \ + INIT_ID(n_unnamed_fields), \ + INIT_ID(name), \ + INIT_ID(name_from), \ + INIT_ID(namespace_separator), \ + INIT_ID(namespaces), \ + INIT_ID(narg), \ + INIT_ID(ndigits), \ + INIT_ID(nested), \ + INIT_ID(new_file_name), \ + INIT_ID(new_limit), \ + INIT_ID(newline), \ + INIT_ID(newlines), \ + INIT_ID(next), \ + INIT_ID(nlocals), \ + INIT_ID(node_depth), \ + INIT_ID(node_offset), \ + INIT_ID(ns), \ + INIT_ID(nstype), \ + INIT_ID(nt), \ + INIT_ID(null), \ + INIT_ID(number), \ + INIT_ID(obj), \ + INIT_ID(object), \ + INIT_ID(offset), \ + INIT_ID(offset_dst), \ + INIT_ID(offset_src), \ + INIT_ID(on_type_read), \ + INIT_ID(onceregistry), \ + INIT_ID(only_active_thread), \ + INIT_ID(only_keys), \ + INIT_ID(oparg), \ + INIT_ID(opcode), \ + INIT_ID(open), \ + INIT_ID(opener), \ + INIT_ID(operation), \ + INIT_ID(optimize), \ + INIT_ID(options), \ + INIT_ID(order), \ + INIT_ID(origin), \ + INIT_ID(out_fd), \ + INIT_ID(outgoing), \ + INIT_ID(outpath), \ + INIT_ID(overlapped), \ + INIT_ID(owner), \ + INIT_ID(pages), \ + INIT_ID(parameter), \ + INIT_ID(parent), \ + INIT_ID(password), \ + INIT_ID(path), \ + INIT_ID(pattern), \ + INIT_ID(peek), \ + INIT_ID(persistent_id), \ + INIT_ID(persistent_load), \ + INIT_ID(person), \ + INIT_ID(pi_factory), \ + INIT_ID(pid), \ + INIT_ID(policy), \ + INIT_ID(pos), \ + INIT_ID(pos1), \ + INIT_ID(pos2), \ + INIT_ID(posix), \ + INIT_ID(print_file_and_line), \ + INIT_ID(priority), \ + INIT_ID(progress), \ + INIT_ID(progress_handler), \ + INIT_ID(progress_routine), \ + INIT_ID(proto), \ + INIT_ID(protocol), \ + INIT_ID(ps1), \ + INIT_ID(ps2), \ + INIT_ID(query), \ + INIT_ID(quotetabs), \ + INIT_ID(raw), \ + INIT_ID(read), \ + INIT_ID(read1), \ + INIT_ID(readable), \ + INIT_ID(readall), \ + INIT_ID(readinto), \ + INIT_ID(readinto1), \ + INIT_ID(readline), \ + INIT_ID(readonly), \ + INIT_ID(real), \ + INIT_ID(reducer_override), \ + INIT_ID(registry), \ + INIT_ID(rel_tol), \ + INIT_ID(release), \ + INIT_ID(reload), \ + INIT_ID(repl), \ + INIT_ID(replace), \ + INIT_ID(reserved), \ + INIT_ID(reset), \ + INIT_ID(resetids), \ + INIT_ID(return), \ + INIT_ID(reverse), \ + INIT_ID(reversed), \ + INIT_ID(salt), \ + INIT_ID(sched_priority), \ + INIT_ID(scheduler), \ + INIT_ID(script), \ + INIT_ID(second), \ + INIT_ID(security_attributes), \ + INIT_ID(seek), \ + INIT_ID(seekable), \ + INIT_ID(selectors), \ + INIT_ID(self), \ + INIT_ID(send), \ + INIT_ID(sep), \ + INIT_ID(sequence), \ + INIT_ID(server_hostname), \ + INIT_ID(server_side), \ + INIT_ID(session), \ + INIT_ID(setcomp), \ + INIT_ID(setpgroup), \ + INIT_ID(setsid), \ + INIT_ID(setsigdef), \ + INIT_ID(setsigmask), \ + INIT_ID(setstate), \ + INIT_ID(shape), \ + INIT_ID(show_cmd), \ + INIT_ID(signed), \ + INIT_ID(size), \ + INIT_ID(sizehint), \ + INIT_ID(skip_file_prefixes), \ + INIT_ID(sleep), \ + INIT_ID(sock), \ + INIT_ID(sort), \ + INIT_ID(source), \ + INIT_ID(source_traceback), \ + INIT_ID(spam), \ + INIT_ID(src), \ + INIT_ID(src_dir_fd), \ + INIT_ID(stacklevel), \ + INIT_ID(start), \ + INIT_ID(statement), \ + INIT_ID(status), \ + INIT_ID(stderr), \ + INIT_ID(stdin), \ + INIT_ID(stdout), \ + INIT_ID(step), \ + INIT_ID(steps), \ + INIT_ID(store_name), \ + INIT_ID(strategy), \ + INIT_ID(strftime), \ + INIT_ID(strict), \ + INIT_ID(strict_mode), \ + INIT_ID(string), \ + INIT_ID(sub_key), \ + INIT_ID(subcalls), \ + INIT_ID(symmetric_difference_update), \ + INIT_ID(tabsize), \ + INIT_ID(tag), \ + INIT_ID(target), \ + INIT_ID(target_is_directory), \ + INIT_ID(task), \ + INIT_ID(tb_frame), \ + INIT_ID(tb_lasti), \ + INIT_ID(tb_lineno), \ + INIT_ID(tb_next), \ + INIT_ID(tell), \ + INIT_ID(template), \ + INIT_ID(term), \ + INIT_ID(text), \ + INIT_ID(threading), \ + INIT_ID(throw), \ + INIT_ID(timeout), \ + INIT_ID(timer), \ + INIT_ID(times), \ + INIT_ID(timetuple), \ + INIT_ID(timeunit), \ + INIT_ID(top), \ + INIT_ID(trace_callback), \ + INIT_ID(traceback), \ + INIT_ID(trailers), \ + INIT_ID(translate), \ + INIT_ID(true), \ + INIT_ID(truncate), \ + INIT_ID(twice), \ + INIT_ID(txt), \ + INIT_ID(type), \ + INIT_ID(type_params), \ + INIT_ID(tz), \ + INIT_ID(tzinfo), \ + INIT_ID(tzname), \ + INIT_ID(uid), \ + INIT_ID(unlink), \ + INIT_ID(unraisablehook), \ + INIT_ID(uri), \ + INIT_ID(usedforsecurity), \ + INIT_ID(value), \ + INIT_ID(values), \ + INIT_ID(version), \ + INIT_ID(volume), \ + INIT_ID(wait_all), \ + INIT_ID(warn_on_full_buffer), \ + INIT_ID(warnings), \ + INIT_ID(warnoptions), \ + INIT_ID(wbits), \ + INIT_ID(week), \ + INIT_ID(weekday), \ + INIT_ID(which), \ + INIT_ID(who), \ + INIT_ID(withdata), \ + INIT_ID(writable), \ + INIT_ID(write), \ + INIT_ID(write_through), \ + INIT_ID(year), \ + INIT_ID(zdict), \ + INIT_ID(zstd_dict), \ +} + +#define _Py_str_ascii_INIT { \ + _PyASCIIObject_INIT("\x00"), \ + _PyASCIIObject_INIT("\x01"), \ + _PyASCIIObject_INIT("\x02"), \ + _PyASCIIObject_INIT("\x03"), \ + _PyASCIIObject_INIT("\x04"), \ + _PyASCIIObject_INIT("\x05"), \ + _PyASCIIObject_INIT("\x06"), \ + _PyASCIIObject_INIT("\x07"), \ + _PyASCIIObject_INIT("\x08"), \ + _PyASCIIObject_INIT("\x09"), \ + _PyASCIIObject_INIT("\x0a"), \ + _PyASCIIObject_INIT("\x0b"), \ + _PyASCIIObject_INIT("\x0c"), \ + _PyASCIIObject_INIT("\x0d"), \ + _PyASCIIObject_INIT("\x0e"), \ + _PyASCIIObject_INIT("\x0f"), \ + _PyASCIIObject_INIT("\x10"), \ + _PyASCIIObject_INIT("\x11"), \ + _PyASCIIObject_INIT("\x12"), \ + _PyASCIIObject_INIT("\x13"), \ + _PyASCIIObject_INIT("\x14"), \ + _PyASCIIObject_INIT("\x15"), \ + _PyASCIIObject_INIT("\x16"), \ + _PyASCIIObject_INIT("\x17"), \ + _PyASCIIObject_INIT("\x18"), \ + _PyASCIIObject_INIT("\x19"), \ + _PyASCIIObject_INIT("\x1a"), \ + _PyASCIIObject_INIT("\x1b"), \ + _PyASCIIObject_INIT("\x1c"), \ + _PyASCIIObject_INIT("\x1d"), \ + _PyASCIIObject_INIT("\x1e"), \ + _PyASCIIObject_INIT("\x1f"), \ + _PyASCIIObject_INIT("\x20"), \ + _PyASCIIObject_INIT("\x21"), \ + _PyASCIIObject_INIT("\x22"), \ + _PyASCIIObject_INIT("\x23"), \ + _PyASCIIObject_INIT("\x24"), \ + _PyASCIIObject_INIT("\x25"), \ + _PyASCIIObject_INIT("\x26"), \ + _PyASCIIObject_INIT("\x27"), \ + _PyASCIIObject_INIT("\x28"), \ + _PyASCIIObject_INIT("\x29"), \ + _PyASCIIObject_INIT("\x2a"), \ + _PyASCIIObject_INIT("\x2b"), \ + _PyASCIIObject_INIT("\x2c"), \ + _PyASCIIObject_INIT("\x2d"), \ + _PyASCIIObject_INIT("\x2e"), \ + _PyASCIIObject_INIT("\x2f"), \ + _PyASCIIObject_INIT("\x30"), \ + _PyASCIIObject_INIT("\x31"), \ + _PyASCIIObject_INIT("\x32"), \ + _PyASCIIObject_INIT("\x33"), \ + _PyASCIIObject_INIT("\x34"), \ + _PyASCIIObject_INIT("\x35"), \ + _PyASCIIObject_INIT("\x36"), \ + _PyASCIIObject_INIT("\x37"), \ + _PyASCIIObject_INIT("\x38"), \ + _PyASCIIObject_INIT("\x39"), \ + _PyASCIIObject_INIT("\x3a"), \ + _PyASCIIObject_INIT("\x3b"), \ + _PyASCIIObject_INIT("\x3c"), \ + _PyASCIIObject_INIT("\x3d"), \ + _PyASCIIObject_INIT("\x3e"), \ + _PyASCIIObject_INIT("\x3f"), \ + _PyASCIIObject_INIT("\x40"), \ + _PyASCIIObject_INIT("\x41"), \ + _PyASCIIObject_INIT("\x42"), \ + _PyASCIIObject_INIT("\x43"), \ + _PyASCIIObject_INIT("\x44"), \ + _PyASCIIObject_INIT("\x45"), \ + _PyASCIIObject_INIT("\x46"), \ + _PyASCIIObject_INIT("\x47"), \ + _PyASCIIObject_INIT("\x48"), \ + _PyASCIIObject_INIT("\x49"), \ + _PyASCIIObject_INIT("\x4a"), \ + _PyASCIIObject_INIT("\x4b"), \ + _PyASCIIObject_INIT("\x4c"), \ + _PyASCIIObject_INIT("\x4d"), \ + _PyASCIIObject_INIT("\x4e"), \ + _PyASCIIObject_INIT("\x4f"), \ + _PyASCIIObject_INIT("\x50"), \ + _PyASCIIObject_INIT("\x51"), \ + _PyASCIIObject_INIT("\x52"), \ + _PyASCIIObject_INIT("\x53"), \ + _PyASCIIObject_INIT("\x54"), \ + _PyASCIIObject_INIT("\x55"), \ + _PyASCIIObject_INIT("\x56"), \ + _PyASCIIObject_INIT("\x57"), \ + _PyASCIIObject_INIT("\x58"), \ + _PyASCIIObject_INIT("\x59"), \ + _PyASCIIObject_INIT("\x5a"), \ + _PyASCIIObject_INIT("\x5b"), \ + _PyASCIIObject_INIT("\x5c"), \ + _PyASCIIObject_INIT("\x5d"), \ + _PyASCIIObject_INIT("\x5e"), \ + _PyASCIIObject_INIT("\x5f"), \ + _PyASCIIObject_INIT("\x60"), \ + _PyASCIIObject_INIT("\x61"), \ + _PyASCIIObject_INIT("\x62"), \ + _PyASCIIObject_INIT("\x63"), \ + _PyASCIIObject_INIT("\x64"), \ + _PyASCIIObject_INIT("\x65"), \ + _PyASCIIObject_INIT("\x66"), \ + _PyASCIIObject_INIT("\x67"), \ + _PyASCIIObject_INIT("\x68"), \ + _PyASCIIObject_INIT("\x69"), \ + _PyASCIIObject_INIT("\x6a"), \ + _PyASCIIObject_INIT("\x6b"), \ + _PyASCIIObject_INIT("\x6c"), \ + _PyASCIIObject_INIT("\x6d"), \ + _PyASCIIObject_INIT("\x6e"), \ + _PyASCIIObject_INIT("\x6f"), \ + _PyASCIIObject_INIT("\x70"), \ + _PyASCIIObject_INIT("\x71"), \ + _PyASCIIObject_INIT("\x72"), \ + _PyASCIIObject_INIT("\x73"), \ + _PyASCIIObject_INIT("\x74"), \ + _PyASCIIObject_INIT("\x75"), \ + _PyASCIIObject_INIT("\x76"), \ + _PyASCIIObject_INIT("\x77"), \ + _PyASCIIObject_INIT("\x78"), \ + _PyASCIIObject_INIT("\x79"), \ + _PyASCIIObject_INIT("\x7a"), \ + _PyASCIIObject_INIT("\x7b"), \ + _PyASCIIObject_INIT("\x7c"), \ + _PyASCIIObject_INIT("\x7d"), \ + _PyASCIIObject_INIT("\x7e"), \ + _PyASCIIObject_INIT("\x7f"), \ +} + +#define _Py_str_latin1_INIT { \ + _PyUnicode_LATIN1_INIT("\x80", "\xc2\x80"), \ + _PyUnicode_LATIN1_INIT("\x81", "\xc2\x81"), \ + _PyUnicode_LATIN1_INIT("\x82", "\xc2\x82"), \ + _PyUnicode_LATIN1_INIT("\x83", "\xc2\x83"), \ + _PyUnicode_LATIN1_INIT("\x84", "\xc2\x84"), \ + _PyUnicode_LATIN1_INIT("\x85", "\xc2\x85"), \ + _PyUnicode_LATIN1_INIT("\x86", "\xc2\x86"), \ + _PyUnicode_LATIN1_INIT("\x87", "\xc2\x87"), \ + _PyUnicode_LATIN1_INIT("\x88", "\xc2\x88"), \ + _PyUnicode_LATIN1_INIT("\x89", "\xc2\x89"), \ + _PyUnicode_LATIN1_INIT("\x8a", "\xc2\x8a"), \ + _PyUnicode_LATIN1_INIT("\x8b", "\xc2\x8b"), \ + _PyUnicode_LATIN1_INIT("\x8c", "\xc2\x8c"), \ + _PyUnicode_LATIN1_INIT("\x8d", "\xc2\x8d"), \ + _PyUnicode_LATIN1_INIT("\x8e", "\xc2\x8e"), \ + _PyUnicode_LATIN1_INIT("\x8f", "\xc2\x8f"), \ + _PyUnicode_LATIN1_INIT("\x90", "\xc2\x90"), \ + _PyUnicode_LATIN1_INIT("\x91", "\xc2\x91"), \ + _PyUnicode_LATIN1_INIT("\x92", "\xc2\x92"), \ + _PyUnicode_LATIN1_INIT("\x93", "\xc2\x93"), \ + _PyUnicode_LATIN1_INIT("\x94", "\xc2\x94"), \ + _PyUnicode_LATIN1_INIT("\x95", "\xc2\x95"), \ + _PyUnicode_LATIN1_INIT("\x96", "\xc2\x96"), \ + _PyUnicode_LATIN1_INIT("\x97", "\xc2\x97"), \ + _PyUnicode_LATIN1_INIT("\x98", "\xc2\x98"), \ + _PyUnicode_LATIN1_INIT("\x99", "\xc2\x99"), \ + _PyUnicode_LATIN1_INIT("\x9a", "\xc2\x9a"), \ + _PyUnicode_LATIN1_INIT("\x9b", "\xc2\x9b"), \ + _PyUnicode_LATIN1_INIT("\x9c", "\xc2\x9c"), \ + _PyUnicode_LATIN1_INIT("\x9d", "\xc2\x9d"), \ + _PyUnicode_LATIN1_INIT("\x9e", "\xc2\x9e"), \ + _PyUnicode_LATIN1_INIT("\x9f", "\xc2\x9f"), \ + _PyUnicode_LATIN1_INIT("\xa0", "\xc2\xa0"), \ + _PyUnicode_LATIN1_INIT("\xa1", "\xc2\xa1"), \ + _PyUnicode_LATIN1_INIT("\xa2", "\xc2\xa2"), \ + _PyUnicode_LATIN1_INIT("\xa3", "\xc2\xa3"), \ + _PyUnicode_LATIN1_INIT("\xa4", "\xc2\xa4"), \ + _PyUnicode_LATIN1_INIT("\xa5", "\xc2\xa5"), \ + _PyUnicode_LATIN1_INIT("\xa6", "\xc2\xa6"), \ + _PyUnicode_LATIN1_INIT("\xa7", "\xc2\xa7"), \ + _PyUnicode_LATIN1_INIT("\xa8", "\xc2\xa8"), \ + _PyUnicode_LATIN1_INIT("\xa9", "\xc2\xa9"), \ + _PyUnicode_LATIN1_INIT("\xaa", "\xc2\xaa"), \ + _PyUnicode_LATIN1_INIT("\xab", "\xc2\xab"), \ + _PyUnicode_LATIN1_INIT("\xac", "\xc2\xac"), \ + _PyUnicode_LATIN1_INIT("\xad", "\xc2\xad"), \ + _PyUnicode_LATIN1_INIT("\xae", "\xc2\xae"), \ + _PyUnicode_LATIN1_INIT("\xaf", "\xc2\xaf"), \ + _PyUnicode_LATIN1_INIT("\xb0", "\xc2\xb0"), \ + _PyUnicode_LATIN1_INIT("\xb1", "\xc2\xb1"), \ + _PyUnicode_LATIN1_INIT("\xb2", "\xc2\xb2"), \ + _PyUnicode_LATIN1_INIT("\xb3", "\xc2\xb3"), \ + _PyUnicode_LATIN1_INIT("\xb4", "\xc2\xb4"), \ + _PyUnicode_LATIN1_INIT("\xb5", "\xc2\xb5"), \ + _PyUnicode_LATIN1_INIT("\xb6", "\xc2\xb6"), \ + _PyUnicode_LATIN1_INIT("\xb7", "\xc2\xb7"), \ + _PyUnicode_LATIN1_INIT("\xb8", "\xc2\xb8"), \ + _PyUnicode_LATIN1_INIT("\xb9", "\xc2\xb9"), \ + _PyUnicode_LATIN1_INIT("\xba", "\xc2\xba"), \ + _PyUnicode_LATIN1_INIT("\xbb", "\xc2\xbb"), \ + _PyUnicode_LATIN1_INIT("\xbc", "\xc2\xbc"), \ + _PyUnicode_LATIN1_INIT("\xbd", "\xc2\xbd"), \ + _PyUnicode_LATIN1_INIT("\xbe", "\xc2\xbe"), \ + _PyUnicode_LATIN1_INIT("\xbf", "\xc2\xbf"), \ + _PyUnicode_LATIN1_INIT("\xc0", "\xc3\x80"), \ + _PyUnicode_LATIN1_INIT("\xc1", "\xc3\x81"), \ + _PyUnicode_LATIN1_INIT("\xc2", "\xc3\x82"), \ + _PyUnicode_LATIN1_INIT("\xc3", "\xc3\x83"), \ + _PyUnicode_LATIN1_INIT("\xc4", "\xc3\x84"), \ + _PyUnicode_LATIN1_INIT("\xc5", "\xc3\x85"), \ + _PyUnicode_LATIN1_INIT("\xc6", "\xc3\x86"), \ + _PyUnicode_LATIN1_INIT("\xc7", "\xc3\x87"), \ + _PyUnicode_LATIN1_INIT("\xc8", "\xc3\x88"), \ + _PyUnicode_LATIN1_INIT("\xc9", "\xc3\x89"), \ + _PyUnicode_LATIN1_INIT("\xca", "\xc3\x8a"), \ + _PyUnicode_LATIN1_INIT("\xcb", "\xc3\x8b"), \ + _PyUnicode_LATIN1_INIT("\xcc", "\xc3\x8c"), \ + _PyUnicode_LATIN1_INIT("\xcd", "\xc3\x8d"), \ + _PyUnicode_LATIN1_INIT("\xce", "\xc3\x8e"), \ + _PyUnicode_LATIN1_INIT("\xcf", "\xc3\x8f"), \ + _PyUnicode_LATIN1_INIT("\xd0", "\xc3\x90"), \ + _PyUnicode_LATIN1_INIT("\xd1", "\xc3\x91"), \ + _PyUnicode_LATIN1_INIT("\xd2", "\xc3\x92"), \ + _PyUnicode_LATIN1_INIT("\xd3", "\xc3\x93"), \ + _PyUnicode_LATIN1_INIT("\xd4", "\xc3\x94"), \ + _PyUnicode_LATIN1_INIT("\xd5", "\xc3\x95"), \ + _PyUnicode_LATIN1_INIT("\xd6", "\xc3\x96"), \ + _PyUnicode_LATIN1_INIT("\xd7", "\xc3\x97"), \ + _PyUnicode_LATIN1_INIT("\xd8", "\xc3\x98"), \ + _PyUnicode_LATIN1_INIT("\xd9", "\xc3\x99"), \ + _PyUnicode_LATIN1_INIT("\xda", "\xc3\x9a"), \ + _PyUnicode_LATIN1_INIT("\xdb", "\xc3\x9b"), \ + _PyUnicode_LATIN1_INIT("\xdc", "\xc3\x9c"), \ + _PyUnicode_LATIN1_INIT("\xdd", "\xc3\x9d"), \ + _PyUnicode_LATIN1_INIT("\xde", "\xc3\x9e"), \ + _PyUnicode_LATIN1_INIT("\xdf", "\xc3\x9f"), \ + _PyUnicode_LATIN1_INIT("\xe0", "\xc3\xa0"), \ + _PyUnicode_LATIN1_INIT("\xe1", "\xc3\xa1"), \ + _PyUnicode_LATIN1_INIT("\xe2", "\xc3\xa2"), \ + _PyUnicode_LATIN1_INIT("\xe3", "\xc3\xa3"), \ + _PyUnicode_LATIN1_INIT("\xe4", "\xc3\xa4"), \ + _PyUnicode_LATIN1_INIT("\xe5", "\xc3\xa5"), \ + _PyUnicode_LATIN1_INIT("\xe6", "\xc3\xa6"), \ + _PyUnicode_LATIN1_INIT("\xe7", "\xc3\xa7"), \ + _PyUnicode_LATIN1_INIT("\xe8", "\xc3\xa8"), \ + _PyUnicode_LATIN1_INIT("\xe9", "\xc3\xa9"), \ + _PyUnicode_LATIN1_INIT("\xea", "\xc3\xaa"), \ + _PyUnicode_LATIN1_INIT("\xeb", "\xc3\xab"), \ + _PyUnicode_LATIN1_INIT("\xec", "\xc3\xac"), \ + _PyUnicode_LATIN1_INIT("\xed", "\xc3\xad"), \ + _PyUnicode_LATIN1_INIT("\xee", "\xc3\xae"), \ + _PyUnicode_LATIN1_INIT("\xef", "\xc3\xaf"), \ + _PyUnicode_LATIN1_INIT("\xf0", "\xc3\xb0"), \ + _PyUnicode_LATIN1_INIT("\xf1", "\xc3\xb1"), \ + _PyUnicode_LATIN1_INIT("\xf2", "\xc3\xb2"), \ + _PyUnicode_LATIN1_INIT("\xf3", "\xc3\xb3"), \ + _PyUnicode_LATIN1_INIT("\xf4", "\xc3\xb4"), \ + _PyUnicode_LATIN1_INIT("\xf5", "\xc3\xb5"), \ + _PyUnicode_LATIN1_INIT("\xf6", "\xc3\xb6"), \ + _PyUnicode_LATIN1_INIT("\xf7", "\xc3\xb7"), \ + _PyUnicode_LATIN1_INIT("\xf8", "\xc3\xb8"), \ + _PyUnicode_LATIN1_INIT("\xf9", "\xc3\xb9"), \ + _PyUnicode_LATIN1_INIT("\xfa", "\xc3\xba"), \ + _PyUnicode_LATIN1_INIT("\xfb", "\xc3\xbb"), \ + _PyUnicode_LATIN1_INIT("\xfc", "\xc3\xbc"), \ + _PyUnicode_LATIN1_INIT("\xfd", "\xc3\xbd"), \ + _PyUnicode_LATIN1_INIT("\xfe", "\xc3\xbe"), \ + _PyUnicode_LATIN1_INIT("\xff", "\xc3\xbf"), \ +} +/* End auto-generated code */ + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_RUNTIME_INIT_GENERATED_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_runtime_structs.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_runtime_structs.h new file mode 100644 index 0000000000000000000000000000000000000000..78f236a51a1ff7cd8871fa9befce745394cb93e0 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_runtime_structs.h @@ -0,0 +1,320 @@ +/* This file contains the struct definitions for the runtime, interpreter + * and thread states, plus all smaller structs contained therein */ + +#ifndef Py_INTERNAL_RUNTIME_STRUCTS_H +#define Py_INTERNAL_RUNTIME_STRUCTS_H +#ifdef __cplusplus +extern "C" { +#endif + +#include "pycore_interp_structs.h" // _PyGC_Head_UNUSED +#include "pycore_obmalloc.h" // struct _obmalloc_global_state + +/************ Runtime state ************/ + +typedef struct { + /* We tag each block with an API ID in order to tag API violations */ + char api_id; + PyMemAllocatorEx alloc; +} debug_alloc_api_t; + +struct _pymem_allocators { + PyMutex mutex; + struct { + PyMemAllocatorEx raw; + PyMemAllocatorEx mem; + PyMemAllocatorEx obj; + } standard; + struct { + debug_alloc_api_t raw; + debug_alloc_api_t mem; + debug_alloc_api_t obj; + } debug; + int is_debug_enabled; + PyObjectArenaAllocator obj_arena; +}; + +enum _py_float_format_type { + _py_float_format_unknown, + _py_float_format_ieee_big_endian, + _py_float_format_ieee_little_endian, +}; + +struct _Py_float_runtime_state { + enum _py_float_format_type float_format; + enum _py_float_format_type double_format; +}; + +struct pyhash_runtime_state { + struct { +#ifndef MS_WINDOWS + int fd; + dev_t st_dev; + ino_t st_ino; +#else + // This is a placeholder so the struct isn't empty on Windows. + int _not_used; +#endif + } urandom_cache; +}; + +#include "pycore_tracemalloc.h" // struct _tracemalloc_runtime_state + +struct _fileutils_state { + int force_ascii; +}; + +#include "pycore_interpframe_structs.h" // _PyInterpreterFrame +#include "pycore_debug_offsets.h" // _Py_DebugOffsets +#include "pycore_signal.h" // struct _signals_runtime_state +#include "pycore_faulthandler.h" // struct _faulthandler_runtime_state +#include "pycore_ast.h" // struct _expr + +#ifdef Py_DEBUG +#define _PYPEGEN_NSTATISTICS 2000 +#endif + +struct _parser_runtime_state { +#ifdef Py_DEBUG + long memo_statistics[_PYPEGEN_NSTATISTICS]; +#ifdef Py_GIL_DISABLED + PyMutex mutex; +#endif +#else + int _not_used; +#endif + struct _expr dummy_name; +}; + +typedef struct { + PyTime_t numer; + PyTime_t denom; +} _PyTimeFraction; + +struct _Py_time_runtime_state { +#if defined(MS_WINDOWS) || defined(__APPLE__) + _PyTimeFraction base; +#else + char _unused; +#endif +}; + + +struct _Py_cached_objects { + // XXX We could statically allocate the hashtable. + _Py_hashtable_t *interned_strings; +}; + +// These would be in pycore_long.h if it weren't for an include cycle. +#define _PY_NSMALLPOSINTS 257 +#define _PY_NSMALLNEGINTS 5 + +#include "pycore_global_strings.h" // struct _Py_global_strings + +struct _Py_static_objects { + struct { + /* Small integers are preallocated in this array so that they + * can be shared. + * The integers that are preallocated are those in the range + * -_PY_NSMALLNEGINTS (inclusive) to _PY_NSMALLPOSINTS (exclusive). + */ + PyLongObject small_ints[_PY_NSMALLNEGINTS + _PY_NSMALLPOSINTS]; + + PyBytesObject bytes_empty; + struct { + PyBytesObject ob; + char eos; + } bytes_characters[256]; + + struct _Py_global_strings strings; + + _PyGC_Head_UNUSED _tuple_empty_gc_not_used; + PyTupleObject tuple_empty; + + _PyGC_Head_UNUSED _hamt_bitmap_node_empty_gc_not_used; + PyHamtNode_Bitmap hamt_bitmap_node_empty; + _PyContextTokenMissing context_token_missing; + } singletons; +}; + +/* Full Python runtime state */ + +/* _PyRuntimeState holds the global state for the CPython runtime. + That data is exported by the internal API as a global variable + (_PyRuntime, defined near the top of pylifecycle.c). + */ +struct pyruntimestate { + /* This field must be first to facilitate locating it by out of process + * debuggers. Out of process debuggers will use the offsets contained in this + * field to be able to locate other fields in several interpreter structures + * in a way that doesn't require them to know the exact layout of those + * structures. + * + * IMPORTANT: + * This struct is **NOT** backwards compatible between minor version of the + * interpreter and the members, order of members and size can change between + * minor versions. This struct is only guaranteed to be stable between patch + * versions for a given minor version of the interpreter. + */ + _Py_DebugOffsets debug_offsets; + + /* Has been initialized to a safe state. + + In order to be effective, this must be set to 0 during or right + after allocation. */ + int _initialized; + + /* Is running Py_PreInitialize()? */ + int preinitializing; + + /* Is Python preinitialized? Set to 1 by Py_PreInitialize() */ + int preinitialized; + + /* Is Python core initialized? Set to 1 by _Py_InitializeCore() */ + int core_initialized; + + /* Is Python fully initialized? Set to 1 by Py_Initialize() */ + int initialized; + + /* Set by Py_FinalizeEx(). Only reset to NULL if Py_Initialize() + is called again. + + Use _PyRuntimeState_GetFinalizing() and _PyRuntimeState_SetFinalizing() + to access it, don't access it directly. */ + PyThreadState *_finalizing; + /* The ID of the OS thread in which we are finalizing. */ + unsigned long _finalizing_id; + + struct pyinterpreters { + PyMutex mutex; + /* The linked list of interpreters, newest first. */ + PyInterpreterState *head; + /* The runtime's initial interpreter, which has a special role + in the operation of the runtime. It is also often the only + interpreter. */ + PyInterpreterState *main; + /* next_id is an auto-numbered sequence of small + integers. It gets initialized in _PyInterpreterState_Enable(), + which is called in Py_Initialize(), and used in + PyInterpreterState_New(). A negative interpreter ID + indicates an error occurred. The main interpreter will + always have an ID of 0. Overflow results in a RuntimeError. + If that becomes a problem later then we can adjust, e.g. by + using a Python int. */ + int64_t next_id; + } interpreters; + + /* Platform-specific identifier and PyThreadState, respectively, for the + main thread in the main interpreter. */ + unsigned long main_thread; + PyThreadState *main_tstate; + + /* ---------- IMPORTANT --------------------------- + The fields above this line are declared as early as + possible to facilitate out-of-process observability + tools. */ + + /* cross-interpreter data and utils */ + _PyXI_global_state_t xi; + + struct _pymem_allocators allocators; + struct _obmalloc_global_state obmalloc; + struct pyhash_runtime_state pyhash_state; + struct _pythread_runtime_state threads; + struct _signals_runtime_state signals; + + /* Used for the thread state bound to the current thread. */ + Py_tss_t autoTSSkey; + + /* Used instead of PyThreadState.trash when there is not current tstate. */ + Py_tss_t trashTSSkey; + + PyWideStringList orig_argv; + + struct _parser_runtime_state parser; + + struct _atexit_runtime_state atexit; + + struct _import_runtime_state imports; + struct _ceval_runtime_state ceval; + struct _gilstate_runtime_state { + /* bpo-26558: Flag to disable PyGILState_Check(). + If set to non-zero, PyGILState_Check() always return 1. */ + int check_enabled; + /* The single PyInterpreterState used by this process' + GILState implementation + */ + /* TODO: Given interp_main, it may be possible to kill this ref */ + PyInterpreterState *autoInterpreterState; + } gilstate; + struct _getargs_runtime_state { + struct _PyArg_Parser *static_parsers; + } getargs; + struct _fileutils_state fileutils; + struct _faulthandler_runtime_state faulthandler; + struct _tracemalloc_runtime_state tracemalloc; + struct _reftracer_runtime_state ref_tracer; + + // The rwmutex is used to prevent overlapping global and per-interpreter + // stop-the-world events. Global stop-the-world events lock the mutex + // exclusively (as a "writer"), while per-interpreter stop-the-world events + // lock it non-exclusively (as "readers"). + _PyRWMutex stoptheworld_mutex; + struct _stoptheworld_state stoptheworld; + + PyPreConfig preconfig; + + // Audit values must be preserved when Py_Initialize()/Py_Finalize() + // is called multiple times. + Py_OpenCodeHookFunction open_code_hook; + void *open_code_userdata; + struct { + PyMutex mutex; + struct _Py_AuditHookEntry *head; + } audit_hooks; + + struct _py_object_runtime_state object_state; + struct _Py_float_runtime_state float_state; + struct _Py_unicode_runtime_state unicode_state; + struct _types_runtime_state types; + struct _Py_time_runtime_state time; + +#if defined(__EMSCRIPTEN__) && defined(PY_CALL_TRAMPOLINE) + // Used in "Python/emscripten_trampoline.c" to choose between wasm-gc + // trampoline and JavaScript trampoline. + PyObject* (*emscripten_trampoline)(int* success, + PyCFunctionWithKeywords func, + PyObject* self, + PyObject* args, + PyObject* kw); +#endif + + /* All the objects that are shared by the runtime's interpreters. */ + struct _Py_cached_objects cached_objects; + struct _Py_static_objects static_objects; + + /* The following fields are here to avoid allocation during init. + The data is exposed through _PyRuntimeState pointer fields. + These fields should not be accessed directly outside of init. + + All other _PyRuntimeState pointer fields are populated when + needed and default to NULL. + + For now there are some exceptions to that rule, which require + allocation during init. These will be addressed on a case-by-case + basis. Most notably, we don't pre-allocated the several mutex + (PyThread_type_lock) fields, because on Windows we only ever get + a pointer type. + */ + + /* _PyRuntimeState.interpreters.main */ + PyInterpreterState _main_interpreter; + // _main_interpreter should be the last field of _PyRuntimeState. + // See https://github.com/python/cpython/issues/127117. +}; + + +#ifdef __cplusplus +} +#endif +#endif /* Py_INTERNAL_RUNTIME_STRUCTS_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_semaphore.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_semaphore.h new file mode 100644 index 0000000000000000000000000000000000000000..269538384606ce1b031a75f928038e253c5efce4 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_semaphore.h @@ -0,0 +1,67 @@ +// The _PySemaphore API a simplified cross-platform semaphore used to implement +// wakeup/sleep. +#ifndef Py_INTERNAL_SEMAPHORE_H +#define Py_INTERNAL_SEMAPHORE_H + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_pythread.h" // _POSIX_SEMAPHORES + +#ifdef MS_WINDOWS +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +# endif +# include +#elif defined(HAVE_PTHREAD_H) +# include +#elif defined(HAVE_PTHREAD_STUBS) +# include "cpython/pthread_stubs.h" +#else +# error "Require native threads. See https://bugs.python.org/issue31370" +#endif + +#if (defined(_POSIX_SEMAPHORES) && (_POSIX_SEMAPHORES+0) != -1 && \ + defined(HAVE_SEM_TIMEDWAIT)) +# define _Py_USE_SEMAPHORES +# include +#endif + + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct _PySemaphore { +#if defined(MS_WINDOWS) + HANDLE platform_sem; +#elif defined(_Py_USE_SEMAPHORES) + sem_t platform_sem; +#else + pthread_mutex_t mutex; + pthread_cond_t cond; + int counter; +#endif +} _PySemaphore; + +// Puts the current thread to sleep until _PySemaphore_Wakeup() is called. +// If `detach` is true, then the thread will detach/release the GIL while +// sleeping. +PyAPI_FUNC(int) +_PySemaphore_Wait(_PySemaphore *sema, PyTime_t timeout_ns, int detach); + +// Wakes up a single thread waiting on sema. Note that _PySemaphore_Wakeup() +// can be called before _PySemaphore_Wait(). +PyAPI_FUNC(void) +_PySemaphore_Wakeup(_PySemaphore *sema); + +// Initializes/destroys a semaphore +PyAPI_FUNC(void) _PySemaphore_Init(_PySemaphore *sema); +PyAPI_FUNC(void) _PySemaphore_Destroy(_PySemaphore *sema); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_SEMAPHORE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_setobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_setobject.h new file mode 100644 index 0000000000000000000000000000000000000000..24d0135ed1aeca8228e6ef15acc2dfbdb2a21498 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_setobject.h @@ -0,0 +1,41 @@ +#ifndef Py_INTERNAL_SETOBJECT_H +#define Py_INTERNAL_SETOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +// Export for '_abc' shared extension +PyAPI_FUNC(int) _PySet_NextEntry( + PyObject *set, + Py_ssize_t *pos, + PyObject **key, + Py_hash_t *hash); + +// Export for '_pickle' shared extension +PyAPI_FUNC(int) _PySet_NextEntryRef( + PyObject *set, + Py_ssize_t *pos, + PyObject **key, + Py_hash_t *hash); + +// Export for '_pickle' shared extension +PyAPI_FUNC(int) _PySet_Update(PyObject *set, PyObject *iterable); + +// Export for the gdb plugin's (python-gdb.py) benefit +PyAPI_DATA(PyObject *) _PySet_Dummy; + +PyAPI_FUNC(int) _PySet_Contains(PySetObject *so, PyObject *key); + +// Clears the set without acquiring locks. Used by _PyCode_Fini. +extern void _PySet_ClearInternal(PySetObject *so); + +PyAPI_FUNC(int) _PySet_AddTakeRef(PySetObject *so, PyObject *key); + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_SETOBJECT_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_signal.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_signal.h new file mode 100644 index 0000000000000000000000000000000000000000..47213a34ab77b526be8ef0672720811d519c8856 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_signal.h @@ -0,0 +1,108 @@ +// Define Py_NSIG constant for signal handling. + +#ifndef Py_INTERNAL_SIGNAL_H +#define Py_INTERNAL_SIGNAL_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include // NSIG + + +// Restore signals that the interpreter has called SIG_IGN on to SIG_DFL. +// Export for '_posixsubprocess' shared extension. +PyAPI_FUNC(void) _Py_RestoreSignals(void); + +#ifdef _SIG_MAXSIG + // gh-91145: On FreeBSD, defines NSIG as 32: it doesn't include + // realtime signals: [SIGRTMIN,SIGRTMAX]. Use _SIG_MAXSIG instead. For + // example on x86-64 FreeBSD 13, SIGRTMAX is 126 and _SIG_MAXSIG is 128. +# define Py_NSIG _SIG_MAXSIG +#elif defined(NSIG) +# define Py_NSIG NSIG +#elif defined(_NSIG) +# define Py_NSIG _NSIG // BSD/SysV +#elif defined(_SIGMAX) +# define Py_NSIG (_SIGMAX + 1) // QNX +#elif defined(SIGMAX) +# define Py_NSIG (SIGMAX + 1) // djgpp +#else +# define Py_NSIG 64 // Use a reasonable default value +#endif + +#define INVALID_FD (-1) + +struct _signals_runtime_state { + struct { + // tripped and func should be accessed using atomic ops. + int tripped; + PyObject* func; + } handlers[Py_NSIG]; + + volatile struct { +#ifdef MS_WINDOWS + /* This would be "SOCKET fd" if were always included. + It isn't so we must cast to SOCKET where appropriate. */ + volatile int fd; +#elif defined(__VXWORKS__) + int fd; +#else + sig_atomic_t fd; +#endif + + int warn_on_full_buffer; +#ifdef MS_WINDOWS + int use_send; +#endif + } wakeup; + + /* Speed up sigcheck() when none tripped. + is_tripped should be accessed using atomic ops. */ + int is_tripped; + + /* These objects necessarily belong to the main interpreter. */ + PyObject *default_handler; + PyObject *ignore_handler; + +#ifdef MS_WINDOWS + /* This would be "HANDLE sigint_event" if were always included. + It isn't so we must cast to HANDLE everywhere "sigint_event" is used. */ + void *sigint_event; +#endif + + /* True if the main interpreter thread exited due to an unhandled + * KeyboardInterrupt exception, suggesting the user pressed ^C. */ + int unhandled_keyboard_interrupt; +}; + +#ifdef MS_WINDOWS +# define _signals_WAKEUP_INIT \ + {.fd = INVALID_FD, .warn_on_full_buffer = 1, .use_send = 0} +#else +# define _signals_WAKEUP_INIT \ + {.fd = INVALID_FD, .warn_on_full_buffer = 1} +#endif + +#define _signals_RUNTIME_INIT \ + { \ + .wakeup = _signals_WAKEUP_INIT, \ + } + + +// Export for '_multiprocessing' shared extension +PyAPI_FUNC(int) _PyOS_IsMainThread(void); + +#ifdef MS_WINDOWS +// is not included by Python.h so use void* instead of HANDLE. +// Export for '_multiprocessing' shared extension +PyAPI_FUNC(void*) _PyOS_SigintEvent(void); +#endif + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_SIGNAL_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_sliceobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_sliceobject.h new file mode 100644 index 0000000000000000000000000000000000000000..ba8b1f1cb27dee3219436416586b2bb3e3b8d4e3 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_sliceobject.h @@ -0,0 +1,20 @@ +#ifndef Py_INTERNAL_SLICEOBJECT_H +#define Py_INTERNAL_SLICEOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + + +/* runtime lifecycle */ + +PyAPI_FUNC(PyObject *) +_PyBuildSlice_ConsumeRefs(PyObject *start, PyObject *stop); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_SLICEOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_stackref.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_stackref.h new file mode 100644 index 0000000000000000000000000000000000000000..42fdbeb21f652a80814ad3088287dceb1741f947 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_stackref.h @@ -0,0 +1,838 @@ +#ifndef Py_INTERNAL_STACKREF_H +#define Py_INTERNAL_STACKREF_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_object.h" // Py_DECREF_MORTAL +#include "pycore_object_deferred.h" // _PyObject_HasDeferredRefcount() + +#include // bool + + +/* + This file introduces a new API for handling references on the stack, called + _PyStackRef. This API is inspired by HPy. + + There are 3 main operations, that convert _PyStackRef to PyObject* and + vice versa: + + 1. Borrow (discouraged) + 2. Steal + 3. New + + Borrow means that the reference is converted without any change in ownership. + This is discouraged because it makes verification much harder. It also makes + unboxed integers harder in the future. + + Steal means that ownership is transferred to something else. The total + number of references to the object stays the same. The old reference is no + longer valid. + + New creates a new reference from the old reference. The old reference + is still valid. + + All _PyStackRef must be operated on by the new reference operations: + + 1. DUP + 2. CLOSE + + DUP is roughly equivalent to Py_NewRef. It creates a new reference from an old + reference. The old reference remains unchanged. + + CLOSE is roughly equivalent to Py_DECREF. It destroys a reference. + + Note that it is unsafe to borrow a _PyStackRef and then do normal + CPython refcounting operations on it! +*/ + + +#if !defined(Py_GIL_DISABLED) && defined(Py_STACKREF_DEBUG) + +#define Py_TAG_BITS 0 + +PyAPI_FUNC(PyObject *) _Py_stackref_get_object(_PyStackRef ref); +PyAPI_FUNC(PyObject *) _Py_stackref_close(_PyStackRef ref, const char *filename, int linenumber); +PyAPI_FUNC(_PyStackRef) _Py_stackref_create(PyObject *obj, const char *filename, int linenumber); +PyAPI_FUNC(void) _Py_stackref_record_borrow(_PyStackRef ref, const char *filename, int linenumber); +extern void _Py_stackref_associate(PyInterpreterState *interp, PyObject *obj, _PyStackRef ref); + +static const _PyStackRef PyStackRef_NULL = { .index = 0 }; + +// Use the first 3 even numbers for None, True and False. +// Odd numbers are reserved for (tagged) integers +#define PyStackRef_None ((_PyStackRef){ .index = 2 } ) +#define PyStackRef_False ((_PyStackRef){ .index = 4 }) +#define PyStackRef_True ((_PyStackRef){ .index = 6 }) + +#define INITIAL_STACKREF_INDEX 8 + +static inline int +PyStackRef_IsNull(_PyStackRef ref) +{ + return ref.index == 0; +} + +static inline int +PyStackRef_IsTrue(_PyStackRef ref) +{ + return _Py_stackref_get_object(ref) == Py_True; +} + +static inline int +PyStackRef_IsFalse(_PyStackRef ref) +{ + return _Py_stackref_get_object(ref) == Py_False; +} + +static inline int +PyStackRef_IsNone(_PyStackRef ref) +{ + return _Py_stackref_get_object(ref) == Py_None; +} + +static inline PyObject * +_PyStackRef_AsPyObjectBorrow(_PyStackRef ref, const char *filename, int linenumber) +{ + assert((ref.index & 1) == 0); + _Py_stackref_record_borrow(ref, filename, linenumber); + return _Py_stackref_get_object(ref); +} + +#define PyStackRef_AsPyObjectBorrow(REF) _PyStackRef_AsPyObjectBorrow((REF), __FILE__, __LINE__) + +static inline PyObject * +_PyStackRef_AsPyObjectSteal(_PyStackRef ref, const char *filename, int linenumber) +{ + return _Py_stackref_close(ref, filename, linenumber); +} +#define PyStackRef_AsPyObjectSteal(REF) _PyStackRef_AsPyObjectSteal((REF), __FILE__, __LINE__) + +static inline _PyStackRef +_PyStackRef_FromPyObjectNew(PyObject *obj, const char *filename, int linenumber) +{ + Py_INCREF(obj); + return _Py_stackref_create(obj, filename, linenumber); +} +#define PyStackRef_FromPyObjectNew(obj) _PyStackRef_FromPyObjectNew(_PyObject_CAST(obj), __FILE__, __LINE__) + +static inline _PyStackRef +_PyStackRef_FromPyObjectSteal(PyObject *obj, const char *filename, int linenumber) +{ + return _Py_stackref_create(obj, filename, linenumber); +} +#define PyStackRef_FromPyObjectSteal(obj) _PyStackRef_FromPyObjectSteal(_PyObject_CAST(obj), __FILE__, __LINE__) + +static inline _PyStackRef +_PyStackRef_FromPyObjectBorrow(PyObject *obj, const char *filename, int linenumber) +{ + return _Py_stackref_create(obj, filename, linenumber); +} +#define PyStackRef_FromPyObjectBorrow(obj) _PyStackRef_FromPyObjectBorrow(_PyObject_CAST(obj), __FILE__, __LINE__) + +static inline _PyStackRef +_PyStackRef_FromPyObjectImmortal(PyObject *obj, const char *filename, int linenumber) +{ + assert(_Py_IsImmortal(obj)); + return _Py_stackref_create(obj, filename, linenumber); +} +#define PyStackRef_FromPyObjectImmortal(obj) _PyStackRef_FromPyObjectImmortal(_PyObject_CAST(obj), __FILE__, __LINE__) + +static inline bool +PyStackRef_IsTaggedInt(_PyStackRef ref) +{ + return (ref.index & 1) == 1; +} + +static inline void +_PyStackRef_CLOSE(_PyStackRef ref, const char *filename, int linenumber) +{ + if (PyStackRef_IsTaggedInt(ref)) { + return; + } + PyObject *obj = _Py_stackref_close(ref, filename, linenumber); + Py_DECREF(obj); +} +#define PyStackRef_CLOSE(REF) _PyStackRef_CLOSE((REF), __FILE__, __LINE__) + + +static inline void +_PyStackRef_XCLOSE(_PyStackRef ref, const char *filename, int linenumber) +{ + if (PyStackRef_IsNull(ref)) { + return; + } + _PyStackRef_CLOSE(ref, filename, linenumber); +} +#define PyStackRef_XCLOSE(REF) _PyStackRef_XCLOSE((REF), __FILE__, __LINE__) + +static inline _PyStackRef +_PyStackRef_DUP(_PyStackRef ref, const char *filename, int linenumber) +{ + if (PyStackRef_IsTaggedInt(ref)) { + return ref; + } + else { + PyObject *obj = _Py_stackref_get_object(ref); + Py_INCREF(obj); + return _Py_stackref_create(obj, filename, linenumber); + } +} +#define PyStackRef_DUP(REF) _PyStackRef_DUP(REF, __FILE__, __LINE__) + +extern void _PyStackRef_CLOSE_SPECIALIZED(_PyStackRef ref, destructor destruct, const char *filename, int linenumber); +#define PyStackRef_CLOSE_SPECIALIZED(REF, DESTRUCT) _PyStackRef_CLOSE_SPECIALIZED(REF, DESTRUCT, __FILE__, __LINE__) + +static inline _PyStackRef +PyStackRef_MakeHeapSafe(_PyStackRef ref) +{ + return ref; +} + +static inline _PyStackRef +PyStackRef_Borrow(_PyStackRef ref) +{ + return PyStackRef_DUP(ref); +} + +#define PyStackRef_CLEAR(REF) \ + do { \ + _PyStackRef *_tmp_op_ptr = &(REF); \ + _PyStackRef _tmp_old_op = (*_tmp_op_ptr); \ + *_tmp_op_ptr = PyStackRef_NULL; \ + PyStackRef_XCLOSE(_tmp_old_op); \ + } while (0) + +static inline _PyStackRef +_PyStackRef_FromPyObjectStealMortal(PyObject *obj, const char *filename, int linenumber) +{ + assert(!_Py_IsImmortal(obj)); + return _Py_stackref_create(obj, filename, linenumber); +} +#define PyStackRef_FromPyObjectStealMortal(obj) _PyStackRef_FromPyObjectStealMortal(_PyObject_CAST(obj), __FILE__, __LINE__) + +static inline bool +PyStackRef_IsHeapSafe(_PyStackRef ref) +{ + return true; +} + +static inline _PyStackRef +_PyStackRef_FromPyObjectNewMortal(PyObject *obj, const char *filename, int linenumber) +{ + assert(!_Py_IsStaticImmortal(obj)); + Py_INCREF(obj); + return _Py_stackref_create(obj, filename, linenumber); +} +#define PyStackRef_FromPyObjectNewMortal(obj) _PyStackRef_FromPyObjectNewMortal(_PyObject_CAST(obj), __FILE__, __LINE__) + +#define PyStackRef_RefcountOnObject(REF) 1 + +extern int PyStackRef_Is(_PyStackRef a, _PyStackRef b); + +extern bool PyStackRef_IsTaggedInt(_PyStackRef ref); + +extern intptr_t PyStackRef_UntagInt(_PyStackRef ref); + +extern _PyStackRef PyStackRef_TagInt(intptr_t i); + +extern bool +PyStackRef_IsNullOrInt(_PyStackRef ref); + +#else + +#define Py_INT_TAG 3 +#define Py_TAG_REFCNT 1 + +static inline bool +PyStackRef_IsTaggedInt(_PyStackRef i) +{ + return (i.bits & Py_INT_TAG) == Py_INT_TAG; +} + +static inline _PyStackRef +PyStackRef_TagInt(intptr_t i) +{ + assert(Py_ARITHMETIC_RIGHT_SHIFT(intptr_t, (i << 2), 2) == i); + return (_PyStackRef){ .bits = ((((uintptr_t)i) << 2) | Py_INT_TAG) }; +} + +static inline intptr_t +PyStackRef_UntagInt(_PyStackRef i) +{ + assert((i.bits & Py_INT_TAG) == Py_INT_TAG); + intptr_t val = (intptr_t)i.bits; + return Py_ARITHMETIC_RIGHT_SHIFT(intptr_t, val, 2); +} + + +#ifdef Py_GIL_DISABLED + +#define Py_TAG_DEFERRED Py_TAG_REFCNT + +#define Py_TAG_PTR ((uintptr_t)0) +#define Py_TAG_BITS ((uintptr_t)1) + + +static const _PyStackRef PyStackRef_NULL = { .bits = Py_TAG_DEFERRED}; +#define PyStackRef_IsNull(stackref) ((stackref).bits == PyStackRef_NULL.bits) +#define PyStackRef_True ((_PyStackRef){.bits = ((uintptr_t)&_Py_TrueStruct) | Py_TAG_DEFERRED }) +#define PyStackRef_False ((_PyStackRef){.bits = ((uintptr_t)&_Py_FalseStruct) | Py_TAG_DEFERRED }) +#define PyStackRef_None ((_PyStackRef){.bits = ((uintptr_t)&_Py_NoneStruct) | Py_TAG_DEFERRED }) + +// Checks that mask out the deferred bit in the free threading build. +#define PyStackRef_IsNone(ref) (PyStackRef_AsPyObjectBorrow(ref) == Py_None) +#define PyStackRef_IsTrue(ref) (PyStackRef_AsPyObjectBorrow(ref) == Py_True) +#define PyStackRef_IsFalse(ref) (PyStackRef_AsPyObjectBorrow(ref) == Py_False) + +#define PyStackRef_IsNullOrInt(stackref) (PyStackRef_IsNull(stackref) || PyStackRef_IsTaggedInt(stackref)) + +static inline PyObject * +PyStackRef_AsPyObjectBorrow(_PyStackRef stackref) +{ + PyObject *cleared = ((PyObject *)((stackref).bits & (~Py_TAG_BITS))); + return cleared; +} + +#define PyStackRef_IsDeferred(ref) (((ref).bits & Py_TAG_BITS) == Py_TAG_DEFERRED) + +static inline PyObject * +PyStackRef_NotDeferred_AsPyObject(_PyStackRef stackref) +{ + assert(!PyStackRef_IsDeferred(stackref)); + return (PyObject *)stackref.bits; +} + +static inline PyObject * +PyStackRef_AsPyObjectSteal(_PyStackRef stackref) +{ + assert(!PyStackRef_IsNull(stackref)); + if (PyStackRef_IsDeferred(stackref)) { + return Py_NewRef(PyStackRef_AsPyObjectBorrow(stackref)); + } + return PyStackRef_AsPyObjectBorrow(stackref); +} + +static inline _PyStackRef +_PyStackRef_FromPyObjectSteal(PyObject *obj) +{ + assert(obj != NULL); + // Make sure we don't take an already tagged value. + assert(((uintptr_t)obj & Py_TAG_BITS) == 0); + return (_PyStackRef){ .bits = (uintptr_t)obj }; +} +# define PyStackRef_FromPyObjectSteal(obj) _PyStackRef_FromPyObjectSteal(_PyObject_CAST(obj)) + +static inline _PyStackRef +PyStackRef_FromPyObjectBorrow(PyObject *obj) +{ + assert(obj != NULL); + assert(((uintptr_t)obj & Py_TAG_BITS) == 0); + return (_PyStackRef){ .bits = (uintptr_t)obj | Py_TAG_DEFERRED }; +} + +static inline bool +PyStackRef_IsHeapSafe(_PyStackRef stackref) +{ + if (PyStackRef_IsDeferred(stackref) && !PyStackRef_IsTaggedInt(stackref)) { + PyObject *obj = PyStackRef_AsPyObjectBorrow(stackref); + return obj == NULL || _Py_IsImmortal(obj) || _PyObject_HasDeferredRefcount(obj); + } + return true; +} + +static inline _PyStackRef +PyStackRef_MakeHeapSafe(_PyStackRef stackref) +{ + if (PyStackRef_IsHeapSafe(stackref)) { + return stackref; + } + PyObject *obj = PyStackRef_AsPyObjectBorrow(stackref); + return (_PyStackRef){ .bits = (uintptr_t)(Py_NewRef(obj)) | Py_TAG_PTR }; +} + +static inline _PyStackRef +PyStackRef_FromPyObjectStealMortal(PyObject *obj) +{ + assert(obj != NULL); + assert(!_Py_IsImmortal(obj)); + // Make sure we don't take an already tagged value. + assert(((uintptr_t)obj & Py_TAG_BITS) == 0); + return (_PyStackRef){ .bits = (uintptr_t)obj }; +} + +static inline _PyStackRef +PyStackRef_FromPyObjectNew(PyObject *obj) +{ + // Make sure we don't take an already tagged value. + assert(((uintptr_t)obj & Py_TAG_BITS) == 0); + assert(obj != NULL); + if (_PyObject_HasDeferredRefcount(obj)) { + return (_PyStackRef){ .bits = (uintptr_t)obj | Py_TAG_DEFERRED }; + } + else { + return (_PyStackRef){ .bits = (uintptr_t)(Py_NewRef(obj)) | Py_TAG_PTR }; + } +} +#define PyStackRef_FromPyObjectNew(obj) PyStackRef_FromPyObjectNew(_PyObject_CAST(obj)) + +static inline _PyStackRef +PyStackRef_FromPyObjectImmortal(PyObject *obj) +{ + // Make sure we don't take an already tagged value. + assert(((uintptr_t)obj & Py_TAG_BITS) == 0); + assert(obj != NULL); + assert(_Py_IsImmortal(obj)); + return (_PyStackRef){ .bits = (uintptr_t)obj | Py_TAG_DEFERRED }; +} +#define PyStackRef_FromPyObjectImmortal(obj) PyStackRef_FromPyObjectImmortal(_PyObject_CAST(obj)) + +#define PyStackRef_CLOSE(REF) \ + do { \ + _PyStackRef _close_tmp = (REF); \ + assert(!PyStackRef_IsNull(_close_tmp)); \ + if (!PyStackRef_IsDeferred(_close_tmp)) { \ + Py_DECREF(PyStackRef_AsPyObjectBorrow(_close_tmp)); \ + } \ + } while (0) + +static inline void +PyStackRef_CLOSE_SPECIALIZED(_PyStackRef ref, destructor destruct) +{ + (void)destruct; + PyStackRef_CLOSE(ref); +} + +static inline _PyStackRef +PyStackRef_DUP(_PyStackRef stackref) +{ + assert(!PyStackRef_IsNull(stackref)); + if (PyStackRef_IsDeferred(stackref)) { + return stackref; + } + Py_INCREF(PyStackRef_AsPyObjectBorrow(stackref)); + return stackref; +} + +static inline _PyStackRef +PyStackRef_Borrow(_PyStackRef stackref) +{ + return (_PyStackRef){ .bits = stackref.bits | Py_TAG_DEFERRED }; +} + +// Convert a possibly deferred reference to a strong reference. +static inline _PyStackRef +PyStackRef_AsStrongReference(_PyStackRef stackref) +{ + return PyStackRef_FromPyObjectSteal(PyStackRef_AsPyObjectSteal(stackref)); +} + +#define PyStackRef_XCLOSE(stackref) \ + do { \ + _PyStackRef _tmp = (stackref); \ + if (!PyStackRef_IsNull(_tmp)) { \ + PyStackRef_CLOSE(_tmp); \ + } \ + } while (0); + +#define PyStackRef_CLEAR(op) \ + do { \ + _PyStackRef *_tmp_op_ptr = &(op); \ + _PyStackRef _tmp_old_op = (*_tmp_op_ptr); \ + if (!PyStackRef_IsNull(_tmp_old_op)) { \ + *_tmp_op_ptr = PyStackRef_NULL; \ + PyStackRef_CLOSE(_tmp_old_op); \ + } \ + } while (0) + +#define PyStackRef_FromPyObjectNewMortal PyStackRef_FromPyObjectNew + +#else // Py_GIL_DISABLED + +// With GIL + +/* References to immortal objects always have their tag bit set to Py_TAG_REFCNT + * as they can (must) have their reclamation deferred */ + +#define Py_TAG_BITS 3 +#if _Py_IMMORTAL_FLAGS != Py_TAG_REFCNT +# error "_Py_IMMORTAL_FLAGS != Py_TAG_REFCNT" +#endif + +#define BITS_TO_PTR(REF) ((PyObject *)((REF).bits)) +#define BITS_TO_PTR_MASKED(REF) ((PyObject *)(((REF).bits) & (~Py_TAG_REFCNT))) + +#define PyStackRef_NULL_BITS Py_TAG_REFCNT +static const _PyStackRef PyStackRef_NULL = { .bits = PyStackRef_NULL_BITS }; + +#define PyStackRef_IsNull(ref) ((ref).bits == PyStackRef_NULL_BITS) +#define PyStackRef_True ((_PyStackRef){.bits = ((uintptr_t)&_Py_TrueStruct) | Py_TAG_REFCNT }) +#define PyStackRef_False ((_PyStackRef){.bits = ((uintptr_t)&_Py_FalseStruct) | Py_TAG_REFCNT }) +#define PyStackRef_None ((_PyStackRef){.bits = ((uintptr_t)&_Py_NoneStruct) | Py_TAG_REFCNT }) + +#define PyStackRef_IsTrue(REF) ((REF).bits == (((uintptr_t)&_Py_TrueStruct) | Py_TAG_REFCNT)) +#define PyStackRef_IsFalse(REF) ((REF).bits == (((uintptr_t)&_Py_FalseStruct) | Py_TAG_REFCNT)) +#define PyStackRef_IsNone(REF) ((REF).bits == (((uintptr_t)&_Py_NoneStruct) | Py_TAG_REFCNT)) + +#ifdef Py_DEBUG + +static inline void PyStackRef_CheckValid(_PyStackRef ref) { + assert(ref.bits != 0); + int tag = ref.bits & Py_TAG_BITS; + PyObject *obj = BITS_TO_PTR_MASKED(ref); + switch (tag) { + case 0: + /* Can be immortal if object was made immortal after reference came into existence */ + assert(!_Py_IsStaticImmortal(obj)); + break; + case Py_TAG_REFCNT: + break; + default: + assert(0); + } +} + +#else + +#define PyStackRef_CheckValid(REF) ((void)0) + +#endif + +#ifdef _WIN32 +#define PyStackRef_RefcountOnObject(REF) (((REF).bits & Py_TAG_REFCNT) == 0) +#define PyStackRef_AsPyObjectBorrow BITS_TO_PTR_MASKED +#define PyStackRef_Borrow(REF) (_PyStackRef){ .bits = ((REF).bits) | Py_TAG_REFCNT}; +#else +/* Does this ref not have an embedded refcount and thus not refer to a declared immmortal object? */ +static inline int +PyStackRef_RefcountOnObject(_PyStackRef ref) +{ + return (ref.bits & Py_TAG_REFCNT) == 0; +} + +static inline PyObject * +PyStackRef_AsPyObjectBorrow(_PyStackRef ref) +{ + assert(!PyStackRef_IsTaggedInt(ref)); + return BITS_TO_PTR_MASKED(ref); +} + +static inline _PyStackRef +PyStackRef_Borrow(_PyStackRef ref) +{ + return (_PyStackRef){ .bits = ref.bits | Py_TAG_REFCNT }; +} +#endif + +static inline PyObject * +PyStackRef_AsPyObjectSteal(_PyStackRef ref) +{ + if (PyStackRef_RefcountOnObject(ref)) { + return BITS_TO_PTR(ref); + } + else { + return Py_NewRef(BITS_TO_PTR_MASKED(ref)); + } +} + +static inline _PyStackRef +PyStackRef_FromPyObjectSteal(PyObject *obj) +{ + assert(obj != NULL); +#if SIZEOF_VOID_P > 4 + unsigned int tag = obj->ob_flags & Py_TAG_REFCNT; +#else + unsigned int tag = _Py_IsImmortal(obj) ? Py_TAG_REFCNT : 0; +#endif + _PyStackRef ref = ((_PyStackRef){.bits = ((uintptr_t)(obj)) | tag}); + PyStackRef_CheckValid(ref); + return ref; +} + +static inline _PyStackRef +PyStackRef_FromPyObjectBorrow(PyObject *obj) +{ + assert(obj != NULL); + return (_PyStackRef){ .bits = (uintptr_t)obj | Py_TAG_REFCNT }; +} + +static inline _PyStackRef +PyStackRef_FromPyObjectStealMortal(PyObject *obj) +{ + assert(obj != NULL); + assert(!_Py_IsImmortal(obj)); + _PyStackRef ref = ((_PyStackRef){.bits = ((uintptr_t)(obj)) }); + PyStackRef_CheckValid(ref); + return ref; +} + +static inline _PyStackRef +_PyStackRef_FromPyObjectNew(PyObject *obj) +{ + assert(obj != NULL); + if (_Py_IsImmortal(obj)) { + return (_PyStackRef){ .bits = ((uintptr_t)obj) | Py_TAG_REFCNT}; + } + _Py_INCREF_MORTAL(obj); + _PyStackRef ref = (_PyStackRef){ .bits = (uintptr_t)obj }; + PyStackRef_CheckValid(ref); + return ref; +} +#define PyStackRef_FromPyObjectNew(obj) _PyStackRef_FromPyObjectNew(_PyObject_CAST(obj)) + +static inline _PyStackRef +_PyStackRef_FromPyObjectNewMortal(PyObject *obj) +{ + assert(obj != NULL); + _Py_INCREF_MORTAL(obj); + _PyStackRef ref = (_PyStackRef){ .bits = (uintptr_t)obj }; + PyStackRef_CheckValid(ref); + return ref; +} +#define PyStackRef_FromPyObjectNewMortal(obj) _PyStackRef_FromPyObjectNewMortal(_PyObject_CAST(obj)) + +/* Create a new reference from an object with an embedded reference count */ +static inline _PyStackRef +PyStackRef_FromPyObjectImmortal(PyObject *obj) +{ + assert(_Py_IsImmortal(obj)); + return (_PyStackRef){ .bits = (uintptr_t)obj | Py_TAG_REFCNT}; +} + +/* WARNING: This macro evaluates its argument more than once */ +#ifdef _WIN32 +#define PyStackRef_DUP(REF) \ + (PyStackRef_RefcountOnObject(REF) ? (_Py_INCREF_MORTAL(BITS_TO_PTR(REF)), (REF)) : (REF)) +#else +static inline _PyStackRef +PyStackRef_DUP(_PyStackRef ref) +{ + assert(!PyStackRef_IsNull(ref)); + if (PyStackRef_RefcountOnObject(ref)) { + _Py_INCREF_MORTAL(BITS_TO_PTR(ref)); + } + return ref; +} +#endif + +static inline bool +PyStackRef_IsHeapSafe(_PyStackRef ref) +{ + return (ref.bits & Py_TAG_BITS) != Py_TAG_REFCNT || ref.bits == PyStackRef_NULL_BITS || _Py_IsImmortal(BITS_TO_PTR_MASKED(ref)); +} + +static inline _PyStackRef +PyStackRef_MakeHeapSafe(_PyStackRef ref) +{ + if (PyStackRef_IsHeapSafe(ref)) { + return ref; + } + PyObject *obj = BITS_TO_PTR_MASKED(ref); + Py_INCREF(obj); + ref.bits = (uintptr_t)obj; + PyStackRef_CheckValid(ref); + return ref; +} + +#ifdef _WIN32 +#define PyStackRef_CLOSE(REF) \ +do { \ + _PyStackRef _temp = (REF); \ + if (PyStackRef_RefcountOnObject(_temp)) Py_DECREF_MORTAL(BITS_TO_PTR(_temp)); \ +} while (0) +#else +static inline void +PyStackRef_CLOSE(_PyStackRef ref) +{ + assert(!PyStackRef_IsNull(ref)); + if (PyStackRef_RefcountOnObject(ref)) { + Py_DECREF_MORTAL(BITS_TO_PTR(ref)); + } +} +#endif + +static inline bool +PyStackRef_IsNullOrInt(_PyStackRef ref) +{ + return PyStackRef_IsNull(ref) || PyStackRef_IsTaggedInt(ref); +} + +static inline void +PyStackRef_CLOSE_SPECIALIZED(_PyStackRef ref, destructor destruct) +{ + assert(!PyStackRef_IsNull(ref)); + if (PyStackRef_RefcountOnObject(ref)) { + Py_DECREF_MORTAL_SPECIALIZED(BITS_TO_PTR(ref), destruct); + } +} + +#ifdef _WIN32 +#define PyStackRef_XCLOSE PyStackRef_CLOSE +#else +static inline void +PyStackRef_XCLOSE(_PyStackRef ref) +{ + assert(ref.bits != 0); + if (PyStackRef_RefcountOnObject(ref)) { + assert(!PyStackRef_IsNull(ref)); + Py_DECREF_MORTAL(BITS_TO_PTR(ref)); + } +} +#endif + +#define PyStackRef_CLEAR(REF) \ + do { \ + _PyStackRef *_tmp_op_ptr = &(REF); \ + _PyStackRef _tmp_old_op = (*_tmp_op_ptr); \ + *_tmp_op_ptr = PyStackRef_NULL; \ + PyStackRef_XCLOSE(_tmp_old_op); \ + } while (0) + + +#endif // Py_GIL_DISABLED + +// Note: this is a macro because MSVC (Windows) has trouble inlining it. + +#define PyStackRef_Is(a, b) (((a).bits & (~Py_TAG_REFCNT)) == ((b).bits & (~Py_TAG_REFCNT))) + + +#endif // !defined(Py_GIL_DISABLED) && defined(Py_STACKREF_DEBUG) + +#define PyStackRef_TYPE(stackref) Py_TYPE(PyStackRef_AsPyObjectBorrow(stackref)) + +// Converts a PyStackRef back to a PyObject *, converting the +// stackref to a new reference. +#define PyStackRef_AsPyObjectNew(stackref) Py_NewRef(PyStackRef_AsPyObjectBorrow(stackref)) + +// StackRef type checks + +static inline bool +PyStackRef_GenCheck(_PyStackRef stackref) +{ + return PyGen_Check(PyStackRef_AsPyObjectBorrow(stackref)); +} + +static inline bool +PyStackRef_BoolCheck(_PyStackRef stackref) +{ + return PyBool_Check(PyStackRef_AsPyObjectBorrow(stackref)); +} + +static inline bool +PyStackRef_LongCheck(_PyStackRef stackref) +{ + return PyLong_Check(PyStackRef_AsPyObjectBorrow(stackref)); +} + +static inline bool +PyStackRef_ExceptionInstanceCheck(_PyStackRef stackref) +{ + return PyExceptionInstance_Check(PyStackRef_AsPyObjectBorrow(stackref)); +} + +static inline bool +PyStackRef_CodeCheck(_PyStackRef stackref) +{ + return PyCode_Check(PyStackRef_AsPyObjectBorrow(stackref)); +} + +static inline bool +PyStackRef_FunctionCheck(_PyStackRef stackref) +{ + return PyFunction_Check(PyStackRef_AsPyObjectBorrow(stackref)); +} + +static inline void +_PyThreadState_PushCStackRef(PyThreadState *tstate, _PyCStackRef *ref) +{ +#ifdef Py_GIL_DISABLED + _PyThreadStateImpl *tstate_impl = (_PyThreadStateImpl *)tstate; + ref->next = tstate_impl->c_stack_refs; + tstate_impl->c_stack_refs = ref; +#endif + ref->ref = PyStackRef_NULL; +} + +static inline void +_PyThreadState_PushCStackRefNew(PyThreadState *tstate, _PyCStackRef *ref, PyObject *obj) +{ + _PyThreadState_PushCStackRef(tstate, ref); + ref->ref = PyStackRef_FromPyObjectNew(obj); +} + +static inline void +_PyThreadState_PopCStackRef(PyThreadState *tstate, _PyCStackRef *ref) +{ +#ifdef Py_GIL_DISABLED + _PyThreadStateImpl *tstate_impl = (_PyThreadStateImpl *)tstate; + assert(tstate_impl->c_stack_refs == ref); + tstate_impl->c_stack_refs = ref->next; +#endif + PyStackRef_XCLOSE(ref->ref); +} + +static inline _PyStackRef +_PyThreadState_PopCStackRefSteal(PyThreadState *tstate, _PyCStackRef *ref) +{ +#ifdef Py_GIL_DISABLED + _PyThreadStateImpl *tstate_impl = (_PyThreadStateImpl *)tstate; + assert(tstate_impl->c_stack_refs == ref); + tstate_impl->c_stack_refs = ref->next; +#endif + return ref->ref; +} + +#ifdef Py_GIL_DISABLED + +static inline int +_Py_TryIncrefCompareStackRef(PyObject **src, PyObject *op, _PyStackRef *out) +{ + if (_PyObject_HasDeferredRefcount(op)) { + *out = (_PyStackRef){ .bits = (uintptr_t)op | Py_TAG_DEFERRED }; + return 1; + } + if (_Py_TryIncrefCompare(src, op)) { + *out = PyStackRef_FromPyObjectSteal(op); + return 1; + } + return 0; +} + +static inline int +_Py_TryXGetStackRef(PyObject **src, _PyStackRef *out) +{ + PyObject *op = _PyObject_CAST(_Py_atomic_load_ptr_relaxed(src)); + if (op == NULL) { + *out = PyStackRef_NULL; + return 1; + } + return _Py_TryIncrefCompareStackRef(src, op, out); +} + +#endif + +#define PyStackRef_XSETREF(dst, src) \ + do { \ + _PyStackRef _tmp_dst_ref = (dst); \ + (dst) = (src); \ + PyStackRef_XCLOSE(_tmp_dst_ref); \ + } while(0) + +// Like Py_VISIT but for _PyStackRef fields +#define _Py_VISIT_STACKREF(ref) \ + do { \ + if (!PyStackRef_IsNullOrInt(ref)) { \ + int vret = _PyGC_VisitStackRef(&(ref), visit, arg); \ + if (vret) \ + return vret; \ + } \ + } while (0) + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_STACKREF_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_stats.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_stats.h new file mode 100644 index 0000000000000000000000000000000000000000..24f239a2135b93dc3b4ee60d6661bc1d029170eb --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_stats.h @@ -0,0 +1,97 @@ +#ifndef Py_INTERNAL_STATS_H +#define Py_INTERNAL_STATS_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_structs.h" // + + +#ifdef Py_STATS + +#include "pycore_bitutils.h" // _Py_bit_length + +#define STAT_INC(opname, name) do { if (_Py_stats) _Py_stats->opcode_stats[opname].specialization.name++; } while (0) +#define STAT_DEC(opname, name) do { if (_Py_stats) _Py_stats->opcode_stats[opname].specialization.name--; } while (0) +#define OPCODE_EXE_INC(opname) do { if (_Py_stats) _Py_stats->opcode_stats[opname].execution_count++; } while (0) +#define CALL_STAT_INC(name) do { if (_Py_stats) _Py_stats->call_stats.name++; } while (0) +#define OBJECT_STAT_INC(name) do { if (_Py_stats) _Py_stats->object_stats.name++; } while (0) +#define OBJECT_STAT_INC_COND(name, cond) \ + do { if (_Py_stats && cond) _Py_stats->object_stats.name++; } while (0) +#define EVAL_CALL_STAT_INC(name) do { if (_Py_stats) _Py_stats->call_stats.eval_calls[name]++; } while (0) +#define EVAL_CALL_STAT_INC_IF_FUNCTION(name, callable) \ + do { if (_Py_stats && PyFunction_Check(callable)) _Py_stats->call_stats.eval_calls[name]++; } while (0) +#define GC_STAT_ADD(gen, name, n) do { if (_Py_stats) _Py_stats->gc_stats[(gen)].name += (n); } while (0) +#define OPT_STAT_INC(name) do { if (_Py_stats) _Py_stats->optimization_stats.name++; } while (0) +#define OPT_STAT_ADD(name, n) do { if (_Py_stats) _Py_stats->optimization_stats.name += (n); } while (0) +#define UOP_STAT_INC(opname, name) do { if (_Py_stats) { assert(opname < 512); _Py_stats->optimization_stats.opcode[opname].name++; } } while (0) +#define UOP_PAIR_INC(uopcode, lastuop) \ + do { \ + if (lastuop && _Py_stats) { \ + _Py_stats->optimization_stats.opcode[lastuop].pair_count[uopcode]++; \ + } \ + lastuop = uopcode; \ + } while (0) +#define OPT_UNSUPPORTED_OPCODE(opname) do { if (_Py_stats) _Py_stats->optimization_stats.unsupported_opcode[opname]++; } while (0) +#define OPT_ERROR_IN_OPCODE(opname) do { if (_Py_stats) _Py_stats->optimization_stats.error_in_opcode[opname]++; } while (0) +#define OPT_HIST(length, name) \ + do { \ + if (_Py_stats) { \ + int bucket = _Py_bit_length(length >= 1 ? length - 1 : 0); \ + bucket = (bucket >= _Py_UOP_HIST_SIZE) ? _Py_UOP_HIST_SIZE - 1 : bucket; \ + _Py_stats->optimization_stats.name[bucket]++; \ + } \ + } while (0) +#define RARE_EVENT_STAT_INC(name) do { if (_Py_stats) _Py_stats->rare_event_stats.name++; } while (0) +#define OPCODE_DEFERRED_INC(opname) do { if (_Py_stats && opcode == opname) _Py_stats->opcode_stats[opname].specialization.deferred++; } while (0) + +// Export for '_opcode' shared extension +PyAPI_FUNC(PyObject*) _Py_GetSpecializationStats(void); + +#else +#define STAT_INC(opname, name) ((void)0) +#define STAT_DEC(opname, name) ((void)0) +#define OPCODE_EXE_INC(opname) ((void)0) +#define CALL_STAT_INC(name) ((void)0) +#define OBJECT_STAT_INC(name) ((void)0) +#define OBJECT_STAT_INC_COND(name, cond) ((void)0) +#define EVAL_CALL_STAT_INC(name) ((void)0) +#define EVAL_CALL_STAT_INC_IF_FUNCTION(name, callable) ((void)0) +#define GC_STAT_ADD(gen, name, n) ((void)0) +#define OPT_STAT_INC(name) ((void)0) +#define OPT_STAT_ADD(name, n) ((void)0) +#define UOP_STAT_INC(opname, name) ((void)0) +#define UOP_PAIR_INC(uopcode, lastuop) ((void)0) +#define OPT_UNSUPPORTED_OPCODE(opname) ((void)0) +#define OPT_ERROR_IN_OPCODE(opname) ((void)0) +#define OPT_HIST(length, name) ((void)0) +#define RARE_EVENT_STAT_INC(name) ((void)0) +#define OPCODE_DEFERRED_INC(opname) ((void)0) +#endif // !Py_STATS + + +#define RARE_EVENT_INTERP_INC(interp, name) \ + do { \ + /* saturating add */ \ + uint8_t val = FT_ATOMIC_LOAD_UINT8_RELAXED(interp->rare_events.name); \ + if (val < UINT8_MAX) { \ + FT_ATOMIC_STORE_UINT8(interp->rare_events.name, val + 1); \ + } \ + RARE_EVENT_STAT_INC(name); \ + } while (0); \ + +#define RARE_EVENT_INC(name) \ + do { \ + PyInterpreterState *interp = PyInterpreterState_Get(); \ + RARE_EVENT_INTERP_INC(interp, name); \ + } while (0); \ + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_STATS_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_strhex.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_strhex.h new file mode 100644 index 0000000000000000000000000000000000000000..225f423912f2c27eabe64de90a3f9b916cb03577 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_strhex.h @@ -0,0 +1,39 @@ +#ifndef Py_INTERNAL_STRHEX_H +#define Py_INTERNAL_STRHEX_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +// Returns a str() containing the hex representation of argbuf. +// Export for '_hashlib' shared extension. +PyAPI_FUNC(PyObject*) _Py_strhex(const + char* argbuf, + const Py_ssize_t arglen); + +// Returns a bytes() containing the ASCII hex representation of argbuf. +extern PyObject* _Py_strhex_bytes( + const char* argbuf, + const Py_ssize_t arglen); + +// These variants include support for a separator between every N bytes: +extern PyObject* _Py_strhex_with_sep( + const char* argbuf, + const Py_ssize_t arglen, + PyObject* sep, + const int bytes_per_group); + +// Export for 'binascii' shared extension +PyAPI_FUNC(PyObject*) _Py_strhex_bytes_with_sep( + const char* argbuf, + const Py_ssize_t arglen, + PyObject* sep, + const int bytes_per_group); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_STRHEX_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_structs.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_structs.h new file mode 100644 index 0000000000000000000000000000000000000000..0d5f5dc7acc773beeaa15e06faace3fb9c12cdc6 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_structs.h @@ -0,0 +1,88 @@ +/* This files contains various key structs that are widely used + * and do not depend on other headers. */ + +#ifndef Py_INTERNAL_STRUCTS_H +#define Py_INTERNAL_STRUCTS_H +#ifdef __cplusplus +extern "C" { +#endif + +#include // uint16_t + + +typedef struct { + uint16_t value_and_backoff; +} _Py_BackoffCounter; + +/* Each instruction in a code object is a fixed-width value, + * currently 2 bytes: 1-byte opcode + 1-byte oparg. The EXTENDED_ARG + * opcode allows for larger values but the current limit is 3 uses + * of EXTENDED_ARG (see Python/compile.c), for a maximum + * 32-bit value. This aligns with the note in Python/compile.c + * (compiler_addop_i_line) indicating that the max oparg value is + * 2**32 - 1, rather than INT_MAX. + */ +typedef union { + uint16_t cache; + struct { + uint8_t code; + uint8_t arg; + } op; + _Py_BackoffCounter counter; // First cache entry of specializable op +} _Py_CODEUNIT; + + +/* Abstract tree node. */ +typedef struct { + PyObject_HEAD +} PyHamtNode; + + +/* An HAMT immutable mapping collection. */ +typedef struct { + PyObject_HEAD + PyHamtNode *h_root; + PyObject *h_weakreflist; + Py_ssize_t h_count; +} PyHamtObject; + +typedef struct { + PyObject_VAR_HEAD + uint32_t b_bitmap; + PyObject *b_array[1]; +} PyHamtNode_Bitmap; + +#include "pycore_context.h" // _PyContextTokenMissing + +// Define this to get precise tracking of stackrefs. +// #define Py_STACKREF_DEBUG 1 + +// Define this to get precise tracking of closed stackrefs. +// This will use unbounded memory, as it can only grow. +// Use this to track double closes in short-lived programs +// #define Py_STACKREF_CLOSE_DEBUG 1 + + +typedef union _PyStackRef { +#if !defined(Py_GIL_DISABLED) && defined(Py_STACKREF_DEBUG) + uint64_t index; +#else + uintptr_t bits; +#endif +} _PyStackRef; + +// A stackref that can be stored in a regular C local variable and be visible +// to the GC in the free threading build. +// Used in combination with _PyThreadState_PushCStackRef(). +typedef struct _PyCStackRef { + _PyStackRef ref; +#ifdef Py_GIL_DISABLED + struct _PyCStackRef *next; +#endif +} _PyCStackRef; + + +#ifdef __cplusplus +} +#endif +#endif /* Py_INTERNAL_STRUCTS_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_structseq.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_structseq.h new file mode 100644 index 0000000000000000000000000000000000000000..5cff165627502bd865abda793c469c4eeb01f588 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_structseq.h @@ -0,0 +1,40 @@ +#ifndef Py_INTERNAL_STRUCTSEQ_H +#define Py_INTERNAL_STRUCTSEQ_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + + +/* other API */ + +// Export for '_curses' shared extension +PyAPI_FUNC(PyTypeObject*) _PyStructSequence_NewType( + PyStructSequence_Desc *desc, + unsigned long tp_flags); + +extern int _PyStructSequence_InitBuiltinWithFlags( + PyInterpreterState *interp, + PyTypeObject *type, + PyStructSequence_Desc *desc, + unsigned long tp_flags); + +static inline int +_PyStructSequence_InitBuiltin(PyInterpreterState *interp, + PyTypeObject *type, + PyStructSequence_Desc *desc) +{ + return _PyStructSequence_InitBuiltinWithFlags(interp, type, desc, 0); +} + +extern void _PyStructSequence_FiniBuiltin( + PyInterpreterState *interp, + PyTypeObject *type); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_STRUCTSEQ_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_symtable.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_symtable.h new file mode 100644 index 0000000000000000000000000000000000000000..98099b4a497b01631d6ba28e7d162e92855d8231 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_symtable.h @@ -0,0 +1,201 @@ +#ifndef Py_INTERNAL_SYMTABLE_H +#define Py_INTERNAL_SYMTABLE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +struct _mod; // Type defined in pycore_ast.h + +typedef enum _block_type { + FunctionBlock, ClassBlock, ModuleBlock, + // Used for annotations. If 'from __future__ import annotations' is active, + // annotation blocks cannot bind names and are not evaluated. Otherwise, they + // are lazily evaluated (see PEP 649). + AnnotationBlock, + + // The following blocks are used for generics and type aliases. These work + // mostly like functions (see PEP 695 for details). The three different + // blocks function identically; they are different enum entries only so + // that error messages can be more precise. + + // The block to enter when processing a "type" (PEP 695) construction, + // e.g., "type MyGeneric[T] = list[T]". + TypeAliasBlock, + // The block to enter when processing a "generic" (PEP 695) object, + // e.g., "def foo[T](): pass" or "class A[T]: pass". + TypeParametersBlock, + // The block to enter when processing the bound, the constraint tuple + // or the default value of a single "type variable" in the formal sense, + // i.e., a TypeVar, a TypeVarTuple or a ParamSpec object (the latter two + // do not support a bound or a constraint tuple). + TypeVariableBlock, +} _Py_block_ty; + +typedef enum _comprehension_type { + NoComprehension = 0, + ListComprehension = 1, + DictComprehension = 2, + SetComprehension = 3, + GeneratorExpression = 4 } _Py_comprehension_ty; + +/* source location information */ +typedef struct { + int lineno; + int end_lineno; + int col_offset; + int end_col_offset; +} _Py_SourceLocation; + +#define SRC_LOCATION_FROM_AST(n) \ + (_Py_SourceLocation){ \ + .lineno = (n)->lineno, \ + .end_lineno = (n)->end_lineno, \ + .col_offset = (n)->col_offset, \ + .end_col_offset = (n)->end_col_offset } + +static const _Py_SourceLocation NO_LOCATION = {-1, -1, -1, -1}; +static const _Py_SourceLocation NEXT_LOCATION = {-2, -2, -2, -2}; + +/* __future__ information */ +typedef struct { + int ff_features; /* flags set by future statements */ + _Py_SourceLocation ff_location; /* location of last future statement */ +} _PyFutureFeatures; + +struct _symtable_entry; + +struct symtable { + PyObject *st_filename; /* name of file being compiled, + decoded from the filesystem encoding */ + struct _symtable_entry *st_cur; /* current symbol table entry */ + struct _symtable_entry *st_top; /* symbol table entry for module */ + PyObject *st_blocks; /* dict: map AST node addresses + * to symbol table entries */ + PyObject *st_stack; /* list: stack of namespace info */ + PyObject *st_global; /* borrowed ref to st_top->ste_symbols */ + int st_nblocks; /* number of blocks used. kept for + consistency with the corresponding + compiler structure */ + PyObject *st_private; /* name of current class or NULL */ + _PyFutureFeatures *st_future; /* module's future features that affect + the symbol table */ +}; + +typedef struct _symtable_entry { + PyObject_HEAD + PyObject *ste_id; /* int: key in ste_table->st_blocks */ + PyObject *ste_symbols; /* dict: variable names to flags */ + PyObject *ste_name; /* string: name of current block */ + PyObject *ste_varnames; /* list of function parameters */ + PyObject *ste_children; /* list of child blocks */ + PyObject *ste_directives;/* locations of global and nonlocal statements */ + PyObject *ste_mangled_names; /* set of names for which mangling should be applied */ + + _Py_block_ty ste_type; + // Optional string set by symtable.c and used when reporting errors. + // The content of that string is a description of the current "context". + // + // For instance, if we are processing the default value of the type + // variable "T" in "def foo[T = int](): pass", `ste_scope_info` is + // set to "a TypeVar default". + const char *ste_scope_info; + + int ste_nested; /* true if block is nested */ + unsigned ste_generator : 1; /* true if namespace is a generator */ + unsigned ste_coroutine : 1; /* true if namespace is a coroutine */ + unsigned ste_annotations_used : 1; /* true if there are any annotations in this scope */ + _Py_comprehension_ty ste_comprehension; /* Kind of comprehension (if any) */ + unsigned ste_varargs : 1; /* true if block has varargs */ + unsigned ste_varkeywords : 1; /* true if block has varkeywords */ + unsigned ste_returns_value : 1; /* true if namespace uses return with + an argument */ + unsigned ste_needs_class_closure : 1; /* for class scopes, true if a + closure over __class__ + should be created */ + unsigned ste_needs_classdict : 1; /* for class scopes, true if a closure + over the class dict should be created */ + unsigned ste_comp_inlined : 1; /* true if this comprehension is inlined */ + unsigned ste_comp_iter_target : 1; /* true if visiting comprehension target */ + unsigned ste_can_see_class_scope : 1; /* true if this block can see names bound in an + enclosing class scope */ + unsigned ste_has_docstring : 1; /* true if docstring present */ + unsigned ste_method : 1; /* true if block is a function block defined in class scope */ + unsigned ste_has_conditional_annotations : 1; /* true if block has conditionally executed annotations */ + unsigned ste_in_conditional_block : 1; /* set while we are inside a conditionally executed block */ + unsigned ste_in_unevaluated_annotation : 1; /* set while we are processing an annotation that will not be evaluated */ + int ste_comp_iter_expr; /* non-zero if visiting a comprehension range expression */ + _Py_SourceLocation ste_loc; /* source location of block */ + struct _symtable_entry *ste_annotation_block; /* symbol table entry for this entry's annotations */ + struct symtable *ste_table; +} PySTEntryObject; + +extern PyTypeObject PySTEntry_Type; + +#define PySTEntry_Check(op) Py_IS_TYPE((op), &PySTEntry_Type) + +extern long _PyST_GetSymbol(PySTEntryObject *, PyObject *); +extern int _PyST_GetScope(PySTEntryObject *, PyObject *); +extern int _PyST_IsFunctionLike(PySTEntryObject *); + +extern struct symtable* _PySymtable_Build( + struct _mod *mod, + PyObject *filename, + _PyFutureFeatures *future); +extern PySTEntryObject* _PySymtable_Lookup(struct symtable *, void *); +extern int _PySymtable_LookupOptional(struct symtable *, void *, PySTEntryObject **); + +extern void _PySymtable_Free(struct symtable *); + +extern PyObject *_Py_MaybeMangle(PyObject *privateobj, PySTEntryObject *ste, PyObject *name); +extern PyObject* _Py_Mangle(PyObject *p, PyObject *name); + +/* Flags for def-use information */ + +#define DEF_GLOBAL 1 /* global stmt */ +#define DEF_LOCAL 2 /* assignment in code block */ +#define DEF_PARAM (2<<1) /* formal parameter */ +#define DEF_NONLOCAL (2<<2) /* nonlocal stmt */ +#define USE (2<<3) /* name is used */ +#define DEF_FREE_CLASS (2<<5) /* free variable from class's method */ +#define DEF_IMPORT (2<<6) /* assignment occurred via import */ +#define DEF_ANNOT (2<<7) /* this name is annotated */ +#define DEF_COMP_ITER (2<<8) /* this name is a comprehension iteration variable */ +#define DEF_TYPE_PARAM (2<<9) /* this name is a type parameter */ +#define DEF_COMP_CELL (2<<10) /* this name is a cell in an inlined comprehension */ + +#define DEF_BOUND (DEF_LOCAL | DEF_PARAM | DEF_IMPORT) + +/* GLOBAL_EXPLICIT and GLOBAL_IMPLICIT are used internally by the symbol + table. GLOBAL is returned from _PyST_GetScope() for either of them. + It is stored in ste_symbols at bits 13-16. +*/ +#define SCOPE_OFFSET 12 +#define SCOPE_MASK (DEF_GLOBAL | DEF_LOCAL | DEF_PARAM | DEF_NONLOCAL) +#define SYMBOL_TO_SCOPE(S) (((S) >> SCOPE_OFFSET) & SCOPE_MASK) + +#define LOCAL 1 +#define GLOBAL_EXPLICIT 2 +#define GLOBAL_IMPLICIT 3 +#define FREE 4 +#define CELL 5 + +// Used by symtablemodule.c +extern struct symtable* _Py_SymtableStringObjectFlags( + const char *str, + PyObject *filename, + int start, + PyCompilerFlags *flags); + +int _PyFuture_FromAST( + struct _mod * mod, + PyObject *filename, + _PyFutureFeatures* futures); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_SYMTABLE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_sysmodule.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_sysmodule.h new file mode 100644 index 0000000000000000000000000000000000000000..008a2da0d04fa7436aa10d85fd03ecf02bb8018a --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_sysmodule.h @@ -0,0 +1,32 @@ +#ifndef Py_INTERNAL_SYSMODULE_H +#define Py_INTERNAL_SYSMODULE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +PyAPI_FUNC(int) _PySys_GetOptionalAttr(PyObject *, PyObject **); +PyAPI_FUNC(int) _PySys_GetOptionalAttrString(const char *, PyObject **); +PyAPI_FUNC(PyObject *) _PySys_GetRequiredAttr(PyObject *); +PyAPI_FUNC(PyObject *) _PySys_GetRequiredAttrString(const char *); + +// Export for '_pickle' shared extension +PyAPI_FUNC(size_t) _PySys_GetSizeOf(PyObject *); + +extern int _PySys_SetAttr(PyObject *, PyObject *); + +extern int _PySys_ClearAttrString(PyInterpreterState *interp, + const char *name, int verbose); + +extern int _PySys_SetFlagObj(Py_ssize_t pos, PyObject *new_value); +extern int _PySys_SetIntMaxStrDigits(int maxdigits); + +extern int _PySysRemoteDebug_SendExec(int pid, int tid, const char *debugger_script_path); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_SYSMODULE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_template.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_template.h new file mode 100644 index 0000000000000000000000000000000000000000..f2f8bf9912d3f6f96d579ba7ba704ba8ded97a2d --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_template.h @@ -0,0 +1,26 @@ +#ifndef Py_INTERNAL_TEMPLATE_H +#define Py_INTERNAL_TEMPLATE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +extern PyTypeObject _PyTemplate_Type; +extern PyTypeObject _PyTemplateIter_Type; + +#define _PyTemplate_CheckExact(op) Py_IS_TYPE((op), &_PyTemplate_Type) +#define _PyTemplateIter_CheckExact(op) Py_IS_TYPE((op), &_PyTemplateIter_Type) + +extern PyObject *_PyTemplate_Concat(PyObject *self, PyObject *other); + +PyAPI_FUNC(PyObject *) _PyTemplate_Build(PyObject *strings, PyObject *interpolations); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_time.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_time.h new file mode 100644 index 0000000000000000000000000000000000000000..23312471c6584efee837e0b5c51cf6401391afa5 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_time.h @@ -0,0 +1,334 @@ +// Internal PyTime_t C API: see Doc/c-api/time.rst for the documentation. +// +// The PyTime_t type is an integer to support directly common arithmetic +// operations such as t1 + t2. +// +// Time formats: +// +// * Seconds. +// * Seconds as a floating-point number (C double). +// * Milliseconds (10^-3 seconds). +// * Microseconds (10^-6 seconds). +// * 100 nanoseconds (10^-7 seconds), used on Windows. +// * Nanoseconds (10^-9 seconds). +// * timeval structure, 1 microsecond (10^-6 seconds). +// * timespec structure, 1 nanosecond (10^-9 seconds). +// +// Note that PyTime_t is now specified as int64_t, in nanoseconds. +// (If we need to change this, we'll need new public API with new names.) +// Previously, PyTime_t was configurable (in theory); some comments and code +// might still allude to that. +// +// Integer overflows are detected and raise OverflowError. Conversion to a +// resolution larger than 1 nanosecond is rounded correctly with the requested +// rounding mode. Available rounding modes: +// +// * Round towards minus infinity (-inf). For example, used to read a clock. +// * Round towards infinity (+inf). For example, used for timeout to wait "at +// least" N seconds. +// * Round to nearest with ties going to nearest even integer. For example, used +// to round from a Python float. +// * Round away from zero. For example, used for timeout. +// +// Some functions clamp the result in the range [PyTime_MIN; PyTime_MAX]. The +// caller doesn't have to handle errors and so doesn't need to hold the GIL to +// handle exceptions. For example, _PyTime_Add(t1, t2) computes t1+t2 and +// clamps the result on overflow. +// +// Clocks: +// +// * System clock +// * Monotonic clock +// * Performance counter +// +// Internally, operations like (t * k / q) with integers are implemented in a +// way to reduce the risk of integer overflow. Such operation is used to convert a +// clock value expressed in ticks with a frequency to PyTime_t, like +// QueryPerformanceCounter() with QueryPerformanceFrequency() on Windows. + + +#ifndef Py_INTERNAL_TIME_H +#define Py_INTERNAL_TIME_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_runtime_structs.h" // _PyTimeFraction + +#ifdef __clang__ +struct timeval; +#endif + +#define _SIZEOF_PYTIME_T 8 + +typedef enum { + // Round towards minus infinity (-inf). + // For example, used to read a clock. + _PyTime_ROUND_FLOOR=0, + + // Round towards infinity (+inf). + // For example, used for timeout to wait "at least" N seconds. + _PyTime_ROUND_CEILING=1, + + // Round to nearest with ties going to nearest even integer. + // For example, used to round from a Python float. + _PyTime_ROUND_HALF_EVEN=2, + + // Round away from zero + // For example, used for timeout. _PyTime_ROUND_CEILING rounds + // -1e-9 to 0 milliseconds which causes bpo-31786 issue. + // _PyTime_ROUND_UP rounds -1e-9 to -1 millisecond which keeps + // the timeout sign as expected. select.poll(timeout) must block + // for negative values. + _PyTime_ROUND_UP=3, + + // _PyTime_ROUND_TIMEOUT (an alias for _PyTime_ROUND_UP) should be + // used for timeouts. + _PyTime_ROUND_TIMEOUT = _PyTime_ROUND_UP +} _PyTime_round_t; + + +// Convert a time_t to a PyLong. +// Export for '_testinternalcapi' shared extension +PyAPI_FUNC(PyObject*) _PyLong_FromTime_t(time_t sec); + +// Convert a PyLong to a time_t. +// Export for '_datetime' shared extension +PyAPI_FUNC(time_t) _PyLong_AsTime_t(PyObject *obj); + +// Convert a number of seconds, int or float, to time_t. +// Export for '_datetime' shared extension. +PyAPI_FUNC(int) _PyTime_ObjectToTime_t( + PyObject *obj, + time_t *sec, + _PyTime_round_t); + +// Convert a number of seconds, int or float, to a timeval structure. +// usec is in the range [0; 999999] and rounded towards zero. +// For example, -1.2 is converted to (-2, 800000). +// Export for '_datetime' shared extension. +PyAPI_FUNC(int) _PyTime_ObjectToTimeval( + PyObject *obj, + time_t *sec, + long *usec, + _PyTime_round_t); + +// Convert a number of seconds, int or float, to a timespec structure. +// nsec is in the range [0; 999999999] and rounded towards zero. +// For example, -1.2 is converted to (-2, 800000000). +// Export for '_testinternalcapi' shared extension. +PyAPI_FUNC(int) _PyTime_ObjectToTimespec( + PyObject *obj, + time_t *sec, + long *nsec, + _PyTime_round_t); + + +// Create a timestamp from a number of seconds. +// Export for '_socket' shared extension. +PyAPI_FUNC(PyTime_t) _PyTime_FromSeconds(int seconds); + +// Create a timestamp from a number of seconds in double. +extern int _PyTime_FromSecondsDouble( + double seconds, + _PyTime_round_t round, + PyTime_t *result); + +// Macro to create a timestamp from a number of seconds, no integer overflow. +// Only use the macro for small values, prefer _PyTime_FromSeconds(). +#define _PYTIME_FROMSECONDS(seconds) \ + ((PyTime_t)(seconds) * (1000 * 1000 * 1000)) + +// Create a timestamp from a number of microseconds. +// Clamp to [PyTime_MIN; PyTime_MAX] on overflow. +extern PyTime_t _PyTime_FromMicrosecondsClamp(PyTime_t us); + +// Create a timestamp from a Python int object (number of nanoseconds). +// Export for '_lsprof' shared extension. +PyAPI_FUNC(int) _PyTime_FromLong(PyTime_t *t, + PyObject *obj); + +// Convert a number of seconds (Python float or int) to a timestamp. +// Raise an exception and return -1 on error, return 0 on success. +// Export for '_socket' shared extension. +PyAPI_FUNC(int) _PyTime_FromSecondsObject(PyTime_t *t, + PyObject *obj, + _PyTime_round_t round); + +// Convert a number of milliseconds (Python float or int, 10^-3) to a timestamp. +// Raise an exception and return -1 on error, return 0 on success. +// Export for 'select' shared extension. +PyAPI_FUNC(int) _PyTime_FromMillisecondsObject(PyTime_t *t, + PyObject *obj, + _PyTime_round_t round); + +// Convert timestamp to a number of milliseconds (10^-3 seconds). +// Export for '_ssl' shared extension. +PyAPI_FUNC(PyTime_t) _PyTime_AsMilliseconds(PyTime_t t, + _PyTime_round_t round); + +// Convert timestamp to a number of microseconds (10^-6 seconds). +// Export for '_queue' shared extension. +PyAPI_FUNC(PyTime_t) _PyTime_AsMicroseconds(PyTime_t t, + _PyTime_round_t round); + +#ifdef MS_WINDOWS +// Convert timestamp to a number of 100 nanoseconds (10^-7 seconds). +extern PyTime_t _PyTime_As100Nanoseconds(PyTime_t t, + _PyTime_round_t round); +#endif + +// Convert a timestamp (number of nanoseconds) as a Python int object. +// Export for '_testinternalcapi' shared extension. +PyAPI_FUNC(PyObject*) _PyTime_AsLong(PyTime_t t); + +#ifndef MS_WINDOWS +// Create a timestamp from a timeval structure. +// Raise an exception and return -1 on overflow, return 0 on success. +extern int _PyTime_FromTimeval(PyTime_t *tp, struct timeval *tv); +#endif + +// Convert a timestamp to a timeval structure (microsecond resolution). +// tv_usec is always positive. +// Raise an exception and return -1 if the conversion overflowed, +// return 0 on success. +// Export for 'select' shared extension. +PyAPI_FUNC(int) _PyTime_AsTimeval(PyTime_t t, + struct timeval *tv, + _PyTime_round_t round); + +// Similar to _PyTime_AsTimeval() but don't raise an exception on overflow. +// On overflow, clamp tv_sec to PyTime_t min/max. +// Export for 'select' shared extension. +PyAPI_FUNC(void) _PyTime_AsTimeval_clamp(PyTime_t t, + struct timeval *tv, + _PyTime_round_t round); + +// Convert a timestamp to a number of seconds (secs) and microseconds (us). +// us is always positive. This function is similar to _PyTime_AsTimeval() +// except that secs is always a time_t type, whereas the timeval structure +// uses a C long for tv_sec on Windows. +// Raise an exception and return -1 if the conversion overflowed, +// return 0 on success. +// Export for '_datetime' shared extension. +PyAPI_FUNC(int) _PyTime_AsTimevalTime_t( + PyTime_t t, + time_t *secs, + int *us, + _PyTime_round_t round); + +#if defined(HAVE_CLOCK_GETTIME) || defined(HAVE_KQUEUE) +// Create a timestamp from a timespec structure. +// Raise an exception and return -1 on overflow, return 0 on success. +extern int _PyTime_FromTimespec(PyTime_t *tp, const struct timespec *ts); + +// Convert a timestamp to a timespec structure (nanosecond resolution). +// tv_nsec is always positive. +// Raise an exception and return -1 on error, return 0 on success. +// Export for '_testinternalcapi' shared extension. +PyAPI_FUNC(int) _PyTime_AsTimespec(PyTime_t t, struct timespec *ts); + +// Similar to _PyTime_AsTimespec() but don't raise an exception on overflow. +// On overflow, clamp tv_sec to PyTime_t min/max. +// Export for '_testinternalcapi' shared extension. +PyAPI_FUNC(void) _PyTime_AsTimespec_clamp(PyTime_t t, struct timespec *ts); +#endif + + +// Compute t1 + t2. Clamp to [PyTime_MIN; PyTime_MAX] on overflow. +extern PyTime_t _PyTime_Add(PyTime_t t1, PyTime_t t2); + +// Structure used by time.get_clock_info() +typedef struct { + const char *implementation; + int monotonic; + int adjustable; + double resolution; +} _Py_clock_info_t; + +// Get the current time from the system clock. +// On success, set *t and *info (if not NULL), and return 0. +// On error, raise an exception and return -1. +extern int _PyTime_TimeWithInfo( + PyTime_t *t, + _Py_clock_info_t *info); + +// Get the time of a monotonic clock, i.e. a clock that cannot go backwards. +// The clock is not affected by system clock updates. The reference point of +// the returned value is undefined, so that only the difference between the +// results of consecutive calls is valid. +// +// Fill info (if set) with information of the function used to get the time. +// +// Return 0 on success, raise an exception and return -1 on error. +// Export for '_testsinglephase' shared extension. +PyAPI_FUNC(int) _PyTime_MonotonicWithInfo( + PyTime_t *t, + _Py_clock_info_t *info); + + +// Converts a timestamp to the Gregorian time, using the local time zone. +// Return 0 on success, raise an exception and return -1 on error. +// Export for '_datetime' shared extension. +PyAPI_FUNC(int) _PyTime_localtime(time_t t, struct tm *tm); + +// Converts a timestamp to the Gregorian time, assuming UTC. +// Return 0 on success, raise an exception and return -1 on error. +// Export for '_datetime' shared extension. +PyAPI_FUNC(int) _PyTime_gmtime(time_t t, struct tm *tm); + + +// Get the performance counter: clock with the highest available resolution to +// measure a short duration. +// +// Fill info (if set) with information of the function used to get the time. +// +// Return 0 on success, raise an exception and return -1 on error. +extern int _PyTime_PerfCounterWithInfo( + PyTime_t *t, + _Py_clock_info_t *info); + + +// --- _PyDeadline ----------------------------------------------------------- + +// Create a deadline. +// Pseudo code: return PyTime_MonotonicRaw() + timeout +// Export for '_ssl' shared extension. +PyAPI_FUNC(PyTime_t) _PyDeadline_Init(PyTime_t timeout); + +// Get remaining time from a deadline. +// Pseudo code: return deadline - PyTime_MonotonicRaw() +// Export for '_ssl' shared extension. +PyAPI_FUNC(PyTime_t) _PyDeadline_Get(PyTime_t deadline); + + +// --- _PyTimeFraction ------------------------------------------------------- + +// Set a fraction. +// Return 0 on success. +// Return -1 if the fraction is invalid. +extern int _PyTimeFraction_Set( + _PyTimeFraction *frac, + PyTime_t numer, + PyTime_t denom); + +// Compute ticks * frac.numer / frac.denom. +// Clamp to [PyTime_MIN; PyTime_MAX] on overflow. +extern PyTime_t _PyTimeFraction_Mul( + PyTime_t ticks, + const _PyTimeFraction *frac); + +// Compute a clock resolution: frac.numer / frac.denom / 1e9. +extern double _PyTimeFraction_Resolution( + const _PyTimeFraction *frac); + +extern PyStatus _PyTime_Init(struct _Py_time_runtime_state *state); + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_TIME_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_token.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_token.h new file mode 100644 index 0000000000000000000000000000000000000000..5de1f719a2f1a284ab905af3a1691ece58b36383 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_token.h @@ -0,0 +1,110 @@ +// Auto-generated by Tools/build/generate_token.py + +/* Token types */ +#ifndef Py_INTERNAL_TOKEN_H +#define Py_INTERNAL_TOKEN_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#undef TILDE /* Prevent clash of our definition with system macro. Ex AIX, ioctl.h */ + +#define ENDMARKER 0 +#define NAME 1 +#define NUMBER 2 +#define STRING 3 +#define NEWLINE 4 +#define INDENT 5 +#define DEDENT 6 +#define LPAR 7 +#define RPAR 8 +#define LSQB 9 +#define RSQB 10 +#define COLON 11 +#define COMMA 12 +#define SEMI 13 +#define PLUS 14 +#define MINUS 15 +#define STAR 16 +#define SLASH 17 +#define VBAR 18 +#define AMPER 19 +#define LESS 20 +#define GREATER 21 +#define EQUAL 22 +#define DOT 23 +#define PERCENT 24 +#define LBRACE 25 +#define RBRACE 26 +#define EQEQUAL 27 +#define NOTEQUAL 28 +#define LESSEQUAL 29 +#define GREATEREQUAL 30 +#define TILDE 31 +#define CIRCUMFLEX 32 +#define LEFTSHIFT 33 +#define RIGHTSHIFT 34 +#define DOUBLESTAR 35 +#define PLUSEQUAL 36 +#define MINEQUAL 37 +#define STAREQUAL 38 +#define SLASHEQUAL 39 +#define PERCENTEQUAL 40 +#define AMPEREQUAL 41 +#define VBAREQUAL 42 +#define CIRCUMFLEXEQUAL 43 +#define LEFTSHIFTEQUAL 44 +#define RIGHTSHIFTEQUAL 45 +#define DOUBLESTAREQUAL 46 +#define DOUBLESLASH 47 +#define DOUBLESLASHEQUAL 48 +#define AT 49 +#define ATEQUAL 50 +#define RARROW 51 +#define ELLIPSIS 52 +#define COLONEQUAL 53 +#define EXCLAMATION 54 +#define OP 55 +#define TYPE_IGNORE 56 +#define TYPE_COMMENT 57 +#define SOFT_KEYWORD 58 +#define FSTRING_START 59 +#define FSTRING_MIDDLE 60 +#define FSTRING_END 61 +#define TSTRING_START 62 +#define TSTRING_MIDDLE 63 +#define TSTRING_END 64 +#define COMMENT 65 +#define NL 66 +#define ERRORTOKEN 67 +#define N_TOKENS 69 +#define NT_OFFSET 256 + +/* Special definitions for cooperation with parser */ + +#define ISTERMINAL(x) ((x) < NT_OFFSET) +#define ISNONTERMINAL(x) ((x) >= NT_OFFSET) +#define ISEOF(x) ((x) == ENDMARKER) +#define ISWHITESPACE(x) ((x) == ENDMARKER || \ + (x) == NEWLINE || \ + (x) == INDENT || \ + (x) == DEDENT) +#define ISSTRINGLIT(x) ((x) == STRING || \ + (x) == FSTRING_MIDDLE || \ + (x) == TSTRING_MIDDLE) + + +// Export these 4 symbols for 'test_peg_generator' +PyAPI_DATA(const char * const) _PyParser_TokenNames[]; /* Token names */ +PyAPI_FUNC(int) _PyToken_OneChar(int); +PyAPI_FUNC(int) _PyToken_TwoChars(int, int); +PyAPI_FUNC(int) _PyToken_ThreeChars(int, int, int); + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_TOKEN_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_traceback.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_traceback.h new file mode 100644 index 0000000000000000000000000000000000000000..8357cce9d899fbb5d2a6944d9d86c6dd1a4eea5b --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_traceback.h @@ -0,0 +1,111 @@ +#ifndef Py_INTERNAL_TRACEBACK_H +#define Py_INTERNAL_TRACEBACK_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +// Export for '_ctypes' shared extension +PyAPI_FUNC(int) _Py_DisplaySourceLine(PyObject *, PyObject *, int, int, int *, PyObject **); + +// Export for 'pyexact' shared extension +PyAPI_FUNC(void) _PyTraceback_Add(const char *, const char *, int); + +/* Write the Python traceback into the file 'fd'. For example: + + Traceback (most recent call first): + File "xxx", line xxx in + File "xxx", line xxx in + ... + File "xxx", line xxx in + + This function is written for debug purpose only, to dump the traceback in + the worst case: after a segmentation fault, at fatal error, etc. That's why, + it is very limited. Strings are truncated to 100 characters and encoded to + ASCII with backslashreplace. It doesn't write the source code, only the + function name, filename and line number of each frame. Write only the first + 100 frames: if the traceback is truncated, write the line " ...". + + This function is signal safe. */ + +extern void _Py_DumpTraceback( + int fd, + PyThreadState *tstate); + +/* Write the traceback of all threads into the file 'fd'. current_thread can be + NULL. + + Return NULL on success, or an error message on error. + + This function is written for debug purpose only. It calls + _Py_DumpTraceback() for each thread, and so has the same limitations. It + only write the traceback of the first 100 threads: write "..." if there are + more threads. + + If current_tstate is NULL, the function tries to get the Python thread state + of the current thread. It is not an error if the function is unable to get + the current Python thread state. + + If interp is NULL, the function tries to get the interpreter state from + the current Python thread state, or from + _PyGILState_GetInterpreterStateUnsafe() in last resort. + + It is better to pass NULL to interp and current_tstate, the function tries + different options to retrieve this information. + + This function is signal safe. */ + +extern const char* _Py_DumpTracebackThreads( + int fd, + PyInterpreterState *interp, + PyThreadState *current_tstate); + +/* Write a Unicode object into the file descriptor fd. Encode the string to + ASCII using the backslashreplace error handler. + + Do nothing if text is not a Unicode object. + + This function is signal safe. */ +extern void _Py_DumpASCII(int fd, PyObject *text); + +/* Format an integer as decimal into the file descriptor fd. + + This function is signal safe. */ +extern void _Py_DumpDecimal( + int fd, + size_t value); + +/* Format an integer as hexadecimal with width digits into fd file descriptor. + The function is signal safe. */ +extern void _Py_DumpHexadecimal( + int fd, + uintptr_t value, + Py_ssize_t width); + +extern PyObject* _PyTraceBack_FromFrame( + PyObject *tb_next, + PyFrameObject *frame); + +#define EXCEPTION_TB_HEADER "Traceback (most recent call last):\n" +#define EXCEPTION_GROUP_TB_HEADER "Exception Group Traceback (most recent call last):\n" + +/* Write the traceback tb to file f. Prefix each line with + indent spaces followed by the margin (if it is not NULL). */ +extern int _PyTraceBack_Print( + PyObject *tb, const char *header, PyObject *f); +extern int _Py_WriteIndentedMargin(int, const char*, PyObject *); +extern int _Py_WriteIndent(int, PyObject *); + +// Export for the faulthandler module +PyAPI_FUNC(void) _Py_InitDumpStack(void); +PyAPI_FUNC(void) _Py_DumpStack(int fd); + +extern void _Py_DumpTraceback_Init(void); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_TRACEBACK_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_tracemalloc.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_tracemalloc.h new file mode 100644 index 0000000000000000000000000000000000000000..41e1c91bee4fde77d2e11d745af640ce5e3e0ad9 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_tracemalloc.h @@ -0,0 +1,167 @@ +#ifndef Py_INTERNAL_TRACEMALLOC_H +#define Py_INTERNAL_TRACEMALLOC_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_hashtable.h" // _Py_hashtable_t + + +struct _PyTraceMalloc_Config { + /* Module initialized? + Variable protected by the GIL */ + enum { + TRACEMALLOC_NOT_INITIALIZED, + TRACEMALLOC_INITIALIZED, + TRACEMALLOC_FINALIZED + } initialized; + + /* Is tracemalloc tracing memory allocations? + Variable protected by the TABLES_LOCK() and stored atomically. + Atomic store is used so that it can read without locking for the + general case of checking if tracemalloc is enabled. + */ + int tracing; + + /* limit of the number of frames in a traceback, 1 by default. + Variable protected by the GIL. */ + int max_nframe; +}; + + +/* Pack the frame_t structure to reduce the memory footprint on 64-bit + architectures: 12 bytes instead of 16. */ +#if defined(_MSC_VER) +#pragma pack(push, 4) +#endif + +struct +#ifdef __GNUC__ +__attribute__((packed)) +#endif +tracemalloc_frame { + /* filename cannot be NULL: "" is used if the Python frame + filename is NULL */ + PyObject *filename; + unsigned int lineno; +}; +#ifdef _MSC_VER +#pragma pack(pop) +#endif + +struct tracemalloc_traceback { + Py_uhash_t hash; + /* Number of frames stored */ + uint16_t nframe; + /* Total number of frames the traceback had */ + uint16_t total_nframe; + struct tracemalloc_frame frames[1]; +}; + + +struct _tracemalloc_runtime_state { + struct _PyTraceMalloc_Config config; + + /* Protected by the GIL */ + struct { + PyMemAllocatorEx mem; + PyMemAllocatorEx raw; + PyMemAllocatorEx obj; + } allocators; + + PyMutex tables_lock; + /* Size in bytes of currently traced memory. + Protected by TABLES_LOCK(). */ + size_t traced_memory; + /* Peak size in bytes of traced memory. + Protected by TABLES_LOCK(). */ + size_t peak_traced_memory; + /* Hash table used as a set to intern filenames: + PyObject* => PyObject*. + Protected by the TABLES_LOCK(). */ + _Py_hashtable_t *filenames; + /* Buffer to store a new traceback in traceback_new(). + Protected by the TABLES_LOCK(). */ + struct tracemalloc_traceback *traceback; + /* Hash table used as a set to intern tracebacks: + traceback_t* => traceback_t* + Protected by the TABLES_LOCK(). */ + _Py_hashtable_t *tracebacks; + /* pointer (void*) => trace (trace_t*). + Protected by TABLES_LOCK(). */ + _Py_hashtable_t *traces; + /* domain (unsigned int) => traces (_Py_hashtable_t). + Protected by TABLES_LOCK(). */ + _Py_hashtable_t *domains; + + struct tracemalloc_traceback empty_traceback; + + Py_tss_t reentrant_key; +}; + +#define _tracemalloc_runtime_state_INIT \ + { \ + .config = { \ + .initialized = TRACEMALLOC_NOT_INITIALIZED, \ + .tracing = 0, \ + .max_nframe = 1, \ + }, \ + .reentrant_key = Py_tss_NEEDS_INIT, \ + } + + +// Get the traceback where a memory block was allocated. +// +// Return a tuple of (filename: str, lineno: int) tuples. +// +// Return None if the tracemalloc module is disabled or if the memory block +// is not tracked by tracemalloc. +// +// Raise an exception and return NULL on error. +// +// Export for '_testinternalcapi' shared extension. +PyAPI_FUNC(PyObject*) _PyTraceMalloc_GetTraceback( + unsigned int domain, + uintptr_t ptr); + +/* Return non-zero if tracemalloc is tracing */ +extern int _PyTraceMalloc_IsTracing(void); + +/* Clear the tracemalloc traces */ +extern void _PyTraceMalloc_ClearTraces(void); + +/* Clear the tracemalloc traces */ +extern PyObject* _PyTraceMalloc_GetTraces(void); + +/* Clear tracemalloc traceback for an object */ +extern PyObject* _PyTraceMalloc_GetObjectTraceback(PyObject *obj); + +/* Initialize tracemalloc */ +extern PyStatus _PyTraceMalloc_Init(void); + +/* Start tracemalloc */ +extern int _PyTraceMalloc_Start(int max_nframe); + +/* Stop tracemalloc */ +extern void _PyTraceMalloc_Stop(void); + +/* Get the tracemalloc traceback limit */ +extern int _PyTraceMalloc_GetTracebackLimit(void); + +/* Get the memory usage of tracemalloc in bytes */ +extern size_t _PyTraceMalloc_GetMemory(void); + +/* Get the current size and peak size of traced memory blocks as a 2-tuple */ +extern PyObject* _PyTraceMalloc_GetTracedMemory(void); + +/* Set the peak size of traced memory blocks to the current size */ +extern void _PyTraceMalloc_ResetPeak(void); + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_TRACEMALLOC_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_tstate.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_tstate.h new file mode 100644 index 0000000000000000000000000000000000000000..87f59c274ac7470d59221311c19ecddb89780924 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_tstate.h @@ -0,0 +1,93 @@ +#ifndef Py_INTERNAL_TSTATE_H +#define Py_INTERNAL_TSTATE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_brc.h" // struct _brc_thread_state +#include "pycore_freelist_state.h" // struct _Py_freelists +#include "pycore_mimalloc.h" // struct _mimalloc_thread_state +#include "pycore_qsbr.h" // struct qsbr + + +#ifdef Py_GIL_DISABLED +struct _gc_thread_state { + /* Thread-local allocation count. */ + Py_ssize_t alloc_count; +}; +#endif + +// Every PyThreadState is actually allocated as a _PyThreadStateImpl. The +// PyThreadState fields are exposed as part of the C API, although most fields +// are intended to be private. The _PyThreadStateImpl fields not exposed. +typedef struct _PyThreadStateImpl { + // semi-public fields are in PyThreadState. + PyThreadState base; + + // The reference count field is used to synchronize deallocation of the + // thread state during runtime finalization. + Py_ssize_t refcount; + + // These are addresses, but we need to convert to ints to avoid UB. + uintptr_t c_stack_top; + uintptr_t c_stack_soft_limit; + uintptr_t c_stack_hard_limit; + + PyObject *asyncio_running_loop; // Strong reference + PyObject *asyncio_running_task; // Strong reference + + /* Head of circular linked-list of all tasks which are instances of `asyncio.Task` + or subclasses of it used in `asyncio.all_tasks`. + */ + struct llist_node asyncio_tasks_head; + struct _qsbr_thread_state *qsbr; // only used by free-threaded build + struct llist_node mem_free_queue; // delayed free queue + +#ifdef Py_GIL_DISABLED + // Stack references for the current thread that exist on the C stack + struct _PyCStackRef *c_stack_refs; + struct _gc_thread_state gc; + struct _mimalloc_thread_state mimalloc; + struct _Py_freelists freelists; + struct _brc_thread_state brc; + struct { + // The per-thread refcounts + Py_ssize_t *values; + + // Size of the refcounts array. + Py_ssize_t size; + + // If set, don't use per-thread refcounts + int is_finalized; + } refcounts; + + // Index to use to retrieve thread-local bytecode for this thread + int32_t tlbc_index; + + // When >1, code objects do not immortalize their non-string constants. + int suppress_co_const_immortalization; +#endif + +#if defined(Py_REF_DEBUG) && defined(Py_GIL_DISABLED) + Py_ssize_t reftotal; // this thread's total refcount operations +#endif + + // PyUnstable_ThreadState_ResetStackProtection() values + uintptr_t c_stack_init_base; + uintptr_t c_stack_init_top; + +#ifdef Py_GIL_DISABLED + // gh-144438: Add padding to ensure that the fields above don't share a + // cache line with other allocations. + char __padding[64]; +#endif +} _PyThreadStateImpl; + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_TSTATE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_tuple.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_tuple.h new file mode 100644 index 0000000000000000000000000000000000000000..acf1bec46028acd753fd53763b9a9ff9ccb30485 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_tuple.h @@ -0,0 +1,75 @@ +#ifndef Py_INTERNAL_TUPLE_H +#define Py_INTERNAL_TUPLE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_object.h" // _PyObject_GC_IS_TRACKED +#include "pycore_structs.h" // _PyStackRef + +extern void _PyTuple_MaybeUntrack(PyObject *); +extern void _PyTuple_DebugMallocStats(FILE *out); + +/* runtime lifecycle */ + +extern PyStatus _PyTuple_InitGlobalObjects(PyInterpreterState *); + + +/* other API */ + +#define _PyTuple_ITEMS(op) _Py_RVALUE(_PyTuple_CAST(op)->ob_item) + +PyAPI_FUNC(PyObject *)_PyTuple_FromArray(PyObject *const *, Py_ssize_t); +PyAPI_FUNC(PyObject *)_PyTuple_FromStackRefStealOnSuccess(const union _PyStackRef *, Py_ssize_t); +PyAPI_FUNC(PyObject *)_PyTuple_FromArraySteal(PyObject *const *, Py_ssize_t); + +typedef struct { + PyObject_HEAD + Py_ssize_t it_index; + PyTupleObject *it_seq; /* Set to NULL when iterator is exhausted */ +} _PyTupleIterObject; + +#define _PyTuple_RESET_HASH_CACHE(op) \ + do { \ + assert(op != NULL); \ + _PyTuple_CAST(op)->ob_hash = -1; \ + } while (0) + +/* bpo-42536: If reusing a tuple object, this should be called to re-track it + with the garbage collector and reset its hash cache. */ +static inline void +_PyTuple_Recycle(PyObject *op) +{ + _PyTuple_RESET_HASH_CACHE(op); + if (!_PyObject_GC_IS_TRACKED(op)) { + _PyObject_GC_TRACK(op); + } +} + +/* Below are the official constants from the xxHash specification. Optimizing + compilers should emit a single "rotate" instruction for the + _PyTuple_HASH_XXROTATE() expansion. If that doesn't happen for some important + platform, the macro could be changed to expand to a platform-specific rotate + spelling instead. +*/ +#if SIZEOF_PY_UHASH_T > 4 +#define _PyTuple_HASH_XXPRIME_1 ((Py_uhash_t)11400714785074694791ULL) +#define _PyTuple_HASH_XXPRIME_2 ((Py_uhash_t)14029467366897019727ULL) +#define _PyTuple_HASH_XXPRIME_5 ((Py_uhash_t)2870177450012600261ULL) +#define _PyTuple_HASH_XXROTATE(x) ((x << 31) | (x >> 33)) /* Rotate left 31 bits */ +#else +#define _PyTuple_HASH_XXPRIME_1 ((Py_uhash_t)2654435761UL) +#define _PyTuple_HASH_XXPRIME_2 ((Py_uhash_t)2246822519UL) +#define _PyTuple_HASH_XXPRIME_5 ((Py_uhash_t)374761393UL) +#define _PyTuple_HASH_XXROTATE(x) ((x << 13) | (x >> 19)) /* Rotate left 13 bits */ +#endif +#define _PyTuple_HASH_EMPTY (_PyTuple_HASH_XXPRIME_5 + (_PyTuple_HASH_XXPRIME_5 ^ 3527539UL)) + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_TUPLE_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_typedefs.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_typedefs.h new file mode 100644 index 0000000000000000000000000000000000000000..d330cc4dc2b8fa3c7bdd2dcc71985c0a3a89118d --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_typedefs.h @@ -0,0 +1,18 @@ +#ifndef Py_INTERNAL_TYPEDEFS_H +#define Py_INTERNAL_TYPEDEFS_H + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct _PyInterpreterFrame _PyInterpreterFrame; +typedef struct pyruntimestate _PyRuntimeState; + +#ifdef __cplusplus +} +#endif +#endif // !Py_INTERNAL_TYPEDEFS_H diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_typeobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_typeobject.h new file mode 100644 index 0000000000000000000000000000000000000000..ba66364d3e94b11defa5baa652afde5f7cebadc7 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_typeobject.h @@ -0,0 +1,160 @@ +#ifndef Py_INTERNAL_TYPEOBJECT_H +#define Py_INTERNAL_TYPEOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_interp_structs.h" // managed_static_type_state +#include "pycore_moduleobject.h" // PyModuleObject + + +/* state */ + +#define _Py_TYPE_VERSION_INT 1 +#define _Py_TYPE_VERSION_FLOAT 2 +#define _Py_TYPE_VERSION_LIST 3 +#define _Py_TYPE_VERSION_TUPLE 4 +#define _Py_TYPE_VERSION_STR 5 +#define _Py_TYPE_VERSION_SET 6 +#define _Py_TYPE_VERSION_FROZEN_SET 7 +#define _Py_TYPE_VERSION_DICT 8 +#define _Py_TYPE_VERSION_BYTEARRAY 9 +#define _Py_TYPE_VERSION_BYTES 10 +#define _Py_TYPE_VERSION_COMPLEX 11 + +#define _Py_TYPE_VERSION_NEXT 16 + + +#define _Py_TYPE_BASE_VERSION_TAG (2<<16) +#define _Py_MAX_GLOBAL_TYPE_VERSION_TAG (_Py_TYPE_BASE_VERSION_TAG - 1) + + +/* runtime lifecycle */ + +extern PyStatus _PyTypes_InitTypes(PyInterpreterState *); +extern void _PyTypes_FiniTypes(PyInterpreterState *); +extern void _PyTypes_FiniExtTypes(PyInterpreterState *interp); +extern void _PyTypes_Fini(PyInterpreterState *); +extern void _PyTypes_AfterFork(void); + +static inline PyObject ** +_PyStaticType_GET_WEAKREFS_LISTPTR(managed_static_type_state *state) +{ + assert(state != NULL); + return &state->tp_weaklist; +} + +extern int _PyStaticType_InitBuiltin( + PyInterpreterState *interp, + PyTypeObject *type); +extern void _PyStaticType_FiniBuiltin( + PyInterpreterState *interp, + PyTypeObject *type); +extern void _PyStaticType_ClearWeakRefs( + PyInterpreterState *interp, + PyTypeObject *type); +extern managed_static_type_state * _PyStaticType_GetState( + PyInterpreterState *interp, + PyTypeObject *type); + +// Export for '_datetime' shared extension. +PyAPI_FUNC(int) _PyStaticType_InitForExtension( + PyInterpreterState *interp, + PyTypeObject *self); + +// Export for _testinternalcapi extension. +PyAPI_FUNC(PyObject *) _PyStaticType_GetBuiltins(void); + + +/* Like PyType_GetModuleState, but skips verification + * that type is a heap type with an associated module */ +static inline void * +_PyType_GetModuleState(PyTypeObject *type) +{ + assert(PyType_Check(type)); + assert(type->tp_flags & Py_TPFLAGS_HEAPTYPE); + PyHeapTypeObject *et = (PyHeapTypeObject *)type; + assert(et->ht_module); + PyModuleObject *mod = (PyModuleObject *)(et->ht_module); + assert(mod != NULL); + return mod->md_state; +} + + +// Export for 'math' shared extension, used via _PyType_IsReady() static inline +// function +PyAPI_FUNC(PyObject *) _PyType_GetDict(PyTypeObject *); + +extern PyObject * _PyType_GetBases(PyTypeObject *type); +extern PyObject * _PyType_GetMRO(PyTypeObject *type); +extern PyObject* _PyType_GetSubclasses(PyTypeObject *); +extern int _PyType_HasSubclasses(PyTypeObject *); + +// Export for _testinternalcapi extension. +PyAPI_FUNC(PyObject *) _PyType_GetSlotWrapperNames(void); + +// PyType_Ready() must be called if _PyType_IsReady() is false. +// See also the Py_TPFLAGS_READY flag. +static inline int +_PyType_IsReady(PyTypeObject *type) +{ + return _PyType_GetDict(type) != NULL; +} + +extern PyObject* _Py_type_getattro_impl(PyTypeObject *type, PyObject *name, + int *suppress_missing_attribute); +extern PyObject* _Py_type_getattro(PyObject *type, PyObject *name); + +extern PyObject* _Py_BaseObject_RichCompare(PyObject* self, PyObject* other, int op); + +extern PyObject* _Py_slot_tp_getattro(PyObject *self, PyObject *name); +extern PyObject* _Py_slot_tp_getattr_hook(PyObject *self, PyObject *name); + +extern PyTypeObject _PyBufferWrapper_Type; + +PyAPI_FUNC(PyObject*) _PySuper_Lookup(PyTypeObject *su_type, PyObject *su_obj, + PyObject *name, int *meth_found); + +extern PyObject* _PyType_GetFullyQualifiedName(PyTypeObject *type, char sep); + +// Perform the following operation, in a thread-safe way when required by the +// build mode. +// +// self->tp_flags = (self->tp_flags & ~mask) | flags; +extern void _PyType_SetFlags(PyTypeObject *self, unsigned long mask, + unsigned long flags); +extern int _PyType_AddMethod(PyTypeObject *, PyMethodDef *); + +// Like _PyType_SetFlags(), but apply the operation to self and any of its +// subclasses without Py_TPFLAGS_IMMUTABLETYPE set. +extern void _PyType_SetFlagsRecursive(PyTypeObject *self, unsigned long mask, + unsigned long flags); + +extern unsigned int _PyType_GetVersionForCurrentState(PyTypeObject *tp); +PyAPI_FUNC(void) _PyType_SetVersion(PyTypeObject *tp, unsigned int version); +PyTypeObject *_PyType_LookupByVersion(unsigned int version); + +// Function pointer type for user-defined validation function that will be +// called by _PyType_Validate(). +// It should return 0 if the validation is passed, otherwise it will return -1. +typedef int (*_py_validate_type)(PyTypeObject *); + +// It will verify the ``ty`` through user-defined validation function ``validate``, +// and if the validation is passed, it will set the ``tp_version`` as valid +// tp_version_tag from the ``ty``. +extern int _PyType_Validate(PyTypeObject *ty, _py_validate_type validate, unsigned int *tp_version); +extern int _PyType_CacheGetItemForSpecialization(PyHeapTypeObject *ht, PyObject *descriptor, uint32_t tp_version); + +// Like PyType_GetBaseByToken, but does not modify refcounts. +// Cannot fail; arguments must be valid. +PyAPI_FUNC(int) +_PyType_GetBaseByToken_Borrow(PyTypeObject *type, void *token, PyTypeObject **result); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_TYPEOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_typevarobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_typevarobject.h new file mode 100644 index 0000000000000000000000000000000000000000..4d7556e68cdaeedafd18e0a64ae0ba3e03efb37d --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_typevarobject.h @@ -0,0 +1,28 @@ +#ifndef Py_INTERNAL_TYPEVAROBJECT_H +#define Py_INTERNAL_TYPEVAROBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +extern PyObject *_Py_make_typevar(PyObject *, PyObject *, PyObject *); +extern PyObject *_Py_make_paramspec(PyThreadState *, PyObject *); +extern PyObject *_Py_make_typevartuple(PyThreadState *, PyObject *); +extern PyObject *_Py_make_typealias(PyThreadState *, PyObject *); +extern PyObject *_Py_subscript_generic(PyThreadState *, PyObject *); +extern PyObject *_Py_set_typeparam_default(PyThreadState *, PyObject *, PyObject *); +extern int _Py_initialize_generic(PyInterpreterState *); +extern void _Py_clear_generic_types(PyInterpreterState *); +extern int _Py_typing_type_repr(PyUnicodeWriter *, PyObject *); + +extern PyTypeObject _PyTypeAlias_Type; +extern PyTypeObject _PyNoDefault_Type; +extern PyObject _Py_NoDefaultStruct; + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_TYPEVAROBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_ucnhash.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_ucnhash.h new file mode 100644 index 0000000000000000000000000000000000000000..1561dfbb3150d3fe3d61898c51701ef2831e8e2f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_ucnhash.h @@ -0,0 +1,36 @@ +/* Unicode name database interface */ +#ifndef Py_INTERNAL_UCNHASH_H +#define Py_INTERNAL_UCNHASH_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* revised ucnhash CAPI interface (exported through a "wrapper") */ + +#define PyUnicodeData_CAPSULE_NAME "unicodedata._ucnhash_CAPI" + +typedef struct { + + /* Get name for a given character code. + Returns non-zero if success, zero if not. + Does not set Python exceptions. */ + int (*getname)(Py_UCS4 code, char* buffer, int buflen, + int with_alias_and_seq); + + /* Get character code for a given name. + Same error handling as for getname(). */ + int (*getcode)(const char* name, int namelen, Py_UCS4* code, + int with_named_seq); + +} _PyUnicode_Name_CAPI; + +extern _PyUnicode_Name_CAPI* _PyUnicode_GetNameCAPI(void); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_UCNHASH_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_unicodeobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_unicodeobject.h new file mode 100644 index 0000000000000000000000000000000000000000..3791b913c175467623a1946d9f9a0b3c1db4263d --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_unicodeobject.h @@ -0,0 +1,308 @@ +#ifndef Py_INTERNAL_UNICODEOBJECT_H +#define Py_INTERNAL_UNICODEOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_fileutils.h" // _Py_error_handler +#include "pycore_ucnhash.h" // _PyUnicode_Name_CAPI + +/* --- Characters Type APIs ----------------------------------------------- */ + +extern int _PyUnicode_IsXidStart(Py_UCS4 ch); +extern int _PyUnicode_IsXidContinue(Py_UCS4 ch); +extern int _PyUnicode_ToLowerFull(Py_UCS4 ch, Py_UCS4 *res); +extern int _PyUnicode_ToTitleFull(Py_UCS4 ch, Py_UCS4 *res); +extern int _PyUnicode_ToUpperFull(Py_UCS4 ch, Py_UCS4 *res); +extern int _PyUnicode_ToFoldedFull(Py_UCS4 ch, Py_UCS4 *res); +extern int _PyUnicode_IsCaseIgnorable(Py_UCS4 ch); +extern int _PyUnicode_IsCased(Py_UCS4 ch); + +/* --- Unicode API -------------------------------------------------------- */ + +// Export for '_json' shared extension +PyAPI_FUNC(int) _PyUnicode_CheckConsistency( + PyObject *op, + int check_content); + +PyAPI_FUNC(void) _PyUnicode_ExactDealloc(PyObject *op); +extern Py_ssize_t _PyUnicode_InternedSize(void); +extern Py_ssize_t _PyUnicode_InternedSize_Immortal(void); + +// Get a copy of a Unicode string. +// Export for '_datetime' shared extension. +PyAPI_FUNC(PyObject*) _PyUnicode_Copy( + PyObject *unicode); + +/* Unsafe version of PyUnicode_Fill(): don't check arguments and so may crash + if parameters are invalid (e.g. if length is longer than the string). */ +extern void _PyUnicode_FastFill( + PyObject *unicode, + Py_ssize_t start, + Py_ssize_t length, + Py_UCS4 fill_char + ); + +/* Unsafe version of PyUnicode_CopyCharacters(): don't check arguments and so + may crash if parameters are invalid (e.g. if the output string + is too short). */ +extern void _PyUnicode_FastCopyCharacters( + PyObject *to, + Py_ssize_t to_start, + PyObject *from, + Py_ssize_t from_start, + Py_ssize_t how_many + ); + +/* Create a new string from a buffer of ASCII characters. + WARNING: Don't check if the string contains any non-ASCII character. */ +extern PyObject* _PyUnicode_FromASCII( + const char *buffer, + Py_ssize_t size); + +/* Compute the maximum character of the substring unicode[start:end]. + Return 127 for an empty string. */ +extern Py_UCS4 _PyUnicode_FindMaxChar ( + PyObject *unicode, + Py_ssize_t start, + Py_ssize_t end); + +/* --- _PyUnicodeWriter API ----------------------------------------------- */ + +/* Format the object based on the format_spec, as defined in PEP 3101 + (Advanced String Formatting). */ +extern int _PyUnicode_FormatAdvancedWriter( + _PyUnicodeWriter *writer, + PyObject *obj, + PyObject *format_spec, + Py_ssize_t start, + Py_ssize_t end); + +/* --- UTF-7 Codecs ------------------------------------------------------- */ + +extern PyObject* _PyUnicode_EncodeUTF7( + PyObject *unicode, /* Unicode object */ + int base64SetO, /* Encode RFC2152 Set O characters in base64 */ + int base64WhiteSpace, /* Encode whitespace (sp, ht, nl, cr) in base64 */ + const char *errors); /* error handling */ + +/* --- UTF-8 Codecs ------------------------------------------------------- */ + +// Export for '_tkinter' shared extension. +PyAPI_FUNC(PyObject*) _PyUnicode_AsUTF8String( + PyObject *unicode, + const char *errors); + +/* --- UTF-32 Codecs ------------------------------------------------------ */ + +// Export for '_tkinter' shared extension +PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF32( + PyObject *object, /* Unicode object */ + const char *errors, /* error handling */ + int byteorder); /* byteorder to use 0=BOM+native;-1=LE,1=BE */ + +/* --- UTF-16 Codecs ------------------------------------------------------ */ + +// Returns a Python string object holding the UTF-16 encoded value of +// the Unicode data. +// +// If byteorder is not 0, output is written according to the following +// byte order: +// +// byteorder == -1: little endian +// byteorder == 0: native byte order (writes a BOM mark) +// byteorder == 1: big endian +// +// If byteorder is 0, the output string will always start with the +// Unicode BOM mark (U+FEFF). In the other two modes, no BOM mark is +// prepended. +// +// Export for '_tkinter' shared extension +PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF16( + PyObject* unicode, /* Unicode object */ + const char *errors, /* error handling */ + int byteorder); /* byteorder to use 0=BOM+native;-1=LE,1=BE */ + +/* --- Unicode-Escape Codecs ---------------------------------------------- */ + +/* Variant of PyUnicode_DecodeUnicodeEscape that supports partial decoding. */ +extern PyObject* _PyUnicode_DecodeUnicodeEscapeStateful( + const char *string, /* Unicode-Escape encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors, /* error handling */ + Py_ssize_t *consumed); /* bytes consumed */ + +// Helper for PyUnicode_DecodeUnicodeEscape that detects invalid escape +// chars. +// Export for test_peg_generator. +PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscapeInternal2( + const char *string, /* Unicode-Escape encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors, /* error handling */ + Py_ssize_t *consumed, /* bytes consumed */ + int *first_invalid_escape_char, /* on return, if not -1, contain the first + invalid escaped char (<= 0xff) or invalid + octal escape (> 0xff) in string. */ + const char **first_invalid_escape_ptr); /* on return, if not NULL, may + point to the first invalid escaped + char in string. + May be NULL if errors is not NULL. */ + +/* --- Raw-Unicode-Escape Codecs ---------------------------------------------- */ + +/* Variant of PyUnicode_DecodeRawUnicodeEscape that supports partial decoding. */ +extern PyObject* _PyUnicode_DecodeRawUnicodeEscapeStateful( + const char *string, /* Unicode-Escape encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors, /* error handling */ + Py_ssize_t *consumed); /* bytes consumed */ + +/* --- Latin-1 Codecs ----------------------------------------------------- */ + +extern PyObject* _PyUnicode_AsLatin1String( + PyObject* unicode, + const char* errors); + +/* --- ASCII Codecs ------------------------------------------------------- */ + +extern PyObject* _PyUnicode_AsASCIIString( + PyObject* unicode, + const char* errors); + +/* --- Character Map Codecs ----------------------------------------------- */ + +/* Translate an Unicode object by applying a character mapping table to + it and return the resulting Unicode object. + + The mapping table must map Unicode ordinal integers to Unicode strings, + Unicode ordinal integers or None (causing deletion of the character). + + Mapping tables may be dictionaries or sequences. Unmapped character + ordinals (ones which cause a LookupError) are left untouched and + are copied as-is. +*/ +extern PyObject* _PyUnicode_EncodeCharmap( + PyObject *unicode, /* Unicode object */ + PyObject *mapping, /* encoding mapping */ + const char *errors); /* error handling */ + +/* --- Decimal Encoder ---------------------------------------------------- */ + +// Converts a Unicode object holding a decimal value to an ASCII string +// for using in int, float and complex parsers. +// Transforms code points that have decimal digit property to the +// corresponding ASCII digit code points. Transforms spaces to ASCII. +// Transforms code points starting from the first non-ASCII code point that +// is neither a decimal digit nor a space to the end into '?'. +// +// Export for '_testinternalcapi' shared extension. +PyAPI_FUNC(PyObject*) _PyUnicode_TransformDecimalAndSpaceToASCII( + PyObject *unicode); /* Unicode object */ + +/* --- Methods & Slots ---------------------------------------------------- */ + +PyAPI_FUNC(PyObject*) _PyUnicode_JoinArray( + PyObject *separator, + PyObject *const *items, + Py_ssize_t seqlen + ); + +/* Test whether a unicode is equal to ASCII identifier. Return 1 if true, + 0 otherwise. The right argument must be ASCII identifier. + Any error occurs inside will be cleared before return. */ +extern int _PyUnicode_EqualToASCIIId( + PyObject *left, /* Left string */ + _Py_Identifier *right /* Right identifier */ + ); + +// Test whether a unicode is equal to ASCII string. Return 1 if true, +// 0 otherwise. The right argument must be ASCII-encoded string. +// Any error occurs inside will be cleared before return. +// Export for '_ctypes' shared extension +PyAPI_FUNC(int) _PyUnicode_EqualToASCIIString( + PyObject *left, + const char *right /* ASCII-encoded string */ + ); + +/* Externally visible for str.strip(unicode) */ +extern PyObject* _PyUnicode_XStrip( + PyObject *self, + int striptype, + PyObject *sepobj + ); + + +/* Using explicit passed-in values, insert the thousands grouping + into the string pointed to by buffer. For the argument descriptions, + see Objects/stringlib/localeutil.h */ +extern Py_ssize_t _PyUnicode_InsertThousandsGrouping( + _PyUnicodeWriter *writer, + Py_ssize_t n_buffer, + PyObject *digits, + Py_ssize_t d_pos, + Py_ssize_t n_digits, + Py_ssize_t min_width, + const char *grouping, + PyObject *thousands_sep, + Py_UCS4 *maxchar, + int forward); + +/* Dedent a string. + Behaviour is expected to be an exact match of `textwrap.dedent`. + Return a new reference on success, NULL with exception set on error. + */ +extern PyObject* _PyUnicode_Dedent(PyObject *unicode); + +/* --- Misc functions ----------------------------------------------------- */ + +extern PyObject* _PyUnicode_FormatLong(PyObject *, int, int, int); + +// Fast equality check when the inputs are known to be exact unicode types. +// Export for '_pickle' shared extension. +PyAPI_FUNC(int) _PyUnicode_Equal(PyObject *, PyObject *); + +extern int _PyUnicode_WideCharString_Converter(PyObject *, void *); +extern int _PyUnicode_WideCharString_Opt_Converter(PyObject *, void *); + +// Export for test_peg_generator +PyAPI_FUNC(Py_ssize_t) _PyUnicode_ScanIdentifier(PyObject *); + +/* --- Runtime lifecycle -------------------------------------------------- */ + +extern void _PyUnicode_InitState(PyInterpreterState *); +extern PyStatus _PyUnicode_InitGlobalObjects(PyInterpreterState *); +extern PyStatus _PyUnicode_InitTypes(PyInterpreterState *); +extern void _PyUnicode_Fini(PyInterpreterState *); +extern void _PyUnicode_FiniTypes(PyInterpreterState *); + +extern PyTypeObject _PyUnicodeASCIIIter_Type; + +/* --- Interning ---------------------------------------------------------- */ + +// All these are "ref-neutral", like the public PyUnicode_InternInPlace. + +// Explicit interning routines: +PyAPI_FUNC(void) _PyUnicode_InternMortal(PyInterpreterState *interp, PyObject **); +PyAPI_FUNC(void) _PyUnicode_InternImmortal(PyInterpreterState *interp, PyObject **); +// Left here to help backporting: +PyAPI_FUNC(void) _PyUnicode_InternInPlace(PyInterpreterState *interp, PyObject **p); +// Only for singletons in the _PyRuntime struct: +extern void _PyUnicode_InternStatic(PyInterpreterState *interp, PyObject **); + +/* --- Other API ---------------------------------------------------------- */ + +extern void _PyUnicode_ClearInterned(PyInterpreterState *interp); + +// Like PyUnicode_AsUTF8(), but check for embedded null characters. +// Export for '_sqlite3' shared extension. +PyAPI_FUNC(const char *) _PyUnicode_AsUTF8NoNUL(PyObject *); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_UNICODEOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_unicodeobject_generated.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_unicodeobject_generated.h new file mode 100644 index 0000000000000000000000000000000000000000..c3ecdf64c6ee0063276314c7c81183f14c3398a6 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_unicodeobject_generated.h @@ -0,0 +1,3132 @@ +#ifndef Py_INTERNAL_UNICODEOBJECT_GENERATED_H +#define Py_INTERNAL_UNICODEOBJECT_GENERATED_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* The following is auto-generated by Tools/build/generate_global_objects.py. */ +static inline void +_PyUnicode_InitStaticStrings(PyInterpreterState *interp) { + PyObject *string; + string = &_Py_ID(CANCELLED); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(FINISHED); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(False); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(JSONDecodeError); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(PENDING); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(Py_Repr); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(TextIOWrapper); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(True); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(WarningMessage); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_WindowsConsoleIO); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__IOBase_closed); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__abc_tpflags__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__abs__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__abstractmethods__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__add__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__aenter__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__aexit__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__aiter__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__all__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__and__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__anext__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__annotate__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__annotate_func__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__annotations__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__annotations_cache__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__args__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__await__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__bases__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__bool__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__buffer__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__build_class__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__builtins__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__bytes__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__call__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__cantrace__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__ceil__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__class__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__class_getitem__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__classcell__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__classdict__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__classdictcell__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__complex__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__conditional_annotations__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__contains__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__ctypes_from_outparam__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__del__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__delattr__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__delete__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__delitem__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__dict__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__dictoffset__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__dir__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__divmod__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__doc__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__enter__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__eq__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__exit__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__file__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__firstlineno__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__float__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__floor__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__floordiv__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__format__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__fspath__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__ge__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__get__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__getattr__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__getattribute__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__getinitargs__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__getitem__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__getnewargs__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__getnewargs_ex__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__getstate__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__gt__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__hash__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__iadd__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__iand__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__ifloordiv__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__ilshift__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__imatmul__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__imod__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__import__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__imul__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__index__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__init__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__init_subclass__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__instancecheck__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__int__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__invert__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__ior__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__ipow__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__irshift__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__isabstractmethod__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__isub__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__iter__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__itruediv__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__ixor__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__le__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__len__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__length_hint__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__lltrace__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__loader__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__lshift__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__lt__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__main__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__match_args__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__matmul__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__missing__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__mod__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__module__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__mro_entries__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__mul__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__name__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__ne__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__neg__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__new__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__newobj__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__newobj_ex__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__next__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__notes__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__or__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__orig_class__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__origin__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__package__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__parameters__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__path__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__pos__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__pow__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__prepare__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__qualname__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__radd__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__rand__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__rdivmod__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__reduce__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__reduce_ex__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__release_buffer__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__repr__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__reversed__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__rfloordiv__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__rlshift__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__rmatmul__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__rmod__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__rmul__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__ror__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__round__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__rpow__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__rrshift__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__rshift__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__rsub__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__rtruediv__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__rxor__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__set__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__set_name__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__setattr__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__setitem__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__setstate__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__sizeof__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__slotnames__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__slots__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__spec__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__static_attributes__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__str__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__sub__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__subclasscheck__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__subclasshook__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__truediv__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__trunc__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__type_params__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__typing_is_unpacked_typevartuple__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__typing_prepare_subst__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__typing_subst__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__typing_unpacked_tuple_args__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__warningregistry__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__weaklistoffset__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__weakref__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(__xor__); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_abc_impl); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_abstract_); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_active); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_anonymous_); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_argtypes_); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_as_parameter_); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_asyncio_future_blocking); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_blksize); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_bootstrap); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_check_retval_); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_dealloc_warn); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_feature_version); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_field_types); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_fields_); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_filters); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_finalizing); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_find_and_load); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_fix_up_module); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_flags_); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_get_sourcefile); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_handle_fromlist); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_initializing); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_internal_use); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_io); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_is_text_encoding); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_isatty_open_only); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_length_); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_limbo); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_lock_unlock_module); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_loop); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_needs_com_addref_); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_only_immortal); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_restype_); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_showwarnmsg); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_shutdown); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_slotnames); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_strptime); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_strptime_datetime_date); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_strptime_datetime_datetime); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_strptime_datetime_time); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_type_); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_uninitialized_submodules); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_warn_unawaited_coroutine); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(_xoptions); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(abs_tol); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(access); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(aclose); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(add); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(add_done_callback); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(after_in_child); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(after_in_parent); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(aggregate_class); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(alias); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(align); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(all); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(all_threads); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(allow_code); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(any); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(append); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(arg); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(argdefs); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(args); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(arguments); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(argv); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(as_integer_ratio); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(asend); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(ast); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(athrow); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(attribute); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(authorizer_callback); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(autocommit); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(backtick); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(base); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(before); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(big); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(binary_form); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(bit_offset); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(bit_size); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(block); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(bound); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(buffer); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(buffer_callback); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(buffer_size); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(buffering); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(buffers); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(bufsize); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(builtins); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(byte_offset); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(byte_size); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(byteorder); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(bytes); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(bytes_per_sep); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(c_call); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(c_exception); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(c_parameter_type); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(c_return); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(cached_datetime_module); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(cached_statements); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(cadata); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(cafile); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(call); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(call_exception_handler); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(call_soon); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(callback); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(cancel); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(capath); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(category); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(cb_type); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(certfile); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(check_same_thread); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(clear); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(close); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(closed); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(closefd); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(closure); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(co_argcount); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(co_cellvars); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(co_code); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(co_consts); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(co_exceptiontable); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(co_filename); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(co_firstlineno); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(co_flags); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(co_freevars); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(co_kwonlyargcount); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(co_linetable); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(co_name); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(co_names); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(co_nlocals); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(co_posonlyargcount); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(co_qualname); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(co_stacksize); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(co_varnames); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(code); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(col_offset); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(command); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(comment_factory); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(compile_mode); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(consts); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(context); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(contravariant); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(conversion); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(cookie); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(copy); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(copyreg); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(coro); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(count); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(covariant); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(cwd); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(d_parameter_type); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(data); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(database); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(day); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(debug); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(decode); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(decoder); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(default); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(defaultaction); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(delete); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(depth); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(desired_access); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(detect_types); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(deterministic); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(device); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(dict); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(dictcomp); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(difference_update); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(digest); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(digest_size); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(digestmod); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(dir_fd); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(discard); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(dispatch_table); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(displayhook); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(dklen); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(doc); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(done); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(dont_inherit); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(dst); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(dst_dir_fd); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(eager_start); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(effective_ids); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(element_factory); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(encode); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(encoding); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(end); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(end_col_offset); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(end_lineno); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(end_offset); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(endpos); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(entrypoint); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(env); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(errors); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(event); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(eventmask); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(exc_type); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(exc_value); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(excepthook); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(exception); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(existing_file_name); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(exp); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(expression); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(extend); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(extra_tokens); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(facility); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(factory); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(false); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(family); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(fanout); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(fd); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(fd2); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(fdel); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(fget); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(fields); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(file); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(file_actions); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(filename); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(fileno); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(filepath); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(fillvalue); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(filter); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(filters); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(final); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(find_class); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(fix_imports); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(flags); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(flush); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(fold); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(follow_symlinks); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(format); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(format_spec); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(frame_buffer); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(from_param); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(fromlist); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(fromtimestamp); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(fromutc); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(fset); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(func); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(future); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(generation); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(genexpr); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(get); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(get_debug); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(get_event_loop); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(get_loop); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(get_source); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(getattr); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(getstate); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(gid); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(globals); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(groupindex); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(groups); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(handle); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(handle_seq); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(has_location); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(hash_name); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(header); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(headers); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(hi); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(hook); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(hour); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(id); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(ident); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(identity_hint); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(ignore); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(imag); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(importlib); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(in_fd); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(incoming); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(index); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(indexgroup); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(inf); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(infer_variance); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(inherit_handle); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(inheritable); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(initial); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(initial_bytes); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(initial_owner); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(initial_state); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(initial_value); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(initval); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(inner_size); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(input); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(insert_comments); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(insert_pis); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(instructions); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(intern); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(intersection); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(interval); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(io); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(is_compress); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(is_raw); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(is_running); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(is_struct); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(isatty); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(isinstance); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(isoformat); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(isolation_level); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(istext); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(item); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(items); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(iter); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(iterable); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(iterations); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(join); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(jump); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(keepends); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(key); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(keyfile); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(keys); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(kind); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(kw); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(kw1); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(kw2); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(kwdefaults); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(label); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(lambda); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(last); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(last_exc); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(last_node); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(last_traceback); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(last_type); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(last_value); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(latin1); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(leaf_size); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(len); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(length); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(level); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(limit); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(line); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(line_buffering); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(lineno); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(listcomp); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(little); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(lo); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(locale); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(locals); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(logoption); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(loop); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(manual_reset); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(mapping); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(match); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(max_length); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(maxdigits); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(maxevents); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(maxlen); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(maxmem); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(maxsplit); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(maxvalue); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(memLevel); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(memlimit); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(message); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(metaclass); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(metadata); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(method); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(microsecond); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(milliseconds); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(minute); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(mod); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(mode); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(module); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(module_globals); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(modules); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(month); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(mro); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(msg); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(mutex); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(mycmp); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(n_arg); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(n_fields); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(n_sequence_fields); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(n_unnamed_fields); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(name); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(name_from); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(namespace_separator); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(namespaces); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(narg); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(ndigits); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(nested); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(new_file_name); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(new_limit); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(newline); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(newlines); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(next); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(nlocals); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(node_depth); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(node_offset); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(ns); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(nstype); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(nt); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(null); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(number); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(obj); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(object); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(offset); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(offset_dst); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(offset_src); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(on_type_read); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(onceregistry); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(only_active_thread); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(only_keys); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(oparg); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(opcode); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(open); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(opener); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(operation); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(optimize); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(options); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(order); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(origin); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(out_fd); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(outgoing); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(outpath); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(overlapped); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(owner); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(pages); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(parameter); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(parent); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(password); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(path); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(pattern); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(peek); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(persistent_id); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(persistent_load); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(person); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(pi_factory); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(pid); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(policy); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(pos); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(pos1); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(pos2); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(posix); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(print_file_and_line); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(priority); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(progress); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(progress_handler); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(progress_routine); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(proto); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(protocol); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(ps1); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(ps2); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(query); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(quotetabs); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(raw); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(read); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(read1); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(readable); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(readall); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(readinto); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(readinto1); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(readline); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(readonly); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(real); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(reducer_override); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(registry); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(rel_tol); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(release); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(reload); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(repl); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(replace); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(reserved); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(reset); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(resetids); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(return); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(reverse); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(reversed); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(salt); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(sched_priority); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(scheduler); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(script); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(second); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(security_attributes); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(seek); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(seekable); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(selectors); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(self); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(send); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(sep); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(sequence); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(server_hostname); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(server_side); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(session); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(setcomp); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(setpgroup); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(setsid); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(setsigdef); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(setsigmask); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(setstate); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(shape); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(show_cmd); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(signed); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(size); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(sizehint); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(skip_file_prefixes); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(sleep); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(sock); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(sort); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(source); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(source_traceback); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(spam); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(src); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(src_dir_fd); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(stacklevel); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(start); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(statement); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(status); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(stderr); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(stdin); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(stdout); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(step); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(steps); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(store_name); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(strategy); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(strftime); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(strict); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(strict_mode); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(string); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(sub_key); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(subcalls); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(symmetric_difference_update); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(tabsize); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(tag); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(target); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(target_is_directory); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(task); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(tb_frame); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(tb_lasti); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(tb_lineno); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(tb_next); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(tell); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(template); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(term); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(text); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(threading); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(throw); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(timeout); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(timer); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(times); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(timetuple); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(timeunit); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(top); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(trace_callback); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(traceback); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(trailers); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(translate); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(true); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(truncate); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(twice); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(txt); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(type); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(type_params); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(tz); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(tzinfo); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(tzname); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(uid); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(unlink); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(unraisablehook); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(uri); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(usedforsecurity); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(value); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(values); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(version); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(volume); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(wait_all); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(warn_on_full_buffer); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(warnings); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(warnoptions); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(wbits); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(week); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(weekday); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(which); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(who); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(withdata); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(writable); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(write); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(write_through); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(year); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(zdict); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(zstd_dict); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(empty); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(dbl_percent); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(dot_locals); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(defaults); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(format); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(generic_base); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(kwdefaults); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(type_params); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(str_replace_inf); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(anon_null); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(anon_dictcomp); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(anon_genexpr); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(anon_lambda); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(anon_listcomp); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(anon_module); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(anon_setcomp); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(anon_string); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(anon_unknown); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(json_decoder); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(list_err); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(utf_8); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(dbl_open_br); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(dbl_close_br); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); +} +/* End auto-generated code */ +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_UNICODEOBJECT_GENERATED_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_unionobject.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_unionobject.h new file mode 100644 index 0000000000000000000000000000000000000000..4bd36f6504d42cfae93ac490a4b90efeb704ff80 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_unionobject.h @@ -0,0 +1,26 @@ +#ifndef Py_INTERNAL_UNIONOBJECT_H +#define Py_INTERNAL_UNIONOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +// For extensions created by test_peg_generator +PyAPI_DATA(PyTypeObject) _PyUnion_Type; +PyAPI_FUNC(PyObject *) _Py_union_type_or(PyObject *, PyObject *); + +#define _PyUnion_Check(op) Py_IS_TYPE((op), &_PyUnion_Type) + +#define _PyGenericAlias_Check(op) PyObject_TypeCheck((op), &Py_GenericAliasType) +extern PyObject *_Py_subs_parameters(PyObject *, PyObject *, PyObject *, PyObject *); +extern PyObject *_Py_make_parameters(PyObject *); +extern PyObject *_Py_union_args(PyObject *self); +extern PyObject *_Py_union_from_tuple(PyObject *args); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_UNIONOBJECT_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_uniqueid.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_uniqueid.h new file mode 100644 index 0000000000000000000000000000000000000000..c80924d50e677ad02c5050bbf610926d9da8eef3 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_uniqueid.h @@ -0,0 +1,57 @@ +#ifndef Py_INTERNAL_UNIQUEID_H +#define Py_INTERNAL_UNIQUEID_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#ifdef Py_GIL_DISABLED + +// This contains code for allocating unique ids to objects for per-thread +// reference counting. +// +// Per-thread reference counting is used along with deferred reference +// counting to avoid scaling bottlenecks due to reference count contention. +// +// An id of 0 is used to indicate that an object doesn't use per-thread +// refcounting. This value is used when the object is finalized by the GC +// and during interpreter shutdown to allow the object to be +// deallocated promptly when the object's refcount reaches zero. +// +// Each entry implicitly represents a unique id based on its offset in the +// table. Non-allocated entries form a free-list via the 'next' pointer. +// Allocated entries store the corresponding PyObject. + +#define _Py_INVALID_UNIQUE_ID 0 + +// Assigns the next id from the pool of ids. +extern Py_ssize_t _PyObject_AssignUniqueId(PyObject *obj); + +// Releases the allocated id back to the pool. +extern void _PyObject_ReleaseUniqueId(Py_ssize_t unique_id); + +// Releases the allocated id back to the pool. +extern void _PyObject_DisablePerThreadRefcounting(PyObject *obj); + +// Merges the per-thread reference counts into the corresponding objects. +extern void _PyObject_MergePerThreadRefcounts(_PyThreadStateImpl *tstate); + +// Like _PyObject_MergePerThreadRefcounts, but also frees the per-thread +// array of refcounts. +extern void _PyObject_FinalizePerThreadRefcounts(_PyThreadStateImpl *tstate); + +// Frees the interpreter's pool of type ids. +extern void _PyObject_FinalizeUniqueIdPool(PyInterpreterState *interp); + +// Increfs the object, resizing the thread-local refcount array if necessary. +PyAPI_FUNC(void) _PyObject_ThreadIncrefSlow(PyObject *obj, size_t idx); + +#endif /* Py_GIL_DISABLED */ + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_UNIQUEID_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_uop_ids.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_uop_ids.h new file mode 100644 index 0000000000000000000000000000000000000000..d3d2b716e2c9977feccf674c83114a35851d0761 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_uop_ids.h @@ -0,0 +1,335 @@ +// This file is generated by Tools/cases_generator/uop_id_generator.py +// from: +// Python/bytecodes.c +// Do not edit! + +#ifndef Py_CORE_UOP_IDS_H +#define Py_CORE_UOP_IDS_H +#ifdef __cplusplus +extern "C" { +#endif + +#define _EXIT_TRACE 300 +#define _SET_IP 301 +#define _BINARY_OP 302 +#define _BINARY_OP_ADD_FLOAT 303 +#define _BINARY_OP_ADD_INT 304 +#define _BINARY_OP_ADD_UNICODE 305 +#define _BINARY_OP_EXTEND 306 +#define _BINARY_OP_INPLACE_ADD_UNICODE 307 +#define _BINARY_OP_MULTIPLY_FLOAT 308 +#define _BINARY_OP_MULTIPLY_INT 309 +#define _BINARY_OP_SUBSCR_CHECK_FUNC 310 +#define _BINARY_OP_SUBSCR_DICT 311 +#define _BINARY_OP_SUBSCR_INIT_CALL 312 +#define _BINARY_OP_SUBSCR_LIST_INT 313 +#define _BINARY_OP_SUBSCR_LIST_SLICE 314 +#define _BINARY_OP_SUBSCR_STR_INT 315 +#define _BINARY_OP_SUBSCR_TUPLE_INT 316 +#define _BINARY_OP_SUBTRACT_FLOAT 317 +#define _BINARY_OP_SUBTRACT_INT 318 +#define _BINARY_SLICE 319 +#define _BUILD_INTERPOLATION BUILD_INTERPOLATION +#define _BUILD_LIST BUILD_LIST +#define _BUILD_MAP BUILD_MAP +#define _BUILD_SET BUILD_SET +#define _BUILD_SLICE BUILD_SLICE +#define _BUILD_STRING BUILD_STRING +#define _BUILD_TEMPLATE BUILD_TEMPLATE +#define _BUILD_TUPLE BUILD_TUPLE +#define _CALL_BUILTIN_CLASS 320 +#define _CALL_BUILTIN_FAST 321 +#define _CALL_BUILTIN_FAST_WITH_KEYWORDS 322 +#define _CALL_BUILTIN_O 323 +#define _CALL_INTRINSIC_1 CALL_INTRINSIC_1 +#define _CALL_INTRINSIC_2 CALL_INTRINSIC_2 +#define _CALL_ISINSTANCE CALL_ISINSTANCE +#define _CALL_KW_NON_PY 324 +#define _CALL_LEN 325 +#define _CALL_LIST_APPEND CALL_LIST_APPEND +#define _CALL_METHOD_DESCRIPTOR_FAST 326 +#define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS 327 +#define _CALL_METHOD_DESCRIPTOR_NOARGS 328 +#define _CALL_METHOD_DESCRIPTOR_O 329 +#define _CALL_NON_PY_GENERAL 330 +#define _CALL_STR_1 331 +#define _CALL_TUPLE_1 332 +#define _CALL_TYPE_1 333 +#define _CHECK_AND_ALLOCATE_OBJECT 334 +#define _CHECK_ATTR_CLASS 335 +#define _CHECK_ATTR_METHOD_LAZY_DICT 336 +#define _CHECK_CALL_BOUND_METHOD_EXACT_ARGS 337 +#define _CHECK_EG_MATCH CHECK_EG_MATCH +#define _CHECK_EXC_MATCH CHECK_EXC_MATCH +#define _CHECK_FUNCTION 338 +#define _CHECK_FUNCTION_EXACT_ARGS 339 +#define _CHECK_FUNCTION_VERSION 340 +#define _CHECK_FUNCTION_VERSION_INLINE 341 +#define _CHECK_FUNCTION_VERSION_KW 342 +#define _CHECK_IS_NOT_PY_CALLABLE 343 +#define _CHECK_IS_NOT_PY_CALLABLE_KW 344 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES 345 +#define _CHECK_METHOD_VERSION 346 +#define _CHECK_METHOD_VERSION_KW 347 +#define _CHECK_PEP_523 348 +#define _CHECK_PERIODIC 349 +#define _CHECK_PERIODIC_IF_NOT_YIELD_FROM 350 +#define _CHECK_RECURSION_REMAINING 351 +#define _CHECK_STACK_SPACE 352 +#define _CHECK_STACK_SPACE_OPERAND 353 +#define _CHECK_VALIDITY 354 +#define _COMPARE_OP 355 +#define _COMPARE_OP_FLOAT 356 +#define _COMPARE_OP_INT 357 +#define _COMPARE_OP_STR 358 +#define _CONTAINS_OP 359 +#define _CONTAINS_OP_DICT 360 +#define _CONTAINS_OP_SET 361 +#define _CONVERT_VALUE CONVERT_VALUE +#define _COPY COPY +#define _COPY_FREE_VARS COPY_FREE_VARS +#define _CREATE_INIT_FRAME 362 +#define _DELETE_ATTR DELETE_ATTR +#define _DELETE_DEREF DELETE_DEREF +#define _DELETE_FAST DELETE_FAST +#define _DELETE_GLOBAL DELETE_GLOBAL +#define _DELETE_NAME DELETE_NAME +#define _DELETE_SUBSCR DELETE_SUBSCR +#define _DEOPT 363 +#define _DICT_MERGE DICT_MERGE +#define _DICT_UPDATE DICT_UPDATE +#define _DO_CALL 364 +#define _DO_CALL_FUNCTION_EX 365 +#define _DO_CALL_KW 366 +#define _END_FOR END_FOR +#define _END_SEND END_SEND +#define _ERROR_POP_N 367 +#define _EXIT_INIT_CHECK EXIT_INIT_CHECK +#define _EXPAND_METHOD 368 +#define _EXPAND_METHOD_KW 369 +#define _FATAL_ERROR 370 +#define _FORMAT_SIMPLE FORMAT_SIMPLE +#define _FORMAT_WITH_SPEC FORMAT_WITH_SPEC +#define _FOR_ITER 371 +#define _FOR_ITER_GEN_FRAME 372 +#define _FOR_ITER_TIER_TWO 373 +#define _GET_AITER GET_AITER +#define _GET_ANEXT GET_ANEXT +#define _GET_AWAITABLE GET_AWAITABLE +#define _GET_ITER GET_ITER +#define _GET_LEN GET_LEN +#define _GET_YIELD_FROM_ITER GET_YIELD_FROM_ITER +#define _GUARD_BINARY_OP_EXTEND 374 +#define _GUARD_CALLABLE_LEN 375 +#define _GUARD_CALLABLE_STR_1 376 +#define _GUARD_CALLABLE_TUPLE_1 377 +#define _GUARD_CALLABLE_TYPE_1 378 +#define _GUARD_DORV_NO_DICT 379 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT 380 +#define _GUARD_GLOBALS_VERSION 381 +#define _GUARD_IS_FALSE_POP 382 +#define _GUARD_IS_NONE_POP 383 +#define _GUARD_IS_NOT_NONE_POP 384 +#define _GUARD_IS_TRUE_POP 385 +#define _GUARD_KEYS_VERSION 386 +#define _GUARD_NOS_DICT 387 +#define _GUARD_NOS_FLOAT 388 +#define _GUARD_NOS_INT 389 +#define _GUARD_NOS_LIST 390 +#define _GUARD_NOS_NULL 391 +#define _GUARD_NOS_TUPLE 392 +#define _GUARD_NOS_UNICODE 393 +#define _GUARD_NOT_EXHAUSTED_LIST 394 +#define _GUARD_NOT_EXHAUSTED_RANGE 395 +#define _GUARD_NOT_EXHAUSTED_TUPLE 396 +#define _GUARD_TOS_ANY_SET 397 +#define _GUARD_TOS_DICT 398 +#define _GUARD_TOS_FLOAT 399 +#define _GUARD_TOS_INT 400 +#define _GUARD_TOS_LIST 401 +#define _GUARD_TOS_SLICE 402 +#define _GUARD_TOS_TUPLE 403 +#define _GUARD_TOS_UNICODE 404 +#define _GUARD_TYPE_VERSION 405 +#define _GUARD_TYPE_VERSION_AND_LOCK 406 +#define _IMPORT_FROM IMPORT_FROM +#define _IMPORT_NAME IMPORT_NAME +#define _INIT_CALL_BOUND_METHOD_EXACT_ARGS 407 +#define _INIT_CALL_PY_EXACT_ARGS 408 +#define _INIT_CALL_PY_EXACT_ARGS_0 409 +#define _INIT_CALL_PY_EXACT_ARGS_1 410 +#define _INIT_CALL_PY_EXACT_ARGS_2 411 +#define _INIT_CALL_PY_EXACT_ARGS_3 412 +#define _INIT_CALL_PY_EXACT_ARGS_4 413 +#define _INSERT_NULL 414 +#define _INSTRUMENTED_FOR_ITER INSTRUMENTED_FOR_ITER +#define _INSTRUMENTED_INSTRUCTION INSTRUMENTED_INSTRUCTION +#define _INSTRUMENTED_JUMP_FORWARD INSTRUMENTED_JUMP_FORWARD +#define _INSTRUMENTED_LINE INSTRUMENTED_LINE +#define _INSTRUMENTED_NOT_TAKEN INSTRUMENTED_NOT_TAKEN +#define _INSTRUMENTED_POP_JUMP_IF_FALSE INSTRUMENTED_POP_JUMP_IF_FALSE +#define _INSTRUMENTED_POP_JUMP_IF_NONE INSTRUMENTED_POP_JUMP_IF_NONE +#define _INSTRUMENTED_POP_JUMP_IF_NOT_NONE INSTRUMENTED_POP_JUMP_IF_NOT_NONE +#define _INSTRUMENTED_POP_JUMP_IF_TRUE INSTRUMENTED_POP_JUMP_IF_TRUE +#define _IS_NONE 415 +#define _IS_OP IS_OP +#define _ITER_CHECK_LIST 416 +#define _ITER_CHECK_RANGE 417 +#define _ITER_CHECK_TUPLE 418 +#define _ITER_JUMP_LIST 419 +#define _ITER_JUMP_RANGE 420 +#define _ITER_JUMP_TUPLE 421 +#define _ITER_NEXT_LIST 422 +#define _ITER_NEXT_LIST_TIER_TWO 423 +#define _ITER_NEXT_RANGE 424 +#define _ITER_NEXT_TUPLE 425 +#define _JUMP_TO_TOP 426 +#define _LIST_APPEND LIST_APPEND +#define _LIST_EXTEND LIST_EXTEND +#define _LOAD_ATTR 427 +#define _LOAD_ATTR_CLASS 428 +#define _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN +#define _LOAD_ATTR_INSTANCE_VALUE 429 +#define _LOAD_ATTR_METHOD_LAZY_DICT 430 +#define _LOAD_ATTR_METHOD_NO_DICT 431 +#define _LOAD_ATTR_METHOD_WITH_VALUES 432 +#define _LOAD_ATTR_MODULE 433 +#define _LOAD_ATTR_NONDESCRIPTOR_NO_DICT 434 +#define _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES 435 +#define _LOAD_ATTR_PROPERTY_FRAME 436 +#define _LOAD_ATTR_SLOT 437 +#define _LOAD_ATTR_WITH_HINT 438 +#define _LOAD_BUILD_CLASS LOAD_BUILD_CLASS +#define _LOAD_BYTECODE 439 +#define _LOAD_COMMON_CONSTANT LOAD_COMMON_CONSTANT +#define _LOAD_CONST LOAD_CONST +#define _LOAD_CONST_IMMORTAL LOAD_CONST_IMMORTAL +#define _LOAD_CONST_INLINE 440 +#define _LOAD_CONST_INLINE_BORROW 441 +#define _LOAD_CONST_MORTAL LOAD_CONST_MORTAL +#define _LOAD_DEREF LOAD_DEREF +#define _LOAD_FAST 442 +#define _LOAD_FAST_0 443 +#define _LOAD_FAST_1 444 +#define _LOAD_FAST_2 445 +#define _LOAD_FAST_3 446 +#define _LOAD_FAST_4 447 +#define _LOAD_FAST_5 448 +#define _LOAD_FAST_6 449 +#define _LOAD_FAST_7 450 +#define _LOAD_FAST_AND_CLEAR LOAD_FAST_AND_CLEAR +#define _LOAD_FAST_BORROW 451 +#define _LOAD_FAST_BORROW_0 452 +#define _LOAD_FAST_BORROW_1 453 +#define _LOAD_FAST_BORROW_2 454 +#define _LOAD_FAST_BORROW_3 455 +#define _LOAD_FAST_BORROW_4 456 +#define _LOAD_FAST_BORROW_5 457 +#define _LOAD_FAST_BORROW_6 458 +#define _LOAD_FAST_BORROW_7 459 +#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW LOAD_FAST_BORROW_LOAD_FAST_BORROW +#define _LOAD_FAST_CHECK LOAD_FAST_CHECK +#define _LOAD_FAST_LOAD_FAST LOAD_FAST_LOAD_FAST +#define _LOAD_FROM_DICT_OR_DEREF LOAD_FROM_DICT_OR_DEREF +#define _LOAD_FROM_DICT_OR_GLOBALS LOAD_FROM_DICT_OR_GLOBALS +#define _LOAD_GLOBAL 460 +#define _LOAD_GLOBAL_BUILTINS 461 +#define _LOAD_GLOBAL_MODULE 462 +#define _LOAD_LOCALS LOAD_LOCALS +#define _LOAD_NAME LOAD_NAME +#define _LOAD_SMALL_INT 463 +#define _LOAD_SMALL_INT_0 464 +#define _LOAD_SMALL_INT_1 465 +#define _LOAD_SMALL_INT_2 466 +#define _LOAD_SMALL_INT_3 467 +#define _LOAD_SPECIAL 468 +#define _LOAD_SUPER_ATTR_ATTR LOAD_SUPER_ATTR_ATTR +#define _LOAD_SUPER_ATTR_METHOD LOAD_SUPER_ATTR_METHOD +#define _MAKE_CALLARGS_A_TUPLE 469 +#define _MAKE_CELL MAKE_CELL +#define _MAKE_FUNCTION MAKE_FUNCTION +#define _MAKE_WARM 470 +#define _MAP_ADD MAP_ADD +#define _MATCH_CLASS MATCH_CLASS +#define _MATCH_KEYS MATCH_KEYS +#define _MATCH_MAPPING MATCH_MAPPING +#define _MATCH_SEQUENCE MATCH_SEQUENCE +#define _MAYBE_EXPAND_METHOD 471 +#define _MAYBE_EXPAND_METHOD_KW 472 +#define _MONITOR_CALL 473 +#define _MONITOR_CALL_KW 474 +#define _MONITOR_JUMP_BACKWARD 475 +#define _MONITOR_RESUME 476 +#define _NOP NOP +#define _POP_EXCEPT POP_EXCEPT +#define _POP_JUMP_IF_FALSE 477 +#define _POP_JUMP_IF_TRUE 478 +#define _POP_TOP POP_TOP +#define _POP_TOP_LOAD_CONST_INLINE 479 +#define _POP_TOP_LOAD_CONST_INLINE_BORROW 480 +#define _POP_TWO_LOAD_CONST_INLINE_BORROW 481 +#define _PUSH_EXC_INFO PUSH_EXC_INFO +#define _PUSH_FRAME 482 +#define _PUSH_NULL PUSH_NULL +#define _PUSH_NULL_CONDITIONAL 483 +#define _PY_FRAME_GENERAL 484 +#define _PY_FRAME_KW 485 +#define _QUICKEN_RESUME 486 +#define _REPLACE_WITH_TRUE 487 +#define _RESUME_CHECK RESUME_CHECK +#define _RETURN_GENERATOR RETURN_GENERATOR +#define _RETURN_VALUE RETURN_VALUE +#define _SAVE_RETURN_OFFSET 488 +#define _SEND 489 +#define _SEND_GEN_FRAME 490 +#define _SETUP_ANNOTATIONS SETUP_ANNOTATIONS +#define _SET_ADD SET_ADD +#define _SET_FUNCTION_ATTRIBUTE SET_FUNCTION_ATTRIBUTE +#define _SET_UPDATE SET_UPDATE +#define _START_EXECUTOR 491 +#define _STORE_ATTR 492 +#define _STORE_ATTR_INSTANCE_VALUE 493 +#define _STORE_ATTR_SLOT 494 +#define _STORE_ATTR_WITH_HINT 495 +#define _STORE_DEREF STORE_DEREF +#define _STORE_FAST 496 +#define _STORE_FAST_0 497 +#define _STORE_FAST_1 498 +#define _STORE_FAST_2 499 +#define _STORE_FAST_3 500 +#define _STORE_FAST_4 501 +#define _STORE_FAST_5 502 +#define _STORE_FAST_6 503 +#define _STORE_FAST_7 504 +#define _STORE_FAST_LOAD_FAST STORE_FAST_LOAD_FAST +#define _STORE_FAST_STORE_FAST STORE_FAST_STORE_FAST +#define _STORE_GLOBAL STORE_GLOBAL +#define _STORE_NAME STORE_NAME +#define _STORE_SLICE 505 +#define _STORE_SUBSCR 506 +#define _STORE_SUBSCR_DICT 507 +#define _STORE_SUBSCR_LIST_INT 508 +#define _SWAP SWAP +#define _TIER2_RESUME_CHECK 509 +#define _TO_BOOL 510 +#define _TO_BOOL_BOOL TO_BOOL_BOOL +#define _TO_BOOL_INT TO_BOOL_INT +#define _TO_BOOL_LIST 511 +#define _TO_BOOL_NONE TO_BOOL_NONE +#define _TO_BOOL_STR 512 +#define _UNARY_INVERT UNARY_INVERT +#define _UNARY_NEGATIVE UNARY_NEGATIVE +#define _UNARY_NOT UNARY_NOT +#define _UNPACK_EX UNPACK_EX +#define _UNPACK_SEQUENCE 513 +#define _UNPACK_SEQUENCE_LIST 514 +#define _UNPACK_SEQUENCE_TUPLE 515 +#define _UNPACK_SEQUENCE_TWO_TUPLE 516 +#define _WITH_EXCEPT_START WITH_EXCEPT_START +#define _YIELD_VALUE YIELD_VALUE +#define MAX_UOP_ID 516 + +#ifdef __cplusplus +} +#endif +#endif /* !Py_CORE_UOP_IDS_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_uop_metadata.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_uop_metadata.h new file mode 100644 index 0000000000000000000000000000000000000000..2166a6900f120a193e227cd893b1cf71ac38c70c --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_uop_metadata.h @@ -0,0 +1,1204 @@ +// This file is generated by Tools/cases_generator/uop_metadata_generator.py +// from: +// Python/bytecodes.c +// Do not edit! + +#ifndef Py_CORE_UOP_METADATA_H +#define Py_CORE_UOP_METADATA_H +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include "pycore_uop_ids.h" +extern const uint16_t _PyUop_Flags[MAX_UOP_ID+1]; +extern const uint8_t _PyUop_Replication[MAX_UOP_ID+1]; +extern const char * const _PyOpcode_uop_name[MAX_UOP_ID+1]; + +extern int _PyUop_num_popped(int opcode, int oparg); + +#ifdef NEED_OPCODE_METADATA +const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { + [_NOP] = HAS_PURE_FLAG, + [_CHECK_PERIODIC] = HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CHECK_PERIODIC_IF_NOT_YIELD_FROM] = HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_RESUME_CHECK] = HAS_DEOPT_FLAG, + [_LOAD_FAST_CHECK] = HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_FAST_0] = HAS_LOCAL_FLAG | HAS_PURE_FLAG, + [_LOAD_FAST_1] = HAS_LOCAL_FLAG | HAS_PURE_FLAG, + [_LOAD_FAST_2] = HAS_LOCAL_FLAG | HAS_PURE_FLAG, + [_LOAD_FAST_3] = HAS_LOCAL_FLAG | HAS_PURE_FLAG, + [_LOAD_FAST_4] = HAS_LOCAL_FLAG | HAS_PURE_FLAG, + [_LOAD_FAST_5] = HAS_LOCAL_FLAG | HAS_PURE_FLAG, + [_LOAD_FAST_6] = HAS_LOCAL_FLAG | HAS_PURE_FLAG, + [_LOAD_FAST_7] = HAS_LOCAL_FLAG | HAS_PURE_FLAG, + [_LOAD_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_PURE_FLAG, + [_LOAD_FAST_BORROW_0] = HAS_LOCAL_FLAG | HAS_PURE_FLAG, + [_LOAD_FAST_BORROW_1] = HAS_LOCAL_FLAG | HAS_PURE_FLAG, + [_LOAD_FAST_BORROW_2] = HAS_LOCAL_FLAG | HAS_PURE_FLAG, + [_LOAD_FAST_BORROW_3] = HAS_LOCAL_FLAG | HAS_PURE_FLAG, + [_LOAD_FAST_BORROW_4] = HAS_LOCAL_FLAG | HAS_PURE_FLAG, + [_LOAD_FAST_BORROW_5] = HAS_LOCAL_FLAG | HAS_PURE_FLAG, + [_LOAD_FAST_BORROW_6] = HAS_LOCAL_FLAG | HAS_PURE_FLAG, + [_LOAD_FAST_BORROW_7] = HAS_LOCAL_FLAG | HAS_PURE_FLAG, + [_LOAD_FAST_BORROW] = HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_PURE_FLAG, + [_LOAD_FAST_AND_CLEAR] = HAS_ARG_FLAG | HAS_LOCAL_FLAG, + [_LOAD_FAST_LOAD_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG, + [_LOAD_FAST_BORROW_LOAD_FAST_BORROW] = HAS_ARG_FLAG | HAS_LOCAL_FLAG, + [_LOAD_CONST_MORTAL] = HAS_ARG_FLAG | HAS_CONST_FLAG, + [_LOAD_CONST_IMMORTAL] = HAS_ARG_FLAG | HAS_CONST_FLAG, + [_LOAD_SMALL_INT_0] = 0, + [_LOAD_SMALL_INT_1] = 0, + [_LOAD_SMALL_INT_2] = 0, + [_LOAD_SMALL_INT_3] = 0, + [_LOAD_SMALL_INT] = HAS_ARG_FLAG, + [_STORE_FAST_0] = HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG, + [_STORE_FAST_1] = HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG, + [_STORE_FAST_2] = HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG, + [_STORE_FAST_3] = HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG, + [_STORE_FAST_4] = HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG, + [_STORE_FAST_5] = HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG, + [_STORE_FAST_6] = HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG, + [_STORE_FAST_7] = HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG, + [_STORE_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG, + [_STORE_FAST_LOAD_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG, + [_STORE_FAST_STORE_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG, + [_POP_TOP] = HAS_ESCAPES_FLAG | HAS_PURE_FLAG, + [_PUSH_NULL] = HAS_PURE_FLAG, + [_END_FOR] = HAS_ESCAPES_FLAG | HAS_NO_SAVE_IP_FLAG, + [_END_SEND] = HAS_ESCAPES_FLAG | HAS_PURE_FLAG, + [_UNARY_NEGATIVE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_UNARY_NOT] = HAS_PURE_FLAG, + [_TO_BOOL] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_TO_BOOL_BOOL] = HAS_EXIT_FLAG, + [_TO_BOOL_INT] = HAS_EXIT_FLAG | HAS_ESCAPES_FLAG, + [_GUARD_NOS_LIST] = HAS_EXIT_FLAG, + [_GUARD_TOS_LIST] = HAS_EXIT_FLAG, + [_GUARD_TOS_SLICE] = HAS_EXIT_FLAG, + [_TO_BOOL_LIST] = 0, + [_TO_BOOL_NONE] = HAS_EXIT_FLAG, + [_GUARD_NOS_UNICODE] = HAS_EXIT_FLAG, + [_GUARD_TOS_UNICODE] = HAS_EXIT_FLAG, + [_TO_BOOL_STR] = HAS_ESCAPES_FLAG, + [_REPLACE_WITH_TRUE] = HAS_ESCAPES_FLAG, + [_UNARY_INVERT] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_GUARD_NOS_INT] = HAS_EXIT_FLAG, + [_GUARD_TOS_INT] = HAS_EXIT_FLAG, + [_BINARY_OP_MULTIPLY_INT] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG | HAS_PURE_FLAG, + [_BINARY_OP_ADD_INT] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG | HAS_PURE_FLAG, + [_BINARY_OP_SUBTRACT_INT] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG | HAS_PURE_FLAG, + [_GUARD_NOS_FLOAT] = HAS_EXIT_FLAG, + [_GUARD_TOS_FLOAT] = HAS_EXIT_FLAG, + [_BINARY_OP_MULTIPLY_FLOAT] = HAS_ERROR_FLAG | HAS_PURE_FLAG, + [_BINARY_OP_ADD_FLOAT] = HAS_ERROR_FLAG | HAS_PURE_FLAG, + [_BINARY_OP_SUBTRACT_FLOAT] = HAS_ERROR_FLAG | HAS_PURE_FLAG, + [_BINARY_OP_ADD_UNICODE] = HAS_ERROR_FLAG | HAS_PURE_FLAG, + [_BINARY_OP_INPLACE_ADD_UNICODE] = HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_GUARD_BINARY_OP_EXTEND] = HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_BINARY_OP_EXTEND] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG | HAS_PURE_FLAG, + [_BINARY_SLICE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_STORE_SLICE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BINARY_OP_SUBSCR_LIST_INT] = HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_BINARY_OP_SUBSCR_LIST_SLICE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BINARY_OP_SUBSCR_STR_INT] = HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_GUARD_NOS_TUPLE] = HAS_EXIT_FLAG, + [_GUARD_TOS_TUPLE] = HAS_EXIT_FLAG, + [_BINARY_OP_SUBSCR_TUPLE_INT] = HAS_DEOPT_FLAG, + [_GUARD_NOS_DICT] = HAS_EXIT_FLAG, + [_GUARD_TOS_DICT] = HAS_EXIT_FLAG, + [_BINARY_OP_SUBSCR_DICT] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BINARY_OP_SUBSCR_CHECK_FUNC] = HAS_DEOPT_FLAG, + [_BINARY_OP_SUBSCR_INIT_CALL] = 0, + [_LIST_APPEND] = HAS_ARG_FLAG | HAS_ERROR_FLAG, + [_SET_ADD] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_STORE_SUBSCR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_STORE_SUBSCR_LIST_INT] = HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_STORE_SUBSCR_DICT] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_DELETE_SUBSCR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_INTRINSIC_1] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_INTRINSIC_2] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_RETURN_VALUE] = HAS_ESCAPES_FLAG, + [_GET_AITER] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_GET_ANEXT] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_GET_AWAITABLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_SEND_GEN_FRAME] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, + [_YIELD_VALUE] = HAS_ARG_FLAG, + [_POP_EXCEPT] = HAS_ESCAPES_FLAG, + [_LOAD_COMMON_CONSTANT] = HAS_ARG_FLAG, + [_LOAD_BUILD_CLASS] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_STORE_NAME] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_DELETE_NAME] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_UNPACK_SEQUENCE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_UNPACK_SEQUENCE_TWO_TUPLE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_UNPACK_SEQUENCE_TUPLE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, + [_UNPACK_SEQUENCE_LIST] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, + [_UNPACK_EX] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_STORE_ATTR] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_DELETE_ATTR] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_STORE_GLOBAL] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_DELETE_GLOBAL] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_LOCALS] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_NAME] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_GLOBAL] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_PUSH_NULL_CONDITIONAL] = HAS_ARG_FLAG, + [_GUARD_GLOBALS_VERSION] = HAS_DEOPT_FLAG, + [_LOAD_GLOBAL_MODULE] = HAS_DEOPT_FLAG, + [_LOAD_GLOBAL_BUILTINS] = HAS_DEOPT_FLAG, + [_DELETE_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_MAKE_CELL] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_DELETE_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_FROM_DICT_OR_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_DEREF] = HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_STORE_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ESCAPES_FLAG, + [_COPY_FREE_VARS] = HAS_ARG_FLAG, + [_BUILD_STRING] = HAS_ARG_FLAG | HAS_ERROR_FLAG, + [_BUILD_INTERPOLATION] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BUILD_TEMPLATE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BUILD_TUPLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG, + [_BUILD_LIST] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_LIST_EXTEND] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_SET_UPDATE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BUILD_SET] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BUILD_MAP] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_SETUP_ANNOTATIONS] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_DICT_UPDATE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_DICT_MERGE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_MAP_ADD] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_SUPER_ATTR_ATTR] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_SUPER_ATTR_METHOD] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_ATTR] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_GUARD_TYPE_VERSION] = HAS_EXIT_FLAG, + [_GUARD_TYPE_VERSION_AND_LOCK] = HAS_EXIT_FLAG, + [_CHECK_MANAGED_OBJECT_HAS_VALUES] = HAS_DEOPT_FLAG, + [_LOAD_ATTR_INSTANCE_VALUE] = HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_ATTR_MODULE] = HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_ATTR_WITH_HINT] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_ATTR_SLOT] = HAS_DEOPT_FLAG, + [_CHECK_ATTR_CLASS] = HAS_EXIT_FLAG, + [_LOAD_ATTR_CLASS] = 0, + [_LOAD_ATTR_PROPERTY_FRAME] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, + [_GUARD_DORV_NO_DICT] = HAS_EXIT_FLAG, + [_STORE_ATTR_INSTANCE_VALUE] = HAS_ESCAPES_FLAG, + [_STORE_ATTR_WITH_HINT] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_STORE_ATTR_SLOT] = HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_COMPARE_OP] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_COMPARE_OP_FLOAT] = HAS_ARG_FLAG, + [_COMPARE_OP_INT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, + [_COMPARE_OP_STR] = HAS_ARG_FLAG, + [_IS_OP] = HAS_ARG_FLAG, + [_CONTAINS_OP] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_GUARD_TOS_ANY_SET] = HAS_DEOPT_FLAG, + [_CONTAINS_OP_SET] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CONTAINS_OP_DICT] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CHECK_EG_MATCH] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CHECK_EXC_MATCH] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_IMPORT_NAME] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_IMPORT_FROM] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_IS_NONE] = 0, + [_GET_LEN] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_MATCH_CLASS] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_MATCH_MAPPING] = 0, + [_MATCH_SEQUENCE] = 0, + [_MATCH_KEYS] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_GET_ITER] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_GET_YIELD_FROM_ITER] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_FOR_ITER_TIER_TWO] = HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_ITER_CHECK_LIST] = HAS_EXIT_FLAG, + [_GUARD_NOT_EXHAUSTED_LIST] = HAS_EXIT_FLAG, + [_ITER_NEXT_LIST_TIER_TWO] = HAS_EXIT_FLAG | HAS_ESCAPES_FLAG, + [_ITER_CHECK_TUPLE] = HAS_EXIT_FLAG, + [_GUARD_NOT_EXHAUSTED_TUPLE] = HAS_EXIT_FLAG, + [_ITER_NEXT_TUPLE] = 0, + [_ITER_CHECK_RANGE] = HAS_EXIT_FLAG, + [_GUARD_NOT_EXHAUSTED_RANGE] = HAS_EXIT_FLAG, + [_ITER_NEXT_RANGE] = HAS_ERROR_FLAG, + [_FOR_ITER_GEN_FRAME] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, + [_INSERT_NULL] = 0, + [_LOAD_SPECIAL] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_WITH_EXCEPT_START] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_PUSH_EXC_INFO] = 0, + [_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT] = HAS_DEOPT_FLAG, + [_GUARD_KEYS_VERSION] = HAS_DEOPT_FLAG, + [_LOAD_ATTR_METHOD_WITH_VALUES] = HAS_ARG_FLAG, + [_LOAD_ATTR_METHOD_NO_DICT] = HAS_ARG_FLAG, + [_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_CHECK_ATTR_METHOD_LAZY_DICT] = HAS_DEOPT_FLAG, + [_LOAD_ATTR_METHOD_LAZY_DICT] = HAS_ARG_FLAG, + [_MAYBE_EXPAND_METHOD] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_PY_FRAME_GENERAL] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_CHECK_FUNCTION_VERSION] = HAS_ARG_FLAG | HAS_EXIT_FLAG, + [_CHECK_FUNCTION_VERSION_INLINE] = HAS_EXIT_FLAG, + [_CHECK_METHOD_VERSION] = HAS_ARG_FLAG | HAS_EXIT_FLAG, + [_EXPAND_METHOD] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_CHECK_IS_NOT_PY_CALLABLE] = HAS_ARG_FLAG | HAS_EXIT_FLAG, + [_CALL_NON_PY_GENERAL] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CHECK_CALL_BOUND_METHOD_EXACT_ARGS] = HAS_ARG_FLAG | HAS_EXIT_FLAG, + [_INIT_CALL_BOUND_METHOD_EXACT_ARGS] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_CHECK_PEP_523] = HAS_DEOPT_FLAG, + [_CHECK_FUNCTION_EXACT_ARGS] = HAS_ARG_FLAG | HAS_EXIT_FLAG, + [_CHECK_STACK_SPACE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, + [_CHECK_RECURSION_REMAINING] = HAS_DEOPT_FLAG, + [_INIT_CALL_PY_EXACT_ARGS_0] = HAS_PURE_FLAG, + [_INIT_CALL_PY_EXACT_ARGS_1] = HAS_PURE_FLAG, + [_INIT_CALL_PY_EXACT_ARGS_2] = HAS_PURE_FLAG, + [_INIT_CALL_PY_EXACT_ARGS_3] = HAS_PURE_FLAG, + [_INIT_CALL_PY_EXACT_ARGS_4] = HAS_PURE_FLAG, + [_INIT_CALL_PY_EXACT_ARGS] = HAS_ARG_FLAG | HAS_PURE_FLAG, + [_PUSH_FRAME] = 0, + [_GUARD_NOS_NULL] = HAS_DEOPT_FLAG, + [_GUARD_CALLABLE_TYPE_1] = HAS_DEOPT_FLAG, + [_CALL_TYPE_1] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_GUARD_CALLABLE_STR_1] = HAS_DEOPT_FLAG, + [_CALL_STR_1] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_GUARD_CALLABLE_TUPLE_1] = HAS_DEOPT_FLAG, + [_CALL_TUPLE_1] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CHECK_AND_ALLOCATE_OBJECT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_CREATE_INIT_FRAME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_EXIT_INIT_CHECK] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_CALL_BUILTIN_CLASS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_BUILTIN_O] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_BUILTIN_FAST] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_BUILTIN_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_GUARD_CALLABLE_LEN] = HAS_DEOPT_FLAG, + [_CALL_LEN] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_CALL_ISINSTANCE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_CALL_LIST_APPEND] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_METHOD_DESCRIPTOR_O] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_METHOD_DESCRIPTOR_NOARGS] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_METHOD_DESCRIPTOR_FAST] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_MAYBE_EXPAND_METHOD_KW] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_PY_FRAME_KW] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CHECK_FUNCTION_VERSION_KW] = HAS_ARG_FLAG | HAS_EXIT_FLAG, + [_CHECK_METHOD_VERSION_KW] = HAS_ARG_FLAG | HAS_EXIT_FLAG, + [_EXPAND_METHOD_KW] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_CHECK_IS_NOT_PY_CALLABLE_KW] = HAS_ARG_FLAG | HAS_EXIT_FLAG, + [_CALL_KW_NON_PY] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_MAKE_CALLARGS_A_TUPLE] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_MAKE_FUNCTION] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_SET_FUNCTION_ATTRIBUTE] = HAS_ARG_FLAG, + [_RETURN_GENERATOR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BUILD_SLICE] = HAS_ARG_FLAG | HAS_ERROR_FLAG, + [_CONVERT_VALUE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_FORMAT_SIMPLE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_FORMAT_WITH_SPEC] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_COPY] = HAS_ARG_FLAG | HAS_PURE_FLAG, + [_BINARY_OP] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_SWAP] = HAS_ARG_FLAG | HAS_PURE_FLAG, + [_GUARD_IS_TRUE_POP] = HAS_EXIT_FLAG, + [_GUARD_IS_FALSE_POP] = HAS_EXIT_FLAG, + [_GUARD_IS_NONE_POP] = HAS_EXIT_FLAG | HAS_ESCAPES_FLAG, + [_GUARD_IS_NOT_NONE_POP] = HAS_EXIT_FLAG | HAS_ESCAPES_FLAG, + [_JUMP_TO_TOP] = 0, + [_SET_IP] = 0, + [_CHECK_STACK_SPACE_OPERAND] = HAS_DEOPT_FLAG, + [_SAVE_RETURN_OFFSET] = HAS_ARG_FLAG, + [_EXIT_TRACE] = HAS_ESCAPES_FLAG, + [_CHECK_VALIDITY] = HAS_DEOPT_FLAG, + [_LOAD_CONST_INLINE] = HAS_PURE_FLAG, + [_POP_TOP_LOAD_CONST_INLINE] = HAS_ESCAPES_FLAG | HAS_PURE_FLAG, + [_LOAD_CONST_INLINE_BORROW] = HAS_PURE_FLAG, + [_POP_TOP_LOAD_CONST_INLINE_BORROW] = HAS_ESCAPES_FLAG | HAS_PURE_FLAG, + [_POP_TWO_LOAD_CONST_INLINE_BORROW] = HAS_ESCAPES_FLAG | HAS_PURE_FLAG, + [_CHECK_FUNCTION] = HAS_DEOPT_FLAG, + [_START_EXECUTOR] = 0, + [_MAKE_WARM] = 0, + [_FATAL_ERROR] = 0, + [_DEOPT] = 0, + [_ERROR_POP_N] = HAS_ARG_FLAG, + [_TIER2_RESUME_CHECK] = HAS_DEOPT_FLAG, +}; + +const uint8_t _PyUop_Replication[MAX_UOP_ID+1] = { + [_LOAD_FAST] = 8, + [_LOAD_FAST_BORROW] = 8, + [_LOAD_SMALL_INT] = 4, + [_STORE_FAST] = 8, + [_INIT_CALL_PY_EXACT_ARGS] = 5, +}; + +const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = { + [_BINARY_OP] = "_BINARY_OP", + [_BINARY_OP_ADD_FLOAT] = "_BINARY_OP_ADD_FLOAT", + [_BINARY_OP_ADD_INT] = "_BINARY_OP_ADD_INT", + [_BINARY_OP_ADD_UNICODE] = "_BINARY_OP_ADD_UNICODE", + [_BINARY_OP_EXTEND] = "_BINARY_OP_EXTEND", + [_BINARY_OP_INPLACE_ADD_UNICODE] = "_BINARY_OP_INPLACE_ADD_UNICODE", + [_BINARY_OP_MULTIPLY_FLOAT] = "_BINARY_OP_MULTIPLY_FLOAT", + [_BINARY_OP_MULTIPLY_INT] = "_BINARY_OP_MULTIPLY_INT", + [_BINARY_OP_SUBSCR_CHECK_FUNC] = "_BINARY_OP_SUBSCR_CHECK_FUNC", + [_BINARY_OP_SUBSCR_DICT] = "_BINARY_OP_SUBSCR_DICT", + [_BINARY_OP_SUBSCR_INIT_CALL] = "_BINARY_OP_SUBSCR_INIT_CALL", + [_BINARY_OP_SUBSCR_LIST_INT] = "_BINARY_OP_SUBSCR_LIST_INT", + [_BINARY_OP_SUBSCR_LIST_SLICE] = "_BINARY_OP_SUBSCR_LIST_SLICE", + [_BINARY_OP_SUBSCR_STR_INT] = "_BINARY_OP_SUBSCR_STR_INT", + [_BINARY_OP_SUBSCR_TUPLE_INT] = "_BINARY_OP_SUBSCR_TUPLE_INT", + [_BINARY_OP_SUBTRACT_FLOAT] = "_BINARY_OP_SUBTRACT_FLOAT", + [_BINARY_OP_SUBTRACT_INT] = "_BINARY_OP_SUBTRACT_INT", + [_BINARY_SLICE] = "_BINARY_SLICE", + [_BUILD_INTERPOLATION] = "_BUILD_INTERPOLATION", + [_BUILD_LIST] = "_BUILD_LIST", + [_BUILD_MAP] = "_BUILD_MAP", + [_BUILD_SET] = "_BUILD_SET", + [_BUILD_SLICE] = "_BUILD_SLICE", + [_BUILD_STRING] = "_BUILD_STRING", + [_BUILD_TEMPLATE] = "_BUILD_TEMPLATE", + [_BUILD_TUPLE] = "_BUILD_TUPLE", + [_CALL_BUILTIN_CLASS] = "_CALL_BUILTIN_CLASS", + [_CALL_BUILTIN_FAST] = "_CALL_BUILTIN_FAST", + [_CALL_BUILTIN_FAST_WITH_KEYWORDS] = "_CALL_BUILTIN_FAST_WITH_KEYWORDS", + [_CALL_BUILTIN_O] = "_CALL_BUILTIN_O", + [_CALL_INTRINSIC_1] = "_CALL_INTRINSIC_1", + [_CALL_INTRINSIC_2] = "_CALL_INTRINSIC_2", + [_CALL_ISINSTANCE] = "_CALL_ISINSTANCE", + [_CALL_KW_NON_PY] = "_CALL_KW_NON_PY", + [_CALL_LEN] = "_CALL_LEN", + [_CALL_LIST_APPEND] = "_CALL_LIST_APPEND", + [_CALL_METHOD_DESCRIPTOR_FAST] = "_CALL_METHOD_DESCRIPTOR_FAST", + [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = "_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS", + [_CALL_METHOD_DESCRIPTOR_NOARGS] = "_CALL_METHOD_DESCRIPTOR_NOARGS", + [_CALL_METHOD_DESCRIPTOR_O] = "_CALL_METHOD_DESCRIPTOR_O", + [_CALL_NON_PY_GENERAL] = "_CALL_NON_PY_GENERAL", + [_CALL_STR_1] = "_CALL_STR_1", + [_CALL_TUPLE_1] = "_CALL_TUPLE_1", + [_CALL_TYPE_1] = "_CALL_TYPE_1", + [_CHECK_AND_ALLOCATE_OBJECT] = "_CHECK_AND_ALLOCATE_OBJECT", + [_CHECK_ATTR_CLASS] = "_CHECK_ATTR_CLASS", + [_CHECK_ATTR_METHOD_LAZY_DICT] = "_CHECK_ATTR_METHOD_LAZY_DICT", + [_CHECK_CALL_BOUND_METHOD_EXACT_ARGS] = "_CHECK_CALL_BOUND_METHOD_EXACT_ARGS", + [_CHECK_EG_MATCH] = "_CHECK_EG_MATCH", + [_CHECK_EXC_MATCH] = "_CHECK_EXC_MATCH", + [_CHECK_FUNCTION] = "_CHECK_FUNCTION", + [_CHECK_FUNCTION_EXACT_ARGS] = "_CHECK_FUNCTION_EXACT_ARGS", + [_CHECK_FUNCTION_VERSION] = "_CHECK_FUNCTION_VERSION", + [_CHECK_FUNCTION_VERSION_INLINE] = "_CHECK_FUNCTION_VERSION_INLINE", + [_CHECK_FUNCTION_VERSION_KW] = "_CHECK_FUNCTION_VERSION_KW", + [_CHECK_IS_NOT_PY_CALLABLE] = "_CHECK_IS_NOT_PY_CALLABLE", + [_CHECK_IS_NOT_PY_CALLABLE_KW] = "_CHECK_IS_NOT_PY_CALLABLE_KW", + [_CHECK_MANAGED_OBJECT_HAS_VALUES] = "_CHECK_MANAGED_OBJECT_HAS_VALUES", + [_CHECK_METHOD_VERSION] = "_CHECK_METHOD_VERSION", + [_CHECK_METHOD_VERSION_KW] = "_CHECK_METHOD_VERSION_KW", + [_CHECK_PEP_523] = "_CHECK_PEP_523", + [_CHECK_PERIODIC] = "_CHECK_PERIODIC", + [_CHECK_PERIODIC_IF_NOT_YIELD_FROM] = "_CHECK_PERIODIC_IF_NOT_YIELD_FROM", + [_CHECK_RECURSION_REMAINING] = "_CHECK_RECURSION_REMAINING", + [_CHECK_STACK_SPACE] = "_CHECK_STACK_SPACE", + [_CHECK_STACK_SPACE_OPERAND] = "_CHECK_STACK_SPACE_OPERAND", + [_CHECK_VALIDITY] = "_CHECK_VALIDITY", + [_COMPARE_OP] = "_COMPARE_OP", + [_COMPARE_OP_FLOAT] = "_COMPARE_OP_FLOAT", + [_COMPARE_OP_INT] = "_COMPARE_OP_INT", + [_COMPARE_OP_STR] = "_COMPARE_OP_STR", + [_CONTAINS_OP] = "_CONTAINS_OP", + [_CONTAINS_OP_DICT] = "_CONTAINS_OP_DICT", + [_CONTAINS_OP_SET] = "_CONTAINS_OP_SET", + [_CONVERT_VALUE] = "_CONVERT_VALUE", + [_COPY] = "_COPY", + [_COPY_FREE_VARS] = "_COPY_FREE_VARS", + [_CREATE_INIT_FRAME] = "_CREATE_INIT_FRAME", + [_DELETE_ATTR] = "_DELETE_ATTR", + [_DELETE_DEREF] = "_DELETE_DEREF", + [_DELETE_FAST] = "_DELETE_FAST", + [_DELETE_GLOBAL] = "_DELETE_GLOBAL", + [_DELETE_NAME] = "_DELETE_NAME", + [_DELETE_SUBSCR] = "_DELETE_SUBSCR", + [_DEOPT] = "_DEOPT", + [_DICT_MERGE] = "_DICT_MERGE", + [_DICT_UPDATE] = "_DICT_UPDATE", + [_END_FOR] = "_END_FOR", + [_END_SEND] = "_END_SEND", + [_ERROR_POP_N] = "_ERROR_POP_N", + [_EXIT_INIT_CHECK] = "_EXIT_INIT_CHECK", + [_EXIT_TRACE] = "_EXIT_TRACE", + [_EXPAND_METHOD] = "_EXPAND_METHOD", + [_EXPAND_METHOD_KW] = "_EXPAND_METHOD_KW", + [_FATAL_ERROR] = "_FATAL_ERROR", + [_FORMAT_SIMPLE] = "_FORMAT_SIMPLE", + [_FORMAT_WITH_SPEC] = "_FORMAT_WITH_SPEC", + [_FOR_ITER_GEN_FRAME] = "_FOR_ITER_GEN_FRAME", + [_FOR_ITER_TIER_TWO] = "_FOR_ITER_TIER_TWO", + [_GET_AITER] = "_GET_AITER", + [_GET_ANEXT] = "_GET_ANEXT", + [_GET_AWAITABLE] = "_GET_AWAITABLE", + [_GET_ITER] = "_GET_ITER", + [_GET_LEN] = "_GET_LEN", + [_GET_YIELD_FROM_ITER] = "_GET_YIELD_FROM_ITER", + [_GUARD_BINARY_OP_EXTEND] = "_GUARD_BINARY_OP_EXTEND", + [_GUARD_CALLABLE_LEN] = "_GUARD_CALLABLE_LEN", + [_GUARD_CALLABLE_STR_1] = "_GUARD_CALLABLE_STR_1", + [_GUARD_CALLABLE_TUPLE_1] = "_GUARD_CALLABLE_TUPLE_1", + [_GUARD_CALLABLE_TYPE_1] = "_GUARD_CALLABLE_TYPE_1", + [_GUARD_DORV_NO_DICT] = "_GUARD_DORV_NO_DICT", + [_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT] = "_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT", + [_GUARD_GLOBALS_VERSION] = "_GUARD_GLOBALS_VERSION", + [_GUARD_IS_FALSE_POP] = "_GUARD_IS_FALSE_POP", + [_GUARD_IS_NONE_POP] = "_GUARD_IS_NONE_POP", + [_GUARD_IS_NOT_NONE_POP] = "_GUARD_IS_NOT_NONE_POP", + [_GUARD_IS_TRUE_POP] = "_GUARD_IS_TRUE_POP", + [_GUARD_KEYS_VERSION] = "_GUARD_KEYS_VERSION", + [_GUARD_NOS_DICT] = "_GUARD_NOS_DICT", + [_GUARD_NOS_FLOAT] = "_GUARD_NOS_FLOAT", + [_GUARD_NOS_INT] = "_GUARD_NOS_INT", + [_GUARD_NOS_LIST] = "_GUARD_NOS_LIST", + [_GUARD_NOS_NULL] = "_GUARD_NOS_NULL", + [_GUARD_NOS_TUPLE] = "_GUARD_NOS_TUPLE", + [_GUARD_NOS_UNICODE] = "_GUARD_NOS_UNICODE", + [_GUARD_NOT_EXHAUSTED_LIST] = "_GUARD_NOT_EXHAUSTED_LIST", + [_GUARD_NOT_EXHAUSTED_RANGE] = "_GUARD_NOT_EXHAUSTED_RANGE", + [_GUARD_NOT_EXHAUSTED_TUPLE] = "_GUARD_NOT_EXHAUSTED_TUPLE", + [_GUARD_TOS_ANY_SET] = "_GUARD_TOS_ANY_SET", + [_GUARD_TOS_DICT] = "_GUARD_TOS_DICT", + [_GUARD_TOS_FLOAT] = "_GUARD_TOS_FLOAT", + [_GUARD_TOS_INT] = "_GUARD_TOS_INT", + [_GUARD_TOS_LIST] = "_GUARD_TOS_LIST", + [_GUARD_TOS_SLICE] = "_GUARD_TOS_SLICE", + [_GUARD_TOS_TUPLE] = "_GUARD_TOS_TUPLE", + [_GUARD_TOS_UNICODE] = "_GUARD_TOS_UNICODE", + [_GUARD_TYPE_VERSION] = "_GUARD_TYPE_VERSION", + [_GUARD_TYPE_VERSION_AND_LOCK] = "_GUARD_TYPE_VERSION_AND_LOCK", + [_IMPORT_FROM] = "_IMPORT_FROM", + [_IMPORT_NAME] = "_IMPORT_NAME", + [_INIT_CALL_BOUND_METHOD_EXACT_ARGS] = "_INIT_CALL_BOUND_METHOD_EXACT_ARGS", + [_INIT_CALL_PY_EXACT_ARGS] = "_INIT_CALL_PY_EXACT_ARGS", + [_INIT_CALL_PY_EXACT_ARGS_0] = "_INIT_CALL_PY_EXACT_ARGS_0", + [_INIT_CALL_PY_EXACT_ARGS_1] = "_INIT_CALL_PY_EXACT_ARGS_1", + [_INIT_CALL_PY_EXACT_ARGS_2] = "_INIT_CALL_PY_EXACT_ARGS_2", + [_INIT_CALL_PY_EXACT_ARGS_3] = "_INIT_CALL_PY_EXACT_ARGS_3", + [_INIT_CALL_PY_EXACT_ARGS_4] = "_INIT_CALL_PY_EXACT_ARGS_4", + [_INSERT_NULL] = "_INSERT_NULL", + [_IS_NONE] = "_IS_NONE", + [_IS_OP] = "_IS_OP", + [_ITER_CHECK_LIST] = "_ITER_CHECK_LIST", + [_ITER_CHECK_RANGE] = "_ITER_CHECK_RANGE", + [_ITER_CHECK_TUPLE] = "_ITER_CHECK_TUPLE", + [_ITER_NEXT_LIST_TIER_TWO] = "_ITER_NEXT_LIST_TIER_TWO", + [_ITER_NEXT_RANGE] = "_ITER_NEXT_RANGE", + [_ITER_NEXT_TUPLE] = "_ITER_NEXT_TUPLE", + [_JUMP_TO_TOP] = "_JUMP_TO_TOP", + [_LIST_APPEND] = "_LIST_APPEND", + [_LIST_EXTEND] = "_LIST_EXTEND", + [_LOAD_ATTR] = "_LOAD_ATTR", + [_LOAD_ATTR_CLASS] = "_LOAD_ATTR_CLASS", + [_LOAD_ATTR_INSTANCE_VALUE] = "_LOAD_ATTR_INSTANCE_VALUE", + [_LOAD_ATTR_METHOD_LAZY_DICT] = "_LOAD_ATTR_METHOD_LAZY_DICT", + [_LOAD_ATTR_METHOD_NO_DICT] = "_LOAD_ATTR_METHOD_NO_DICT", + [_LOAD_ATTR_METHOD_WITH_VALUES] = "_LOAD_ATTR_METHOD_WITH_VALUES", + [_LOAD_ATTR_MODULE] = "_LOAD_ATTR_MODULE", + [_LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = "_LOAD_ATTR_NONDESCRIPTOR_NO_DICT", + [_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = "_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES", + [_LOAD_ATTR_PROPERTY_FRAME] = "_LOAD_ATTR_PROPERTY_FRAME", + [_LOAD_ATTR_SLOT] = "_LOAD_ATTR_SLOT", + [_LOAD_ATTR_WITH_HINT] = "_LOAD_ATTR_WITH_HINT", + [_LOAD_BUILD_CLASS] = "_LOAD_BUILD_CLASS", + [_LOAD_COMMON_CONSTANT] = "_LOAD_COMMON_CONSTANT", + [_LOAD_CONST_IMMORTAL] = "_LOAD_CONST_IMMORTAL", + [_LOAD_CONST_INLINE] = "_LOAD_CONST_INLINE", + [_LOAD_CONST_INLINE_BORROW] = "_LOAD_CONST_INLINE_BORROW", + [_LOAD_CONST_MORTAL] = "_LOAD_CONST_MORTAL", + [_LOAD_DEREF] = "_LOAD_DEREF", + [_LOAD_FAST] = "_LOAD_FAST", + [_LOAD_FAST_0] = "_LOAD_FAST_0", + [_LOAD_FAST_1] = "_LOAD_FAST_1", + [_LOAD_FAST_2] = "_LOAD_FAST_2", + [_LOAD_FAST_3] = "_LOAD_FAST_3", + [_LOAD_FAST_4] = "_LOAD_FAST_4", + [_LOAD_FAST_5] = "_LOAD_FAST_5", + [_LOAD_FAST_6] = "_LOAD_FAST_6", + [_LOAD_FAST_7] = "_LOAD_FAST_7", + [_LOAD_FAST_AND_CLEAR] = "_LOAD_FAST_AND_CLEAR", + [_LOAD_FAST_BORROW] = "_LOAD_FAST_BORROW", + [_LOAD_FAST_BORROW_0] = "_LOAD_FAST_BORROW_0", + [_LOAD_FAST_BORROW_1] = "_LOAD_FAST_BORROW_1", + [_LOAD_FAST_BORROW_2] = "_LOAD_FAST_BORROW_2", + [_LOAD_FAST_BORROW_3] = "_LOAD_FAST_BORROW_3", + [_LOAD_FAST_BORROW_4] = "_LOAD_FAST_BORROW_4", + [_LOAD_FAST_BORROW_5] = "_LOAD_FAST_BORROW_5", + [_LOAD_FAST_BORROW_6] = "_LOAD_FAST_BORROW_6", + [_LOAD_FAST_BORROW_7] = "_LOAD_FAST_BORROW_7", + [_LOAD_FAST_BORROW_LOAD_FAST_BORROW] = "_LOAD_FAST_BORROW_LOAD_FAST_BORROW", + [_LOAD_FAST_CHECK] = "_LOAD_FAST_CHECK", + [_LOAD_FAST_LOAD_FAST] = "_LOAD_FAST_LOAD_FAST", + [_LOAD_FROM_DICT_OR_DEREF] = "_LOAD_FROM_DICT_OR_DEREF", + [_LOAD_GLOBAL] = "_LOAD_GLOBAL", + [_LOAD_GLOBAL_BUILTINS] = "_LOAD_GLOBAL_BUILTINS", + [_LOAD_GLOBAL_MODULE] = "_LOAD_GLOBAL_MODULE", + [_LOAD_LOCALS] = "_LOAD_LOCALS", + [_LOAD_NAME] = "_LOAD_NAME", + [_LOAD_SMALL_INT] = "_LOAD_SMALL_INT", + [_LOAD_SMALL_INT_0] = "_LOAD_SMALL_INT_0", + [_LOAD_SMALL_INT_1] = "_LOAD_SMALL_INT_1", + [_LOAD_SMALL_INT_2] = "_LOAD_SMALL_INT_2", + [_LOAD_SMALL_INT_3] = "_LOAD_SMALL_INT_3", + [_LOAD_SPECIAL] = "_LOAD_SPECIAL", + [_LOAD_SUPER_ATTR_ATTR] = "_LOAD_SUPER_ATTR_ATTR", + [_LOAD_SUPER_ATTR_METHOD] = "_LOAD_SUPER_ATTR_METHOD", + [_MAKE_CALLARGS_A_TUPLE] = "_MAKE_CALLARGS_A_TUPLE", + [_MAKE_CELL] = "_MAKE_CELL", + [_MAKE_FUNCTION] = "_MAKE_FUNCTION", + [_MAKE_WARM] = "_MAKE_WARM", + [_MAP_ADD] = "_MAP_ADD", + [_MATCH_CLASS] = "_MATCH_CLASS", + [_MATCH_KEYS] = "_MATCH_KEYS", + [_MATCH_MAPPING] = "_MATCH_MAPPING", + [_MATCH_SEQUENCE] = "_MATCH_SEQUENCE", + [_MAYBE_EXPAND_METHOD] = "_MAYBE_EXPAND_METHOD", + [_MAYBE_EXPAND_METHOD_KW] = "_MAYBE_EXPAND_METHOD_KW", + [_NOP] = "_NOP", + [_POP_EXCEPT] = "_POP_EXCEPT", + [_POP_TOP] = "_POP_TOP", + [_POP_TOP_LOAD_CONST_INLINE] = "_POP_TOP_LOAD_CONST_INLINE", + [_POP_TOP_LOAD_CONST_INLINE_BORROW] = "_POP_TOP_LOAD_CONST_INLINE_BORROW", + [_POP_TWO_LOAD_CONST_INLINE_BORROW] = "_POP_TWO_LOAD_CONST_INLINE_BORROW", + [_PUSH_EXC_INFO] = "_PUSH_EXC_INFO", + [_PUSH_FRAME] = "_PUSH_FRAME", + [_PUSH_NULL] = "_PUSH_NULL", + [_PUSH_NULL_CONDITIONAL] = "_PUSH_NULL_CONDITIONAL", + [_PY_FRAME_GENERAL] = "_PY_FRAME_GENERAL", + [_PY_FRAME_KW] = "_PY_FRAME_KW", + [_REPLACE_WITH_TRUE] = "_REPLACE_WITH_TRUE", + [_RESUME_CHECK] = "_RESUME_CHECK", + [_RETURN_GENERATOR] = "_RETURN_GENERATOR", + [_RETURN_VALUE] = "_RETURN_VALUE", + [_SAVE_RETURN_OFFSET] = "_SAVE_RETURN_OFFSET", + [_SEND_GEN_FRAME] = "_SEND_GEN_FRAME", + [_SETUP_ANNOTATIONS] = "_SETUP_ANNOTATIONS", + [_SET_ADD] = "_SET_ADD", + [_SET_FUNCTION_ATTRIBUTE] = "_SET_FUNCTION_ATTRIBUTE", + [_SET_IP] = "_SET_IP", + [_SET_UPDATE] = "_SET_UPDATE", + [_START_EXECUTOR] = "_START_EXECUTOR", + [_STORE_ATTR] = "_STORE_ATTR", + [_STORE_ATTR_INSTANCE_VALUE] = "_STORE_ATTR_INSTANCE_VALUE", + [_STORE_ATTR_SLOT] = "_STORE_ATTR_SLOT", + [_STORE_ATTR_WITH_HINT] = "_STORE_ATTR_WITH_HINT", + [_STORE_DEREF] = "_STORE_DEREF", + [_STORE_FAST] = "_STORE_FAST", + [_STORE_FAST_0] = "_STORE_FAST_0", + [_STORE_FAST_1] = "_STORE_FAST_1", + [_STORE_FAST_2] = "_STORE_FAST_2", + [_STORE_FAST_3] = "_STORE_FAST_3", + [_STORE_FAST_4] = "_STORE_FAST_4", + [_STORE_FAST_5] = "_STORE_FAST_5", + [_STORE_FAST_6] = "_STORE_FAST_6", + [_STORE_FAST_7] = "_STORE_FAST_7", + [_STORE_FAST_LOAD_FAST] = "_STORE_FAST_LOAD_FAST", + [_STORE_FAST_STORE_FAST] = "_STORE_FAST_STORE_FAST", + [_STORE_GLOBAL] = "_STORE_GLOBAL", + [_STORE_NAME] = "_STORE_NAME", + [_STORE_SLICE] = "_STORE_SLICE", + [_STORE_SUBSCR] = "_STORE_SUBSCR", + [_STORE_SUBSCR_DICT] = "_STORE_SUBSCR_DICT", + [_STORE_SUBSCR_LIST_INT] = "_STORE_SUBSCR_LIST_INT", + [_SWAP] = "_SWAP", + [_TIER2_RESUME_CHECK] = "_TIER2_RESUME_CHECK", + [_TO_BOOL] = "_TO_BOOL", + [_TO_BOOL_BOOL] = "_TO_BOOL_BOOL", + [_TO_BOOL_INT] = "_TO_BOOL_INT", + [_TO_BOOL_LIST] = "_TO_BOOL_LIST", + [_TO_BOOL_NONE] = "_TO_BOOL_NONE", + [_TO_BOOL_STR] = "_TO_BOOL_STR", + [_UNARY_INVERT] = "_UNARY_INVERT", + [_UNARY_NEGATIVE] = "_UNARY_NEGATIVE", + [_UNARY_NOT] = "_UNARY_NOT", + [_UNPACK_EX] = "_UNPACK_EX", + [_UNPACK_SEQUENCE] = "_UNPACK_SEQUENCE", + [_UNPACK_SEQUENCE_LIST] = "_UNPACK_SEQUENCE_LIST", + [_UNPACK_SEQUENCE_TUPLE] = "_UNPACK_SEQUENCE_TUPLE", + [_UNPACK_SEQUENCE_TWO_TUPLE] = "_UNPACK_SEQUENCE_TWO_TUPLE", + [_WITH_EXCEPT_START] = "_WITH_EXCEPT_START", + [_YIELD_VALUE] = "_YIELD_VALUE", +}; +int _PyUop_num_popped(int opcode, int oparg) +{ + switch(opcode) { + case _NOP: + return 0; + case _CHECK_PERIODIC: + return 0; + case _CHECK_PERIODIC_IF_NOT_YIELD_FROM: + return 0; + case _RESUME_CHECK: + return 0; + case _LOAD_FAST_CHECK: + return 0; + case _LOAD_FAST_0: + return 0; + case _LOAD_FAST_1: + return 0; + case _LOAD_FAST_2: + return 0; + case _LOAD_FAST_3: + return 0; + case _LOAD_FAST_4: + return 0; + case _LOAD_FAST_5: + return 0; + case _LOAD_FAST_6: + return 0; + case _LOAD_FAST_7: + return 0; + case _LOAD_FAST: + return 0; + case _LOAD_FAST_BORROW_0: + return 0; + case _LOAD_FAST_BORROW_1: + return 0; + case _LOAD_FAST_BORROW_2: + return 0; + case _LOAD_FAST_BORROW_3: + return 0; + case _LOAD_FAST_BORROW_4: + return 0; + case _LOAD_FAST_BORROW_5: + return 0; + case _LOAD_FAST_BORROW_6: + return 0; + case _LOAD_FAST_BORROW_7: + return 0; + case _LOAD_FAST_BORROW: + return 0; + case _LOAD_FAST_AND_CLEAR: + return 0; + case _LOAD_FAST_LOAD_FAST: + return 0; + case _LOAD_FAST_BORROW_LOAD_FAST_BORROW: + return 0; + case _LOAD_CONST_MORTAL: + return 0; + case _LOAD_CONST_IMMORTAL: + return 0; + case _LOAD_SMALL_INT_0: + return 0; + case _LOAD_SMALL_INT_1: + return 0; + case _LOAD_SMALL_INT_2: + return 0; + case _LOAD_SMALL_INT_3: + return 0; + case _LOAD_SMALL_INT: + return 0; + case _STORE_FAST_0: + return 1; + case _STORE_FAST_1: + return 1; + case _STORE_FAST_2: + return 1; + case _STORE_FAST_3: + return 1; + case _STORE_FAST_4: + return 1; + case _STORE_FAST_5: + return 1; + case _STORE_FAST_6: + return 1; + case _STORE_FAST_7: + return 1; + case _STORE_FAST: + return 1; + case _STORE_FAST_LOAD_FAST: + return 1; + case _STORE_FAST_STORE_FAST: + return 2; + case _POP_TOP: + return 1; + case _PUSH_NULL: + return 0; + case _END_FOR: + return 1; + case _END_SEND: + return 2; + case _UNARY_NEGATIVE: + return 1; + case _UNARY_NOT: + return 1; + case _TO_BOOL: + return 1; + case _TO_BOOL_BOOL: + return 0; + case _TO_BOOL_INT: + return 1; + case _GUARD_NOS_LIST: + return 0; + case _GUARD_TOS_LIST: + return 0; + case _GUARD_TOS_SLICE: + return 0; + case _TO_BOOL_LIST: + return 1; + case _TO_BOOL_NONE: + return 1; + case _GUARD_NOS_UNICODE: + return 0; + case _GUARD_TOS_UNICODE: + return 0; + case _TO_BOOL_STR: + return 1; + case _REPLACE_WITH_TRUE: + return 1; + case _UNARY_INVERT: + return 1; + case _GUARD_NOS_INT: + return 0; + case _GUARD_TOS_INT: + return 0; + case _BINARY_OP_MULTIPLY_INT: + return 2; + case _BINARY_OP_ADD_INT: + return 2; + case _BINARY_OP_SUBTRACT_INT: + return 2; + case _GUARD_NOS_FLOAT: + return 0; + case _GUARD_TOS_FLOAT: + return 0; + case _BINARY_OP_MULTIPLY_FLOAT: + return 2; + case _BINARY_OP_ADD_FLOAT: + return 2; + case _BINARY_OP_SUBTRACT_FLOAT: + return 2; + case _BINARY_OP_ADD_UNICODE: + return 2; + case _BINARY_OP_INPLACE_ADD_UNICODE: + return 2; + case _GUARD_BINARY_OP_EXTEND: + return 0; + case _BINARY_OP_EXTEND: + return 2; + case _BINARY_SLICE: + return 3; + case _STORE_SLICE: + return 4; + case _BINARY_OP_SUBSCR_LIST_INT: + return 2; + case _BINARY_OP_SUBSCR_LIST_SLICE: + return 2; + case _BINARY_OP_SUBSCR_STR_INT: + return 2; + case _GUARD_NOS_TUPLE: + return 0; + case _GUARD_TOS_TUPLE: + return 0; + case _BINARY_OP_SUBSCR_TUPLE_INT: + return 2; + case _GUARD_NOS_DICT: + return 0; + case _GUARD_TOS_DICT: + return 0; + case _BINARY_OP_SUBSCR_DICT: + return 2; + case _BINARY_OP_SUBSCR_CHECK_FUNC: + return 0; + case _BINARY_OP_SUBSCR_INIT_CALL: + return 3; + case _LIST_APPEND: + return 1; + case _SET_ADD: + return 1; + case _STORE_SUBSCR: + return 3; + case _STORE_SUBSCR_LIST_INT: + return 3; + case _STORE_SUBSCR_DICT: + return 3; + case _DELETE_SUBSCR: + return 2; + case _CALL_INTRINSIC_1: + return 1; + case _CALL_INTRINSIC_2: + return 2; + case _RETURN_VALUE: + return 1; + case _GET_AITER: + return 1; + case _GET_ANEXT: + return 0; + case _GET_AWAITABLE: + return 1; + case _SEND_GEN_FRAME: + return 1; + case _YIELD_VALUE: + return 1; + case _POP_EXCEPT: + return 1; + case _LOAD_COMMON_CONSTANT: + return 0; + case _LOAD_BUILD_CLASS: + return 0; + case _STORE_NAME: + return 1; + case _DELETE_NAME: + return 0; + case _UNPACK_SEQUENCE: + return 1; + case _UNPACK_SEQUENCE_TWO_TUPLE: + return 1; + case _UNPACK_SEQUENCE_TUPLE: + return 1; + case _UNPACK_SEQUENCE_LIST: + return 1; + case _UNPACK_EX: + return 1; + case _STORE_ATTR: + return 2; + case _DELETE_ATTR: + return 1; + case _STORE_GLOBAL: + return 1; + case _DELETE_GLOBAL: + return 0; + case _LOAD_LOCALS: + return 0; + case _LOAD_NAME: + return 0; + case _LOAD_GLOBAL: + return 0; + case _PUSH_NULL_CONDITIONAL: + return 0; + case _GUARD_GLOBALS_VERSION: + return 0; + case _LOAD_GLOBAL_MODULE: + return 0; + case _LOAD_GLOBAL_BUILTINS: + return 0; + case _DELETE_FAST: + return 0; + case _MAKE_CELL: + return 0; + case _DELETE_DEREF: + return 0; + case _LOAD_FROM_DICT_OR_DEREF: + return 1; + case _LOAD_DEREF: + return 0; + case _STORE_DEREF: + return 1; + case _COPY_FREE_VARS: + return 0; + case _BUILD_STRING: + return oparg; + case _BUILD_INTERPOLATION: + return 2 + (oparg & 1); + case _BUILD_TEMPLATE: + return 2; + case _BUILD_TUPLE: + return oparg; + case _BUILD_LIST: + return oparg; + case _LIST_EXTEND: + return 1; + case _SET_UPDATE: + return 1; + case _BUILD_SET: + return oparg; + case _BUILD_MAP: + return oparg*2; + case _SETUP_ANNOTATIONS: + return 0; + case _DICT_UPDATE: + return 1; + case _DICT_MERGE: + return 1; + case _MAP_ADD: + return 2; + case _LOAD_SUPER_ATTR_ATTR: + return 3; + case _LOAD_SUPER_ATTR_METHOD: + return 3; + case _LOAD_ATTR: + return 1; + case _GUARD_TYPE_VERSION: + return 0; + case _GUARD_TYPE_VERSION_AND_LOCK: + return 0; + case _CHECK_MANAGED_OBJECT_HAS_VALUES: + return 0; + case _LOAD_ATTR_INSTANCE_VALUE: + return 1; + case _LOAD_ATTR_MODULE: + return 1; + case _LOAD_ATTR_WITH_HINT: + return 1; + case _LOAD_ATTR_SLOT: + return 1; + case _CHECK_ATTR_CLASS: + return 0; + case _LOAD_ATTR_CLASS: + return 1; + case _LOAD_ATTR_PROPERTY_FRAME: + return 1; + case _GUARD_DORV_NO_DICT: + return 0; + case _STORE_ATTR_INSTANCE_VALUE: + return 2; + case _STORE_ATTR_WITH_HINT: + return 2; + case _STORE_ATTR_SLOT: + return 2; + case _COMPARE_OP: + return 2; + case _COMPARE_OP_FLOAT: + return 2; + case _COMPARE_OP_INT: + return 2; + case _COMPARE_OP_STR: + return 2; + case _IS_OP: + return 2; + case _CONTAINS_OP: + return 2; + case _GUARD_TOS_ANY_SET: + return 0; + case _CONTAINS_OP_SET: + return 2; + case _CONTAINS_OP_DICT: + return 2; + case _CHECK_EG_MATCH: + return 2; + case _CHECK_EXC_MATCH: + return 1; + case _IMPORT_NAME: + return 2; + case _IMPORT_FROM: + return 0; + case _IS_NONE: + return 1; + case _GET_LEN: + return 0; + case _MATCH_CLASS: + return 3; + case _MATCH_MAPPING: + return 0; + case _MATCH_SEQUENCE: + return 0; + case _MATCH_KEYS: + return 0; + case _GET_ITER: + return 1; + case _GET_YIELD_FROM_ITER: + return 1; + case _FOR_ITER_TIER_TWO: + return 0; + case _ITER_CHECK_LIST: + return 0; + case _GUARD_NOT_EXHAUSTED_LIST: + return 0; + case _ITER_NEXT_LIST_TIER_TWO: + return 0; + case _ITER_CHECK_TUPLE: + return 0; + case _GUARD_NOT_EXHAUSTED_TUPLE: + return 0; + case _ITER_NEXT_TUPLE: + return 0; + case _ITER_CHECK_RANGE: + return 0; + case _GUARD_NOT_EXHAUSTED_RANGE: + return 0; + case _ITER_NEXT_RANGE: + return 0; + case _FOR_ITER_GEN_FRAME: + return 0; + case _INSERT_NULL: + return 1; + case _LOAD_SPECIAL: + return 0; + case _WITH_EXCEPT_START: + return 0; + case _PUSH_EXC_INFO: + return 1; + case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT: + return 0; + case _GUARD_KEYS_VERSION: + return 0; + case _LOAD_ATTR_METHOD_WITH_VALUES: + return 1; + case _LOAD_ATTR_METHOD_NO_DICT: + return 1; + case _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES: + return 1; + case _LOAD_ATTR_NONDESCRIPTOR_NO_DICT: + return 1; + case _CHECK_ATTR_METHOD_LAZY_DICT: + return 0; + case _LOAD_ATTR_METHOD_LAZY_DICT: + return 1; + case _MAYBE_EXPAND_METHOD: + return 0; + case _PY_FRAME_GENERAL: + return 2 + oparg; + case _CHECK_FUNCTION_VERSION: + return 0; + case _CHECK_FUNCTION_VERSION_INLINE: + return 0; + case _CHECK_METHOD_VERSION: + return 0; + case _EXPAND_METHOD: + return 0; + case _CHECK_IS_NOT_PY_CALLABLE: + return 0; + case _CALL_NON_PY_GENERAL: + return 2 + oparg; + case _CHECK_CALL_BOUND_METHOD_EXACT_ARGS: + return 0; + case _INIT_CALL_BOUND_METHOD_EXACT_ARGS: + return 0; + case _CHECK_PEP_523: + return 0; + case _CHECK_FUNCTION_EXACT_ARGS: + return 0; + case _CHECK_STACK_SPACE: + return 0; + case _CHECK_RECURSION_REMAINING: + return 0; + case _INIT_CALL_PY_EXACT_ARGS_0: + return 2 + oparg; + case _INIT_CALL_PY_EXACT_ARGS_1: + return 2 + oparg; + case _INIT_CALL_PY_EXACT_ARGS_2: + return 2 + oparg; + case _INIT_CALL_PY_EXACT_ARGS_3: + return 2 + oparg; + case _INIT_CALL_PY_EXACT_ARGS_4: + return 2 + oparg; + case _INIT_CALL_PY_EXACT_ARGS: + return 2 + oparg; + case _PUSH_FRAME: + return 1; + case _GUARD_NOS_NULL: + return 0; + case _GUARD_CALLABLE_TYPE_1: + return 0; + case _CALL_TYPE_1: + return 3; + case _GUARD_CALLABLE_STR_1: + return 0; + case _CALL_STR_1: + return 3; + case _GUARD_CALLABLE_TUPLE_1: + return 0; + case _CALL_TUPLE_1: + return 3; + case _CHECK_AND_ALLOCATE_OBJECT: + return 0; + case _CREATE_INIT_FRAME: + return 2 + oparg; + case _EXIT_INIT_CHECK: + return 1; + case _CALL_BUILTIN_CLASS: + return 2 + oparg; + case _CALL_BUILTIN_O: + return 2 + oparg; + case _CALL_BUILTIN_FAST: + return 2 + oparg; + case _CALL_BUILTIN_FAST_WITH_KEYWORDS: + return 2 + oparg; + case _GUARD_CALLABLE_LEN: + return 0; + case _CALL_LEN: + return 3; + case _CALL_ISINSTANCE: + return 2 + oparg; + case _CALL_LIST_APPEND: + return 3; + case _CALL_METHOD_DESCRIPTOR_O: + return 2 + oparg; + case _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS: + return 2 + oparg; + case _CALL_METHOD_DESCRIPTOR_NOARGS: + return 2 + oparg; + case _CALL_METHOD_DESCRIPTOR_FAST: + return 2 + oparg; + case _MAYBE_EXPAND_METHOD_KW: + return 0; + case _PY_FRAME_KW: + return 3 + oparg; + case _CHECK_FUNCTION_VERSION_KW: + return 0; + case _CHECK_METHOD_VERSION_KW: + return 0; + case _EXPAND_METHOD_KW: + return 0; + case _CHECK_IS_NOT_PY_CALLABLE_KW: + return 0; + case _CALL_KW_NON_PY: + return 3 + oparg; + case _MAKE_CALLARGS_A_TUPLE: + return 0; + case _MAKE_FUNCTION: + return 1; + case _SET_FUNCTION_ATTRIBUTE: + return 2; + case _RETURN_GENERATOR: + return 0; + case _BUILD_SLICE: + return oparg; + case _CONVERT_VALUE: + return 1; + case _FORMAT_SIMPLE: + return 1; + case _FORMAT_WITH_SPEC: + return 2; + case _COPY: + return 0; + case _BINARY_OP: + return 2; + case _SWAP: + return 0; + case _GUARD_IS_TRUE_POP: + return 1; + case _GUARD_IS_FALSE_POP: + return 1; + case _GUARD_IS_NONE_POP: + return 1; + case _GUARD_IS_NOT_NONE_POP: + return 1; + case _JUMP_TO_TOP: + return 0; + case _SET_IP: + return 0; + case _CHECK_STACK_SPACE_OPERAND: + return 0; + case _SAVE_RETURN_OFFSET: + return 0; + case _EXIT_TRACE: + return 0; + case _CHECK_VALIDITY: + return 0; + case _LOAD_CONST_INLINE: + return 0; + case _POP_TOP_LOAD_CONST_INLINE: + return 1; + case _LOAD_CONST_INLINE_BORROW: + return 0; + case _POP_TOP_LOAD_CONST_INLINE_BORROW: + return 1; + case _POP_TWO_LOAD_CONST_INLINE_BORROW: + return 2; + case _CHECK_FUNCTION: + return 0; + case _START_EXECUTOR: + return 0; + case _MAKE_WARM: + return 0; + case _FATAL_ERROR: + return 0; + case _DEOPT: + return 0; + case _ERROR_POP_N: + return 0; + case _TIER2_RESUME_CHECK: + return 0; + default: + return -1; + } +} + +#endif // NEED_OPCODE_METADATA + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_CORE_UOP_METADATA_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_warnings.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_warnings.h new file mode 100644 index 0000000000000000000000000000000000000000..e1348d529a22463e1f38adc3b042184275bef9a8 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_warnings.h @@ -0,0 +1,21 @@ +#ifndef Py_INTERNAL_WARNINGS_H +#define Py_INTERNAL_WARNINGS_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +extern int _PyWarnings_InitState(PyInterpreterState *interp); + +extern PyObject* _PyWarnings_Init(void); + +extern void _PyErr_WarnUnawaitedCoroutine(PyObject *coro); +extern void _PyErr_WarnUnawaitedAgenMethod(PyAsyncGenObject *agen, PyObject *method); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_WARNINGS_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_weakref.h b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_weakref.h new file mode 100644 index 0000000000000000000000000000000000000000..4ed8928c0b92a8c1d3bc55f3e4f2e5523cd4cc75 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/include/internal/pycore_weakref.h @@ -0,0 +1,133 @@ +#ifndef Py_INTERNAL_WEAKREF_H +#define Py_INTERNAL_WEAKREF_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_critical_section.h" // Py_BEGIN_CRITICAL_SECTION() +#include "pycore_lock.h" // PyMutex_LockFlags() +#include "pycore_object.h" // _Py_REF_IS_MERGED() +#include "pycore_pyatomic_ft_wrappers.h" + +#ifdef Py_GIL_DISABLED + +#define WEAKREF_LIST_LOCK(obj) \ + _PyInterpreterState_GET() \ + ->weakref_locks[((uintptr_t)obj) % NUM_WEAKREF_LIST_LOCKS] + +// Lock using the referenced object +#define LOCK_WEAKREFS(obj) \ + PyMutex_LockFlags(&WEAKREF_LIST_LOCK(obj), _Py_LOCK_DONT_DETACH) +#define UNLOCK_WEAKREFS(obj) PyMutex_Unlock(&WEAKREF_LIST_LOCK(obj)) + +// Lock using a weakref +#define LOCK_WEAKREFS_FOR_WR(wr) \ + PyMutex_LockFlags(wr->weakrefs_lock, _Py_LOCK_DONT_DETACH) +#define UNLOCK_WEAKREFS_FOR_WR(wr) PyMutex_Unlock(wr->weakrefs_lock) + +#define FT_CLEAR_WEAKREFS(obj, weakref_list) \ + do { \ + assert(Py_REFCNT(obj) == 0); \ + PyObject_ClearWeakRefs(obj); \ + } while (0) + +#else + +#define LOCK_WEAKREFS(obj) +#define UNLOCK_WEAKREFS(obj) + +#define LOCK_WEAKREFS_FOR_WR(wr) +#define UNLOCK_WEAKREFS_FOR_WR(wr) + +#define FT_CLEAR_WEAKREFS(obj, weakref_list) \ + do { \ + assert(Py_REFCNT(obj) == 0); \ + if (weakref_list != NULL) { \ + PyObject_ClearWeakRefs(obj); \ + } \ + } while (0) + +#endif + +static inline int _is_dead(PyObject *obj) +{ + // Explanation for the Py_REFCNT() check: when a weakref's target is part + // of a long chain of deallocations which triggers the trashcan mechanism, + // clearing the weakrefs can be delayed long after the target's refcount + // has dropped to zero. In the meantime, code accessing the weakref will + // be able to "see" the target object even though it is supposed to be + // unreachable. See issue gh-60806. +#if defined(Py_GIL_DISABLED) + Py_ssize_t shared = _Py_atomic_load_ssize_relaxed(&obj->ob_ref_shared); + return shared == _Py_REF_SHARED(0, _Py_REF_MERGED); +#else + return (Py_REFCNT(obj) == 0); +#endif +} + +static inline PyObject* _PyWeakref_GET_REF(PyObject *ref_obj) +{ + assert(PyWeakref_Check(ref_obj)); + PyWeakReference *ref = _Py_CAST(PyWeakReference*, ref_obj); + + PyObject *obj = FT_ATOMIC_LOAD_PTR(ref->wr_object); + if (obj == Py_None) { + // clear_weakref() was called + return NULL; + } + + LOCK_WEAKREFS(obj); +#ifdef Py_GIL_DISABLED + if (ref->wr_object == Py_None) { + // clear_weakref() was called + UNLOCK_WEAKREFS(obj); + return NULL; + } +#endif + if (_Py_TryIncref(obj)) { + UNLOCK_WEAKREFS(obj); + return obj; + } + UNLOCK_WEAKREFS(obj); + return NULL; +} + +static inline int _PyWeakref_IS_DEAD(PyObject *ref_obj) +{ + assert(PyWeakref_Check(ref_obj)); + int ret = 0; + PyWeakReference *ref = _Py_CAST(PyWeakReference*, ref_obj); + PyObject *obj = FT_ATOMIC_LOAD_PTR(ref->wr_object); + if (obj == Py_None) { + // clear_weakref() was called + ret = 1; + } + else { + LOCK_WEAKREFS(obj); + // See _PyWeakref_GET_REF() for the rationale of this test +#ifdef Py_GIL_DISABLED + ret = (ref->wr_object == Py_None) || _is_dead(obj); +#else + ret = _is_dead(obj); +#endif + UNLOCK_WEAKREFS(obj); + } + return ret; +} + +extern Py_ssize_t _PyWeakref_GetWeakrefCount(PyObject *obj); + +// Clear all the weak references to obj but leave their callbacks uncalled and +// intact. +extern void _PyWeakref_ClearWeakRefsNoCallbacks(PyObject *obj); + +PyAPI_FUNC(int) _PyWeakref_IsDead(PyObject *weakref); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_WEAKREF_H */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/licenses/LICENSE b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..20cf39097c68baa17cc566b64e76d34ebf034044 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/licenses/LICENSE @@ -0,0 +1,277 @@ +A. HISTORY OF THE SOFTWARE +========================== + +Python was created in the early 1990s by Guido van Rossum at Stichting +Mathematisch Centrum (CWI, see https://www.cwi.nl) in the Netherlands +as a successor of a language called ABC. Guido remains Python's +principal author, although it includes many contributions from others. + +In 1995, Guido continued his work on Python at the Corporation for +National Research Initiatives (CNRI, see https://www.cnri.reston.va.us) +in Reston, Virginia where he released several versions of the +software. + +In May 2000, Guido and the Python core development team moved to +BeOpen.com to form the BeOpen PythonLabs team. In October of the same +year, the PythonLabs team moved to Digital Creations, which became +Zope Corporation. In 2001, the Python Software Foundation (PSF, see +https://www.python.org/psf/) was formed, a non-profit organization +created specifically to own Python-related Intellectual Property. +Zope Corporation was a sponsoring member of the PSF. + +All Python releases are Open Source (see https://opensource.org for +the Open Source Definition). Historically, most, but not all, Python +releases have also been GPL-compatible; the table below summarizes +the various releases. + + Release Derived Year Owner GPL- + from compatible? (1) + + 0.9.0 thru 1.2 1991-1995 CWI yes + 1.3 thru 1.5.2 1.2 1995-1999 CNRI yes + 1.6 1.5.2 2000 CNRI no + 2.0 1.6 2000 BeOpen.com no + 1.6.1 1.6 2001 CNRI yes (2) + 2.1 2.0+1.6.1 2001 PSF no + 2.0.1 2.0+1.6.1 2001 PSF yes + 2.1.1 2.1+2.0.1 2001 PSF yes + 2.1.2 2.1.1 2002 PSF yes + 2.1.3 2.1.2 2002 PSF yes + 2.2 and above 2.1.1 2001-now PSF yes + +Footnotes: + +(1) GPL-compatible doesn't mean that we're distributing Python under + the GPL. All Python licenses, unlike the GPL, let you distribute + a modified version without making your changes open source. The + GPL-compatible licenses make it possible to combine Python with + other software that is released under the GPL; the others don't. + +(2) According to Richard Stallman, 1.6.1 is not GPL-compatible, + because its license has a choice of law clause. According to + CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1 + is "not incompatible" with the GPL. + +Thanks to the many outside volunteers who have worked under Guido's +direction to make these releases possible. + + +B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON +=============================================================== + +Python software and documentation are licensed under the +Python Software Foundation License Version 2. + +Starting with Python 3.8.6, examples, recipes, and other code in +the documentation are dual licensed under the PSF License Version 2 +and the Zero-Clause BSD license. + +Some software incorporated into Python is under different licenses. +The licenses are listed with code falling under that license. + + +PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 +-------------------------------------------- + +1. This LICENSE AGREEMENT is between the Python Software Foundation +("PSF"), and the Individual or Organization ("Licensee") accessing and +otherwise using this software ("Python") in source or binary form and +its associated documentation. + +2. Subject to the terms and conditions of this License Agreement, PSF hereby +grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, +analyze, test, perform and/or display publicly, prepare derivative works, +distribute, and otherwise use Python alone or in any derivative version, +provided, however, that PSF's License Agreement and PSF's notice of copyright, +i.e., "Copyright (c) 2001 Python Software Foundation; All Rights Reserved" +are retained in Python alone or in any derivative version prepared by Licensee. + +3. In the event Licensee prepares a derivative work that is based on +or incorporates Python or any part thereof, and wants to make +the derivative work available to others as provided herein, then +Licensee hereby agrees to include in any such work a brief summary of +the changes made to Python. + +4. PSF is making Python available to Licensee on an "AS IS" +basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR +IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT +INFRINGE ANY THIRD PARTY RIGHTS. + +5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON +FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS +A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, +OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + +6. This License Agreement will automatically terminate upon a material +breach of its terms and conditions. + +7. Nothing in this License Agreement shall be deemed to create any +relationship of agency, partnership, or joint venture between PSF and +Licensee. This License Agreement does not grant permission to use PSF +trademarks or trade name in a trademark sense to endorse or promote +products or services of Licensee, or any third party. + +8. By copying, installing or otherwise using Python, Licensee +agrees to be bound by the terms and conditions of this License +Agreement. + + +BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0 +------------------------------------------- + +BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1 + +1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an +office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the +Individual or Organization ("Licensee") accessing and otherwise using +this software in source or binary form and its associated +documentation ("the Software"). + +2. Subject to the terms and conditions of this BeOpen Python License +Agreement, BeOpen hereby grants Licensee a non-exclusive, +royalty-free, world-wide license to reproduce, analyze, test, perform +and/or display publicly, prepare derivative works, distribute, and +otherwise use the Software alone or in any derivative version, +provided, however, that the BeOpen Python License is retained in the +Software, alone or in any derivative version prepared by Licensee. + +3. BeOpen is making the Software available to Licensee on an "AS IS" +basis. BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR +IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT +INFRINGE ANY THIRD PARTY RIGHTS. + +4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE +SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS +AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY +DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + +5. This License Agreement will automatically terminate upon a material +breach of its terms and conditions. + +6. This License Agreement shall be governed by and interpreted in all +respects by the law of the State of California, excluding conflict of +law provisions. Nothing in this License Agreement shall be deemed to +create any relationship of agency, partnership, or joint venture +between BeOpen and Licensee. This License Agreement does not grant +permission to use BeOpen trademarks or trade names in a trademark +sense to endorse or promote products or services of Licensee, or any +third party. As an exception, the "BeOpen Python" logos available at +http://www.pythonlabs.com/logos.html may be used according to the +permissions granted on that web page. + +7. By copying, installing or otherwise using the software, Licensee +agrees to be bound by the terms and conditions of this License +Agreement. + + +CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1 +--------------------------------------- + +1. This LICENSE AGREEMENT is between the Corporation for National +Research Initiatives, having an office at 1895 Preston White Drive, +Reston, VA 20191 ("CNRI"), and the Individual or Organization +("Licensee") accessing and otherwise using Python 1.6.1 software in +source or binary form and its associated documentation. + +2. Subject to the terms and conditions of this License Agreement, CNRI +hereby grants Licensee a nonexclusive, royalty-free, world-wide +license to reproduce, analyze, test, perform and/or display publicly, +prepare derivative works, distribute, and otherwise use Python 1.6.1 +alone or in any derivative version, provided, however, that CNRI's +License Agreement and CNRI's notice of copyright, i.e., "Copyright (c) +1995-2001 Corporation for National Research Initiatives; All Rights +Reserved" are retained in Python 1.6.1 alone or in any derivative +version prepared by Licensee. Alternately, in lieu of CNRI's License +Agreement, Licensee may substitute the following text (omitting the +quotes): "Python 1.6.1 is made available subject to the terms and +conditions in CNRI's License Agreement. This Agreement together with +Python 1.6.1 may be located on the internet using the following +unique, persistent identifier (known as a handle): 1895.22/1013. This +Agreement may also be obtained from a proxy server on the internet +using the following URL: http://hdl.handle.net/1895.22/1013". + +3. In the event Licensee prepares a derivative work that is based on +or incorporates Python 1.6.1 or any part thereof, and wants to make +the derivative work available to others as provided herein, then +Licensee hereby agrees to include in any such work a brief summary of +the changes made to Python 1.6.1. + +4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS" +basis. CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR +IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT +INFRINGE ANY THIRD PARTY RIGHTS. + +5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON +1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS +A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, +OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + +6. This License Agreement will automatically terminate upon a material +breach of its terms and conditions. + +7. This License Agreement shall be governed by the federal +intellectual property law of the United States, including without +limitation the federal copyright law, and, to the extent such +U.S. federal law does not apply, by the law of the Commonwealth of +Virginia, excluding Virginia's conflict of law provisions. +Notwithstanding the foregoing, with regard to derivative works based +on Python 1.6.1 that incorporate non-separable material that was +previously distributed under the GNU General Public License (GPL), the +law of the Commonwealth of Virginia shall govern this License +Agreement only as to issues arising under or with respect to +Paragraphs 4, 5, and 7 of this License Agreement. Nothing in this +License Agreement shall be deemed to create any relationship of +agency, partnership, or joint venture between CNRI and Licensee. This +License Agreement does not grant permission to use CNRI trademarks or +trade name in a trademark sense to endorse or promote products or +services of Licensee, or any third party. + +8. By clicking on the "ACCEPT" button where indicated, or by copying, +installing or otherwise using Python 1.6.1, Licensee agrees to be +bound by the terms and conditions of this License Agreement. + + ACCEPT + + +CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2 +-------------------------------------------------- + +Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam, +The Netherlands. All rights reserved. + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Stichting Mathematisch +Centrum or CWI not be used in advertising or publicity pertaining to +distribution of the software without specific, written prior +permission. + +STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO +THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE +FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON DOCUMENTATION +---------------------------------------------------------------------- + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/build_base.bat b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/build_base.bat new file mode 100644 index 0000000000000000000000000000000000000000..7dd5ccfe8347cd210ff6cc5bf3f036f53a087a8d --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/build_base.bat @@ -0,0 +1,241 @@ +setlocal EnableDelayedExpansion +echo on + +:: Compile python, extensions and external libraries +if "%target_platform%"=="win-64" ( + set HOST_PLATFORM=x64 + set HOST_DIR=amd64 +) +if "%target_platform%"=="win-32" ( + set HOST_PLATFORM=Win32 + set HOST_DIR=win32 +) +if "%target_platform%"=="win-arm64" ( + set HOST_PLATFORM=ARM64 + set HOST_DIR=arm64 +) + +if "%build_platform%"=="win-64" ( + set BUILD_PLATFORM=x64 + set BUILD_DIR=amd64 +) +if "%build_platform%"=="win-32" ( + set BUILD_PLATFORM=Win32 + set BUILD_DIR=win32 +) +if "%build_platform%"=="win-arm64" ( + set BUILD_PLATFORM=ARM64 + set BUILD_DIR=arm64 +) + +for /F "tokens=1,2 delims=." %%i in ("%PKG_VERSION%") do ( + set "VERNODOTS=%%i%%j" +) + +for /F "tokens=1,2 delims=." %%i in ("%PKG_VERSION%") do ( + set "VER=%%i.%%j" +) + +:: Make sure the "python" value in conda_build_config.yaml is up to date. +for /F "tokens=1,2 delims=." %%i in ("%PKG_VERSION%") do ( + if NOT "%PY_VER%"=="%%i.%%j" exit 1 +) + +for /f "usebackq delims=" %%i in (`conda list -p %PREFIX% sqlite --no-show-channel-urls --json ^| findstr "version"`) do set SQLITE3_VERSION_LINE=%%i +for /f "tokens=2 delims==/ " %%i IN ('echo %SQLITE3_VERSION_LINE%') do (set SQLITE3_VERSION=%%~i) +echo SQLITE3_VERSION detected as %SQLITE3_VERSION% + +if "%PY_INTERP_DEBUG%"=="yes" ( + set CONFIG=-d + set _D=_d +) else ( + set CONFIG= + set _D= +) + +set PGO=--pgo +if "%DEBUG_C%"=="yes" ( + set PGO= +) +if "%CONDA_BUILD_CROSS_COMPILATION%" == "1" ( + set PGO= +) + +if "%PY_FREETHREADING%" == "yes" ( + set "FREETHREADING=--disable-gil" + set "THREAD=t" + set "EXE_T=%VER%t" +) else ( + set "FREETHREADING=--experimental-jit-off" + set "THREAD=" + set "EXE_T=" +) + +cd PCbuild + +setlocal EnableDelayedExpansion +if "%CONDA_BUILD_CROSS_COMPILATION%" == "1" ( + REM build for the build platform. LIBRARY_PREFIX is used by the patches + REM No PGO. No externals, i.e. remove building extension modules + REM we don't need. + set LIBRARY_PREFIX=%BUILD_PREFIX%\\Library + call build.bat %CONFIG% %FREETHREADING% -m -E -v -p %BUILD_PLATFORM% + if errorlevel 1 exit 1 +) +endlocal +:: Twice because: +:: error : importlib_zipimport.h updated. You will need to rebuild pythoncore to see the changes. +call build.bat %PGO% %CONFIG% %FREETHREADING% -m -e -v -p %HOST_PLATFORM% +call build.bat %PGO% %CONFIG% %FREETHREADING% -m -e -v -p %HOST_PLATFORM% +if errorlevel 1 exit 1 +cd .. + +:: Populate the root package directory +for %%x in (python%VERNODOTS%%THREAD%%_D%.dll python3%THREAD%%_D%.dll python%EXE_T%%_D%.exe pythonw%EXE_T%%_D%.exe) do ( + if exist %SRC_DIR%\PCbuild\%HOST_DIR%\%%x ( + copy /Y %SRC_DIR%\PCbuild\%HOST_DIR%\%%x %PREFIX% + ) else ( + echo "WARNING :: %SRC_DIR%\PCbuild\%HOST_DIR%\%%x does not exist" + ) +) + +for %%x in (python%THREAD%%_D%.pdb python%VERNODOTS%%THREAD%%_D%.pdb pythonw%THREAD%%_D%.pdb) do ( + if exist %SRC_DIR%\PCbuild\%HOST_DIR%\%%x ( + copy /Y %SRC_DIR%\PCbuild\%HOST_DIR%\%%x %PREFIX% + ) else ( + echo "WARNING :: %SRC_DIR%\PCbuild\%HOST_DIR%\%%x does not exist" + ) +) + +@echo on + +copy %SRC_DIR%\LICENSE %PREFIX%\LICENSE_PYTHON.txt +if errorlevel 1 exit 1 + +:: Populate the DLLs directory +mkdir %PREFIX%\DLLs +xcopy /s /y %SRC_DIR%\PCBuild\%HOST_DIR%\*.pyd %PREFIX%\DLLs\ +if errorlevel 1 exit 1 + +copy /Y %SRC_DIR%\PC\icons\py.ico %PREFIX%\DLLs\ +if errorlevel 1 exit 1 +copy /Y %SRC_DIR%\PC\icons\pyc.ico %PREFIX%\DLLs\ +if errorlevel 1 exit 1 + +:: Populate the Tools directory +mkdir %PREFIX%\Tools +xcopy /s /y /i %SRC_DIR%\Tools\i18n %PREFIX%\Tools\i18n +if errorlevel 1 exit 1 +xcopy /s /y /i %SRC_DIR%\Tools\scripts %PREFIX%\Tools\scripts +if errorlevel 1 exit 1 + +del %PREFIX%\Tools\scripts\README +if errorlevel 1 exit 1 +del %PREFIX%\Tools\scripts\idle3 +if errorlevel 1 exit 1 + +move /y %PREFIX%\Tools\scripts\pydoc3 %PREFIX%\Tools\scripts\pydoc3.py +if errorlevel 1 exit 1 + +:: Populate the include directory +xcopy /s /y %SRC_DIR%\Include %PREFIX%\include\ +if errorlevel 1 exit 1 + +:: Copy generated pyconfig.h +copy /Y %SRC_DIR%\PC\pyconfig.h %PREFIX%\include\ +if errorlevel 1 exit 1 + +:: Populate the Scripts directory +if not exist %SCRIPTS% (mkdir %SCRIPTS%) +if errorlevel 1 exit 1 + +for %%x in (idle pydoc) do ( + copy /Y %SRC_DIR%\Tools\scripts\%%x3 %SCRIPTS%\%%x + if errorlevel 1 exit 1 +) + +:: Populate the libs directory +if not exist %PREFIX%\libs mkdir %PREFIX%\libs +dir %SRC_DIR%\PCbuild\%HOST_DIR%\ +if exist %SRC_DIR%\PCbuild\%HOST_DIR%\python%VERNODOTS%%THREAD%%_D%.lib copy /Y %SRC_DIR%\PCbuild\%HOST_DIR%\python%VERNODOTS%%THREAD%%_D%.lib %PREFIX%\libs\ +if errorlevel 1 exit 1 +if exist %SRC_DIR%\PCbuild\%HOST_DIR%\python3%THREAD%%_D%.lib copy /Y %SRC_DIR%\PCbuild\%HOST_DIR%\python3%THREAD%%_D%.lib %PREFIX%\libs\ +if errorlevel 1 exit 1 +if exist %SRC_DIR%\PCbuild\%HOST_DIR%\_tkinter%THREAD%%_D%.lib copy /Y %SRC_DIR%\PCbuild\%HOST_DIR%\_tkinter%THREAD%%_D%.lib %PREFIX%\libs\ +if errorlevel 1 exit 1 + + +:: Populate the Lib directory +del %PREFIX%\libs\libpython*.a +xcopy /s /y %SRC_DIR%\Lib %PREFIX%\Lib\ +if errorlevel 1 exit 1 + +:: Copy venv[w]launcher scripts to venv\srcipts\nt +:: See https://github.com/python/cpython/blob/b4a316087c32d83e375087fd35fc511bc430ee8b/Lib/venv/__init__.py#L334-L376 +if exist %SRC_DIR%\PCbuild\%HOST_DIR%\venvlauncher%THREAD%%_D%.exe ( + @rem We did copy pythonw.exe until 3.12 but starting with 3.13 we seem to need the latter. Should we omit the first? + copy /Y %SRC_DIR%\PCbuild\%HOST_DIR%\venvlauncher%THREAD%%_D%.exe %PREFIX%\Lib\venv\scripts\nt\python.exe + copy /Y %SRC_DIR%\PCbuild\%HOST_DIR%\venvlauncher%THREAD%%_D%.exe %PREFIX%\Lib\venv\scripts\nt\venvlauncher%THREAD%%_D%.exe +) else ( + echo "WARNING :: %SRC_DIR%\PCbuild\%HOST_DIR%\venvlauncher%THREAD%%_D%.exe does not exist" +) + +if exist %SRC_DIR%\PCbuild\%HOST_DIR%\venvwlauncher%THREAD%%_D%.exe ( + @rem We did copy pythonw.exe until 3.12 but starting with 3.13 we seem to need the latter. Should we omit the first? + copy /Y %SRC_DIR%\PCbuild\%HOST_DIR%\venvwlauncher%THREAD%%_D%.exe %PREFIX%\Lib\venv\scripts\nt\pythonw.exe + copy /Y %SRC_DIR%\PCbuild\%HOST_DIR%\venvwlauncher%THREAD%%_D%.exe %PREFIX%\Lib\venv\scripts\nt\venvwlauncher%THREAD%%_D%.exe +) else ( + echo "WARNING :: %SRC_DIR%\PCbuild\%HOST_DIR%\venvwlauncher%THREAD%%_D%.exe does not exist" +) + +:: Remove test data to save space. +:: Though keep `support` as some things use that. +mkdir %PREFIX%\Lib\test_keep +if errorlevel 1 exit 1 +move %PREFIX%\Lib\test\__init__.py %PREFIX%\Lib\test_keep\ +if errorlevel 1 exit 1 +move %PREFIX%\Lib\test\support %PREFIX%\Lib\test_keep\ +if errorlevel 1 exit 1 +rd /s /q %PREFIX%\Lib\test +if errorlevel 1 exit 1 +move %PREFIX%\Lib\test_keep %PREFIX%\Lib\test +if errorlevel 1 exit 1 + +:: We need our Python to be found! +if "%_D%" neq "" copy %PREFIX%\python%_D%.exe %PREFIX%\python.exe +if "%EXE_T%" neq "" copy %PREFIX%\python%EXE_T%.exe %PREFIX%\python.exe + +if "%CONDA_BUILD_CROSS_COMPILATION%" == "1" ( + set "PYTHON=%SRC_DIR%\PCbuild\%BUILD_DIR%\\python%EXE_T%%_D%.exe" +) else ( + set "PYTHON=%PREFIX%\python.exe" +) +:: bytecode compile the standard library +%PYTHON% -Wi %PREFIX%\Lib\compileall.py -f -q -x "bad_coding|badsyntax|py2_" %PREFIX%\Lib +if errorlevel 1 exit 1 + +:: Ensure that scripts are generated +:: https://github.com/conda-forge/python-feedstock/issues/384 +%PYTHON% %RECIPE_DIR%\fix_staged_scripts.py +if errorlevel 1 exit 1 + +if NOT "%CONDA_BUILD_CROSS_COMPILATION%" == "1" ( + REM Some quick tests for common failures + echo "Testing print() does not print: Hello" + %PREFIX%\python.exe -c "print()" 2>&1 | findstr /r /c:"Hello" + if %errorlevel% neq 1 exit /b 1 + + echo "Testing print('Hello') prints: Hello" + %PREFIX%\python.exe -c "print('Hello')" 2>&1 | findstr /r /c:"Hello" + if %errorlevel% neq 0 exit /b 1 + + echo "Testing import of os (no DLL needed) does not print: The specified module could not be found" + %PREFIX%\python.exe -v -c "import os" 2>&1 + %PREFIX%\python.exe -v -c "import os" 2>&1 | findstr /r /c:"The specified module could not be found" + if %errorlevel% neq 1 exit /b 1 + + echo "Testing import of _sqlite3 (DLL located via PATH needed) does not print: The specified module could not be found" + %PREFIX%\python.exe -v -c "import _sqlite3" 2>&1 + %PREFIX%\python.exe -v -c "import _sqlite3" 2>&1 | findstr /r /c:"The specified module could not be found" + if %errorlevel% neq 1 exit /b 1 +) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/conda_build_config.yaml b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/conda_build_config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b3b99e7b72ccd815224cd962155d2183347d8b5c --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/conda_build_config.yaml @@ -0,0 +1,48 @@ +CI: azure +CONDA_BUILD_SKIP_TESTS: '0' +build_type: release +bzip2: '1' +c_compiler: vs2022 +c_stdlib: vs +channel_sources: conda-forge/label/python_rc,conda-forge +channel_targets: conda-forge main +cpu_optimization_target: nocona +cran_mirror: https://cran.r-project.org +cxx_compiler: vs2022 +expat: '2' +extend_keys: +- ignore_build_only_deps +- ignore_version +- extend_keys +- pin_run_as_build +fortran_compiler: gfortran +freethreading: 'no' +ignore_build_only_deps: +- python +- numpy +is_python_min: 'no' +libffi: '3.5' +liblzma_devel: '5' +libsqlite: '3' +lua: '5' +numpy: '1.16' +openssl: '3.5' +perl: 5.26.2 +pin_run_as_build: + python: + max_pin: x.x + min_pin: x.x + r-base: + max_pin: x.x + min_pin: x.x +python: '3.14' +python_impl: cpython +r_base: '3.4' +target_platform: win-64 +tk: '8.6' +vc: '14' +zip_keys: +- - build_type + - channel_targets +zlib: '1' +zstd: '1.5' diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/meta.yaml b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/meta.yaml new file mode 100644 index 0000000000000000000000000000000000000000..81a7410cadd1d348adc75357f68f895b3bf669a4 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/meta.yaml @@ -0,0 +1,200 @@ +# This file created by conda-build 26.3.0 +# ------------------------------------------------ + +package: + name: python + version: 3.14.4 +source: + - url: https://www.python.org/ftp/python/3.14.4/Python-3.14.4.tar.xz + sha256: d923c51303e38e249136fc1bdf3568d56ecb03214efdef48516176d3d7faaef8 + patches: + - patches/0001-Win32-Change-FD_SETSIZE-from-512-to-2048.patch + - patches/0002-Win32-Do-not-download-externals.patch + - patches/0003-Fix-find_library-so-that-it-looks-in-sys.prefix-lib-.patch + - patches/0004-Disable-registry-lookup-unless-CONDA_PY_ALLOW_REG_PA.patch + - patches/0005-Unvendor-openssl.patch + - patches/0006-Unvendor-sqlite3.patch + - patches/0007-Add-CondaEcosystemModifyDllSearchPath.patch + - patches/0008-Doing-d1trimfile.patch + - patches/0009-cross-compile-darwin.patch + - patches/0010-Fix-TZPATH-on-windows.patch + - patches/0011-Make-dyld-search-work-with-SYSTEM_VERSION_COMPAT-1.patch + - patches/0012-Unvendor-bzip2.patch + - patches/0013-Unvendor-libffi.patch + - patches/0014-Unvendor-tcltk.patch + - patches/0015-unvendor-xz.patch + - patches/0016-unvendor-zlib.patch + - patches/0017-Do-not-pass-g-to-GCC-when-not-Py_DEBUG.patch + - patches/0018-Unvendor-expat.patch + - patches/0019-Remove-unused-readelf.patch + - patches/0020-Don-t-checksharedmods-if-cross-compiling.patch + - patches/0021-Override-configure-LIBFFI.patch + - patches/0022-Unvendor-libmpdec.patch + - patches/0023-Brand-conda-forge.patch + - patches/0024-Do-not-define-pid_t-as-it-might-conflict-with-the-ac.patch + - patches/0025-Unvendor-zstd.patch +build: + number: 100 + activate_in_script: true + no_link: + - DLLs/_ctypes.pyd + ignore_run_exports_from: null + detect_binary_files_with_prefix: true + skip_compile_pyc: null + string: h4b44e0e_100_cp314 + python_site_packages_path: Lib/site-packages + run_exports: + noarch: + - python + weak: + - python_abi 3.14.* *_cp314 + track_features: null + script_env: + - PY_FREETHREADING=no + - PY_INTERP_DEBUG=no + missing_dso_whitelist: + - '**/MSVCR71.dll' + - '**/MSVCR80.dll' + - '**/api-ms-win-core-path-l1-1-0.dll' +requirements: + build: + - clang 19.1.7 default_hac490eb_8 + - clang-19 19.1.7 default_hac490eb_8 + - libiconv 1.18 hc1393d2_2 + - libllvm19 19.1.7 h830ff33_2 + - liblzma 5.8.2 hfd05255_0 + - libxml2 2.15.2 h5d26750_0 + - libxml2-16 2.15.2 h692994f_0 + - libzlib 1.3.2 hfd05255_2 + - llvm-tools 19.1.7 h752b59f_2 + - ucrt 10.0.26100.0 h57928b3_0 + - vc 14.3 h41ae7f8_34 + - vc14_runtime 14.44.35208 h818238b_34 + - vcomp14 14.44.35208 h818238b_34 + - vs2022_win-64 19.44.35207 ha74f236_34 + - vs_win-64 2022.14 ha74f236_34 + - vswhere 3.1.7 h40126e0_1 + - zstd 1.5.7 h534d264_6 + host: + - bzip2 1.0.8 h0ad9c76_9 + - ca-certificates 2026.2.25 h4c7d964_0 + - expat 2.7.5 hac47afa_0 + - libexpat 2.7.5 hac47afa_0 + - libffi 3.5.2 h3d046cb_0 + - liblzma 5.8.2 hfd05255_0 + - liblzma-devel 5.8.2 hfd05255_0 + - libmpdec 4.0.0 hfd05255_1 + - libmpdec-devel 4.0.0 h57928b3_1 + - libsqlite 3.52.0 hf5d6505_0 + - libzlib 1.3.2 hfd05255_2 + - openssl 3.5.6 hf411b9b_0 + - tk 8.6.13 h6ed50ae_3 + - ucrt 10.0.26100.0 h57928b3_0 + - vc 14.3 h41ae7f8_34 + - vc14_runtime 14.44.35208 h818238b_34 + - vcomp14 14.44.35208 h818238b_34 + - zlib 1.3.2 hfd05255_2 + - zstd 1.5.7 h534d264_6 + run: + - bzip2 >=1.0.8,<2.0a0 + - libexpat >=2.7.5,<3.0a0 + - libffi >=3.5.2,<3.6.0a0 + - liblzma >=5.8.2,<6.0a0 + - libmpdec >=4.0.0,<5.0a0 + - libsqlite >=3.52.0,<4.0a0 + - libzlib >=1.3.2,<2.0a0 + - openssl >=3.5.6,<4.0a0 + - python_abi 3.14.* *_cp314 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - zstd >=1.5.7,<1.6.0a0 +test: + downstreams: + - cython + - setuptools + requires: + - cmake + - ninja + - ripgrep + - vs2022_win-64 + - vs_win-64 + files: + - run_test.py + - tests/cmake/* + - tests/cython/* + - tests/prefix-replacement/* + commands: + - echo on + - set + - python -V + - pydoc -h + - set "PIP_NO_BUILD_ISOLATION=False" + - set "PIP_NO_DEPENDENCIES=True" + - set "PIP_IGNORE_INSTALLED=True" + - set "PIP_NO_INDEX=True" + - set "PIP_CACHE_DIR=%CONDA_PREFIX%/pip_cache" + - set "TEMP=%CONDA_PREFIX%/tmp" + - mkdir "%TEMP%" + - python -Im ensurepip --upgrade --default-pip + - python -c "from zoneinfo import ZoneInfo; from datetime import datetime; dt + = datetime(2020, 10, 31, 12, tzinfo=ZoneInfo('America/Los_Angeles')); print(dt.tzname())" + - python -m venv test-venv + - test-venv\\Scripts\\python.exe -c "import ctypes" + - if not exist %PREFIX%\\libs\\python3.lib exit 1 + - if not exist %PREFIX%\\libs\\python314.lib exit 1 + - if exist %PREFIX%\\Scripts\\pydoc exit 1 + - if exist %PREFIX%\\Scripts\\idle exit 1 + - if not exist %PREFIX%\\Scripts\\pydoc-script.py exit 1 + - if not exist %PREFIX%\\Scripts\\idle-script.py exit 1 + - if not exist %PREFIX%\\Scripts\\idle.exe exit 1 + - if not exist %PREFIX%\\Scripts\\pydoc.exe exit 1 + - if not exist %PREFIX%\\include\\pyconfig.h exit 1 + - pushd tests + - pushd cmake + - cmake -GNinja -DPY_VER=3.14.4 --debug-find --trace --debug-output --debug-trycompile + . + - popd + - popd + - python run_test.py + - python -c "from ctypes import CFUNCTYPE; CFUNCTYPE(None)(id)" +about: + home: https://www.python.org/ + license: Python-2.0 + license_file: LICENSE + summary: General purpose programming language + description: "Python is a widely used high-level, general-purpose, interpreted,\ + \ dynamic\nprogramming language. Its design philosophy emphasizes code\nreadability,\ + \ and its syntax allows programmers to express concepts in\nfewer lines of code\ + \ than would be possible in languages such as C++ or\nJava. The language provides\ + \ constructs intended to enable clear programs\non both a small and large scale.\n\ + \nWe provide some meta packages for convenience.\nTo get a CPython flavour, use:\n\ + \n conda install cpython\n\nTo get the freethreading build (i.e. without the\ + \ Global Interpreter Lock - GIL):\n\n conda install python-freethreading\n\n\ + To get the default build (i.e. with the GIL):\n\n conda install python-gil\n\ + \nTo enable the use of the experimental JIT compiler in CPython:\n\n conda\ + \ install python-jit\n\nor set the environment variable PYTHON_JIT=1. Note that\ + \ the JIT support\nis available for x86_64 builds only.\n" + doc_url: https://www.python.org/doc/versions/ + doc_source_url: https://github.com/python/pythondotorg/blob/master/docs/source/index.rst + dev_url: https://docs.python.org/devguide/ +extra: + feedstock-name: python + recipe-maintainers: + - chrisburr + - isuruf + - jakirkham + - katietz + - mbargull + - msarahan + - ocefpaf + - pelson + - scopatz + - xhochy + final: true + copy_test_source_files: true + flow_run_id: azure_20260407.5.1 + remote_url: https://github.com/conda-forge/python-feedstock + sha: a7005d06fd1d03157a094ed247ed324e7924102d diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/LICENSE.txt b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..f6c152a191ca636ae911804d8abf3ae8e642c7d7 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/LICENSE.txt @@ -0,0 +1,13 @@ +BSD 3-clause license +Copyright (c) 2015-2017, conda-forge +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/build_base.bat b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/build_base.bat new file mode 100644 index 0000000000000000000000000000000000000000..7dd5ccfe8347cd210ff6cc5bf3f036f53a087a8d --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/build_base.bat @@ -0,0 +1,241 @@ +setlocal EnableDelayedExpansion +echo on + +:: Compile python, extensions and external libraries +if "%target_platform%"=="win-64" ( + set HOST_PLATFORM=x64 + set HOST_DIR=amd64 +) +if "%target_platform%"=="win-32" ( + set HOST_PLATFORM=Win32 + set HOST_DIR=win32 +) +if "%target_platform%"=="win-arm64" ( + set HOST_PLATFORM=ARM64 + set HOST_DIR=arm64 +) + +if "%build_platform%"=="win-64" ( + set BUILD_PLATFORM=x64 + set BUILD_DIR=amd64 +) +if "%build_platform%"=="win-32" ( + set BUILD_PLATFORM=Win32 + set BUILD_DIR=win32 +) +if "%build_platform%"=="win-arm64" ( + set BUILD_PLATFORM=ARM64 + set BUILD_DIR=arm64 +) + +for /F "tokens=1,2 delims=." %%i in ("%PKG_VERSION%") do ( + set "VERNODOTS=%%i%%j" +) + +for /F "tokens=1,2 delims=." %%i in ("%PKG_VERSION%") do ( + set "VER=%%i.%%j" +) + +:: Make sure the "python" value in conda_build_config.yaml is up to date. +for /F "tokens=1,2 delims=." %%i in ("%PKG_VERSION%") do ( + if NOT "%PY_VER%"=="%%i.%%j" exit 1 +) + +for /f "usebackq delims=" %%i in (`conda list -p %PREFIX% sqlite --no-show-channel-urls --json ^| findstr "version"`) do set SQLITE3_VERSION_LINE=%%i +for /f "tokens=2 delims==/ " %%i IN ('echo %SQLITE3_VERSION_LINE%') do (set SQLITE3_VERSION=%%~i) +echo SQLITE3_VERSION detected as %SQLITE3_VERSION% + +if "%PY_INTERP_DEBUG%"=="yes" ( + set CONFIG=-d + set _D=_d +) else ( + set CONFIG= + set _D= +) + +set PGO=--pgo +if "%DEBUG_C%"=="yes" ( + set PGO= +) +if "%CONDA_BUILD_CROSS_COMPILATION%" == "1" ( + set PGO= +) + +if "%PY_FREETHREADING%" == "yes" ( + set "FREETHREADING=--disable-gil" + set "THREAD=t" + set "EXE_T=%VER%t" +) else ( + set "FREETHREADING=--experimental-jit-off" + set "THREAD=" + set "EXE_T=" +) + +cd PCbuild + +setlocal EnableDelayedExpansion +if "%CONDA_BUILD_CROSS_COMPILATION%" == "1" ( + REM build for the build platform. LIBRARY_PREFIX is used by the patches + REM No PGO. No externals, i.e. remove building extension modules + REM we don't need. + set LIBRARY_PREFIX=%BUILD_PREFIX%\\Library + call build.bat %CONFIG% %FREETHREADING% -m -E -v -p %BUILD_PLATFORM% + if errorlevel 1 exit 1 +) +endlocal +:: Twice because: +:: error : importlib_zipimport.h updated. You will need to rebuild pythoncore to see the changes. +call build.bat %PGO% %CONFIG% %FREETHREADING% -m -e -v -p %HOST_PLATFORM% +call build.bat %PGO% %CONFIG% %FREETHREADING% -m -e -v -p %HOST_PLATFORM% +if errorlevel 1 exit 1 +cd .. + +:: Populate the root package directory +for %%x in (python%VERNODOTS%%THREAD%%_D%.dll python3%THREAD%%_D%.dll python%EXE_T%%_D%.exe pythonw%EXE_T%%_D%.exe) do ( + if exist %SRC_DIR%\PCbuild\%HOST_DIR%\%%x ( + copy /Y %SRC_DIR%\PCbuild\%HOST_DIR%\%%x %PREFIX% + ) else ( + echo "WARNING :: %SRC_DIR%\PCbuild\%HOST_DIR%\%%x does not exist" + ) +) + +for %%x in (python%THREAD%%_D%.pdb python%VERNODOTS%%THREAD%%_D%.pdb pythonw%THREAD%%_D%.pdb) do ( + if exist %SRC_DIR%\PCbuild\%HOST_DIR%\%%x ( + copy /Y %SRC_DIR%\PCbuild\%HOST_DIR%\%%x %PREFIX% + ) else ( + echo "WARNING :: %SRC_DIR%\PCbuild\%HOST_DIR%\%%x does not exist" + ) +) + +@echo on + +copy %SRC_DIR%\LICENSE %PREFIX%\LICENSE_PYTHON.txt +if errorlevel 1 exit 1 + +:: Populate the DLLs directory +mkdir %PREFIX%\DLLs +xcopy /s /y %SRC_DIR%\PCBuild\%HOST_DIR%\*.pyd %PREFIX%\DLLs\ +if errorlevel 1 exit 1 + +copy /Y %SRC_DIR%\PC\icons\py.ico %PREFIX%\DLLs\ +if errorlevel 1 exit 1 +copy /Y %SRC_DIR%\PC\icons\pyc.ico %PREFIX%\DLLs\ +if errorlevel 1 exit 1 + +:: Populate the Tools directory +mkdir %PREFIX%\Tools +xcopy /s /y /i %SRC_DIR%\Tools\i18n %PREFIX%\Tools\i18n +if errorlevel 1 exit 1 +xcopy /s /y /i %SRC_DIR%\Tools\scripts %PREFIX%\Tools\scripts +if errorlevel 1 exit 1 + +del %PREFIX%\Tools\scripts\README +if errorlevel 1 exit 1 +del %PREFIX%\Tools\scripts\idle3 +if errorlevel 1 exit 1 + +move /y %PREFIX%\Tools\scripts\pydoc3 %PREFIX%\Tools\scripts\pydoc3.py +if errorlevel 1 exit 1 + +:: Populate the include directory +xcopy /s /y %SRC_DIR%\Include %PREFIX%\include\ +if errorlevel 1 exit 1 + +:: Copy generated pyconfig.h +copy /Y %SRC_DIR%\PC\pyconfig.h %PREFIX%\include\ +if errorlevel 1 exit 1 + +:: Populate the Scripts directory +if not exist %SCRIPTS% (mkdir %SCRIPTS%) +if errorlevel 1 exit 1 + +for %%x in (idle pydoc) do ( + copy /Y %SRC_DIR%\Tools\scripts\%%x3 %SCRIPTS%\%%x + if errorlevel 1 exit 1 +) + +:: Populate the libs directory +if not exist %PREFIX%\libs mkdir %PREFIX%\libs +dir %SRC_DIR%\PCbuild\%HOST_DIR%\ +if exist %SRC_DIR%\PCbuild\%HOST_DIR%\python%VERNODOTS%%THREAD%%_D%.lib copy /Y %SRC_DIR%\PCbuild\%HOST_DIR%\python%VERNODOTS%%THREAD%%_D%.lib %PREFIX%\libs\ +if errorlevel 1 exit 1 +if exist %SRC_DIR%\PCbuild\%HOST_DIR%\python3%THREAD%%_D%.lib copy /Y %SRC_DIR%\PCbuild\%HOST_DIR%\python3%THREAD%%_D%.lib %PREFIX%\libs\ +if errorlevel 1 exit 1 +if exist %SRC_DIR%\PCbuild\%HOST_DIR%\_tkinter%THREAD%%_D%.lib copy /Y %SRC_DIR%\PCbuild\%HOST_DIR%\_tkinter%THREAD%%_D%.lib %PREFIX%\libs\ +if errorlevel 1 exit 1 + + +:: Populate the Lib directory +del %PREFIX%\libs\libpython*.a +xcopy /s /y %SRC_DIR%\Lib %PREFIX%\Lib\ +if errorlevel 1 exit 1 + +:: Copy venv[w]launcher scripts to venv\srcipts\nt +:: See https://github.com/python/cpython/blob/b4a316087c32d83e375087fd35fc511bc430ee8b/Lib/venv/__init__.py#L334-L376 +if exist %SRC_DIR%\PCbuild\%HOST_DIR%\venvlauncher%THREAD%%_D%.exe ( + @rem We did copy pythonw.exe until 3.12 but starting with 3.13 we seem to need the latter. Should we omit the first? + copy /Y %SRC_DIR%\PCbuild\%HOST_DIR%\venvlauncher%THREAD%%_D%.exe %PREFIX%\Lib\venv\scripts\nt\python.exe + copy /Y %SRC_DIR%\PCbuild\%HOST_DIR%\venvlauncher%THREAD%%_D%.exe %PREFIX%\Lib\venv\scripts\nt\venvlauncher%THREAD%%_D%.exe +) else ( + echo "WARNING :: %SRC_DIR%\PCbuild\%HOST_DIR%\venvlauncher%THREAD%%_D%.exe does not exist" +) + +if exist %SRC_DIR%\PCbuild\%HOST_DIR%\venvwlauncher%THREAD%%_D%.exe ( + @rem We did copy pythonw.exe until 3.12 but starting with 3.13 we seem to need the latter. Should we omit the first? + copy /Y %SRC_DIR%\PCbuild\%HOST_DIR%\venvwlauncher%THREAD%%_D%.exe %PREFIX%\Lib\venv\scripts\nt\pythonw.exe + copy /Y %SRC_DIR%\PCbuild\%HOST_DIR%\venvwlauncher%THREAD%%_D%.exe %PREFIX%\Lib\venv\scripts\nt\venvwlauncher%THREAD%%_D%.exe +) else ( + echo "WARNING :: %SRC_DIR%\PCbuild\%HOST_DIR%\venvwlauncher%THREAD%%_D%.exe does not exist" +) + +:: Remove test data to save space. +:: Though keep `support` as some things use that. +mkdir %PREFIX%\Lib\test_keep +if errorlevel 1 exit 1 +move %PREFIX%\Lib\test\__init__.py %PREFIX%\Lib\test_keep\ +if errorlevel 1 exit 1 +move %PREFIX%\Lib\test\support %PREFIX%\Lib\test_keep\ +if errorlevel 1 exit 1 +rd /s /q %PREFIX%\Lib\test +if errorlevel 1 exit 1 +move %PREFIX%\Lib\test_keep %PREFIX%\Lib\test +if errorlevel 1 exit 1 + +:: We need our Python to be found! +if "%_D%" neq "" copy %PREFIX%\python%_D%.exe %PREFIX%\python.exe +if "%EXE_T%" neq "" copy %PREFIX%\python%EXE_T%.exe %PREFIX%\python.exe + +if "%CONDA_BUILD_CROSS_COMPILATION%" == "1" ( + set "PYTHON=%SRC_DIR%\PCbuild\%BUILD_DIR%\\python%EXE_T%%_D%.exe" +) else ( + set "PYTHON=%PREFIX%\python.exe" +) +:: bytecode compile the standard library +%PYTHON% -Wi %PREFIX%\Lib\compileall.py -f -q -x "bad_coding|badsyntax|py2_" %PREFIX%\Lib +if errorlevel 1 exit 1 + +:: Ensure that scripts are generated +:: https://github.com/conda-forge/python-feedstock/issues/384 +%PYTHON% %RECIPE_DIR%\fix_staged_scripts.py +if errorlevel 1 exit 1 + +if NOT "%CONDA_BUILD_CROSS_COMPILATION%" == "1" ( + REM Some quick tests for common failures + echo "Testing print() does not print: Hello" + %PREFIX%\python.exe -c "print()" 2>&1 | findstr /r /c:"Hello" + if %errorlevel% neq 1 exit /b 1 + + echo "Testing print('Hello') prints: Hello" + %PREFIX%\python.exe -c "print('Hello')" 2>&1 | findstr /r /c:"Hello" + if %errorlevel% neq 0 exit /b 1 + + echo "Testing import of os (no DLL needed) does not print: The specified module could not be found" + %PREFIX%\python.exe -v -c "import os" 2>&1 + %PREFIX%\python.exe -v -c "import os" 2>&1 | findstr /r /c:"The specified module could not be found" + if %errorlevel% neq 1 exit /b 1 + + echo "Testing import of _sqlite3 (DLL located via PATH needed) does not print: The specified module could not be found" + %PREFIX%\python.exe -v -c "import _sqlite3" 2>&1 + %PREFIX%\python.exe -v -c "import _sqlite3" 2>&1 | findstr /r /c:"The specified module could not be found" + if %errorlevel% neq 1 exit /b 1 +) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/build_base.sh b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/build_base.sh new file mode 100644 index 0000000000000000000000000000000000000000..755075d50dcfdea87cfcbb08fad387dbb5c8b118 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/build_base.sh @@ -0,0 +1,548 @@ +#!/bin/bash +set -ex + +# Get an updated config.sub and config.guess +cp $BUILD_PREFIX/share/libtool/build-aux/config.* . + +if [[ ! -d ${SRC_DIR}/python-bin ]]; then + # Need an up-to-date python to build python. + # python 3.10 in miniforge is too old. + CONDA_SUBDIR=$build_platform conda create -p ${SRC_DIR}/python-bin python -c conda-forge --override-channels --yes --quiet + export PATH=${SRC_DIR}/python-bin/bin:${PATH} +fi + +# The LTO/PGO information was sourced from @pitrou and the Debian rules file in: +# http://http.debian.net/debian/pool/main/p/python3.6/python3.6_3.6.2-2.debian.tar.xz +# https://packages.debian.org/source/sid/python3.6 +# or: +# http://bazaar.launchpad.net/~doko/python/pkg3.5-debian/view/head:/rules#L255 +# .. but upstream regrtest.py now has --pgo (since >= 3.6) and skips tests that are: +# "not helpful for PGO". + +VERFULL=${PKG_VERSION} +VER=${PKG_VERSION%.*} +VERNODOTS=${VER//./} +TCLTK_VER=${tk} +# Disables some PGO/LTO +QUICK_BUILD=no + +_buildd_static=build-static +_buildd_shared=build-shared +_ENABLE_SHARED=--enable-shared +# We *still* build a shared lib here for non-static embedded use cases +_DISABLE_SHARED=--disable-shared + +# For debugging builds, set this to no to disable profile-guided optimization +if [[ ${PY_INTERP_DEBUG} == yes ]]; then + _OPTIMIZED=no +else + _OPTIMIZED=yes +fi + +if [[ ${PY_INTERP_DEBUG} == yes ]]; then + # check that the rerendering is correct + if [[ "$CI" != "" && "$channel_targets" == "conda-forge main" ]]; then + exit 1 + fi +fi + +declare -a _dbg_opts +if [[ ${PY_INTERP_DEBUG} == yes ]]; then + # This Python will not be usable with non-debug Python modules. + _dbg_opts+=(--with-pydebug) + DBG=d +else + DBG= +fi + +if [[ ${PY_FREETHREADING} == yes ]]; then + # This Python will not be usable with non-free threading Python modules. + THREAD=t +else + THREAD= +fi + +ABIFLAGS=${DBG}${THREAD} +VERABI=${VER}${THREAD}${DBG} +VERABI_NO_DBG=${VER}${THREAD} + +# Make sure the "python" value in conda_build_config.yaml is up to date. +test "${PY_VER}" = "${VER}" + +# This is the mechanism by which we fall back to default gcc, but having it defined here +# would probably break the build by using incorrect settings and/or importing files that +# do not yet exist. +unset _PYTHON_SYSCONFIGDATA_NAME +unset _CONDA_PYTHON_SYSCONFIGDATA_NAME + +# Prevent lib/python${VERABI_NO_DBG}/_sysconfigdata_*.py from ending up with full paths to these things +# in _build_env because _build_env will not get found during prefix replacement, only _h_env_placeh ... +AR=$(basename "${AR}") + +# CC must contain the string 'gcc' or else distutils thinks it is on macOS and uses '-R' to set rpaths. +if [[ ${target_platform} == osx-* ]]; then + CC=$(basename "${CC}") +else + CC=$(basename "${GCC}") +fi +CXX=$(basename "${CXX}") +RANLIB=$(basename "${RANLIB}") +READELF=$(basename "${READELF}") + +if [[ ${HOST} =~ .*darwin.* ]] && [[ -n ${CONDA_BUILD_SYSROOT} ]]; then + # Python's setup.py will figure out that this is a macOS sysroot. + CFLAGS="-isysroot ${CONDA_BUILD_SYSROOT} "${CFLAGS} + LDFLAGS="-isysroot ${CONDA_BUILD_SYSROOT} "${LDFLAGS} + CPPFLAGS="-isysroot ${CONDA_BUILD_SYSROOT} "${CPPFLAGS} +fi + +# Debian uses -O3 then resets it at the end to -O2 in _sysconfigdata.py +if [[ ${_OPTIMIZED} = yes ]]; then + CPPFLAGS=$(echo "${CPPFLAGS}" | sed "s/-O2/-O3/g") + CFLAGS=$(echo "${CFLAGS}" | sed "s/-O2/-O3/g") + CXXFLAGS=$(echo "${CXXFLAGS}" | sed "s/-O2/-O3/g") +fi + +if [[ ${PY_INTERP_DEBUG} == yes ]]; then + CPPFLAGS=$(echo "${CPPFLAGS}" | sed "s/-O2/-O0/g") + CFLAGS=$(echo "${CFLAGS}" | sed "s/-O2/-O0/g") + CXXFLAGS=$(echo "${CXXFLAGS}" | sed "s/-O2/-O0/g") +fi + +if [[ "$target_platform" == linux-* ]]; then + cp ${PREFIX}/include/uuid/uuid.h ${PREFIX}/include/uuid.h +fi + +declare -a LTO_CFLAGS=() + +# Following is needed for building extensions like zlib +CPPFLAGS=${CPPFLAGS}" -I${PREFIX}/include" + +re='^(.*)(-I[^ ]*)(.*)$' +if [[ ${CFLAGS} =~ $re ]]; then + CFLAGS="${BASH_REMATCH[1]}${BASH_REMATCH[3]}" +fi + +# Force rebuild to avoid: +# ../work/Modules/unicodename_db.h:24118:30: note: (near initialization for 'code_hash') +# ../work/Modules/unicodename_db.h:24118:33: warning: excess elements in scalar initializer +# 0, 0, 12018, 0, 0, 0, 0, 0, 4422, 4708, 3799, 119358, 119357, 0, 120510, +# ^~~~ +# This should have been fixed by https://github.com/python/cpython/commit/7c69c1c0fba8c1c8ff3969bce4c1135736a4cc58 +# .. but that appears incomplete. In particular, the generated files contain: +# /* this file was generated by Tools/unicode/makeunicodedata.py 3.2 */ +# .. yet the PR updated to version of makeunicodedata.py to 3.3 +# rm -f Modules/unicodedata_db.h Modules/unicodename_db.h +# ${SYS_PYTHON} ${SRC_DIR}/Tools/unicode/makeunicodedata.py +# .. instead we revert this commit for now. + +export CPPFLAGS CFLAGS CXXFLAGS LDFLAGS + +declare -a _common_configure_args + +if [[ "${CONDA_BUILD_CROSS_COMPILATION}" == "1" ]]; then + # Build the exact same Python for the build machine. It would be nice (and might be + # possible already?) to be able to make this just an 'exact' pinned build dependency + # of a split-package? + BUILD_PYTHON_PREFIX=${PWD}/build-python-install + mkdir build-python-build + pushd build-python-build + (export CC=${CC_FOR_BUILD} \ + CXX=${CXX_FOR_BUILD} \ + CPP="${CC_FOR_BUILD} -E" \ + CFLAGS="-O2 -I${BUILD_PREFIX}/include" \ + CPPFLAGS="-O2 -I${BUILD_PREFIX}/include" \ + LDFLAGS=${LDFLAGS//${PREFIX}/${BUILD_PREFIX}} \ + PKG_CONFIG_PATH=${BUILD_PREFIX}/lib/pkgconfig \ + AR="$(${CC_FOR_BUILD} --print-prog-name=ar)" \ + RANLIB="$(${CC_FOR_BUILD} --print-prog-name=ranlib)" \ + LD="$(${CC_FOR_BUILD} --print-prog-name=ld)" && \ + ${SRC_DIR}/configure --build=${BUILD} \ + --host=${BUILD} \ + --prefix=${BUILD_PYTHON_PREFIX} \ + --with-ensurepip=no \ + --with-tzpath=${PREFIX}/share/zoneinfo \ + --with-platlibdir=lib && \ + make -j${CPU_COUNT} && \ + make install) + export PATH=${BUILD_PYTHON_PREFIX}/bin:${PATH} + ln -s ${BUILD_PYTHON_PREFIX}/bin/python${VER} ${BUILD_PYTHON_PREFIX}/bin/python + popd + echo "ac_cv_file__dev_ptmx=yes" > config.site + echo "ac_cv_file__dev_ptc=no" >> config.site + echo "ac_cv_pthread=yes" >> config.site + echo "ac_cv_little_endian_double=yes" >> config.site + if [[ "${target_platform}" == "osx-arm64" || "${target_platform}" == "linux-ppc64le" || "${target_platform}" == "linux-aarch64" ]]; then + echo "ac_cv_aligned_required=no" >> config.site + echo "ac_cv_pthread_is_default=yes" >> config.site + echo "ac_cv_working_tzset=yes" >> config.site + echo "ac_cv_pthread_system_supported=yes" >> config.site + else + echo "unknown cross compiling platform" + exit 1 + fi + export CONFIG_SITE=${PWD}/config.site + # This is needed for libffi: + export PKG_CONFIG_PATH=${PREFIX}/lib/pkgconfig + _common_configure_args+=(--with-build-python=${BUILD_PYTHON_PREFIX}/bin/python) +fi + +# This causes setup.py to query the sysroot directories from the compiler, something which +# IMHO should be done by default anyway with a flag to disable it to workaround broken ones. +# Technically, setting _PYTHON_HOST_PLATFORM causes setup.py to consider it cross_compiling +if [[ -n ${HOST} ]]; then + if [[ ${HOST} =~ .*darwin.* ]]; then + # Even if BUILD is .*darwin.* you get better isolation by cross_compiling (no /usr/local) + IFS='-' read -r host_arch host_os host_kernel <<<"${HOST}" + export _PYTHON_HOST_PLATFORM=darwin-${host_arch} + else + IFS='-' read -r host_arch host_vendor host_os host_libc <<<"${HOST}" + export _PYTHON_HOST_PLATFORM=${host_os}-${host_arch} + fi +fi + +if [[ ${target_platform} == osx-64 ]]; then + export MACHDEP=darwin + export ac_sys_system=Darwin + export ac_sys_release=13.4.0 + export MACOSX_DEFAULT_ARCH=x86_64 + # TODO: check with LLVM 12 if the following hack is needed. + # https://reviews.llvm.org/D76461 may have fixed the need for the following hack. + echo '#!/bin/bash' > $BUILD_PREFIX/bin/$HOST-llvm-ar + echo "$BUILD_PREFIX/bin/llvm-ar --format=darwin" '"$@"' >> $BUILD_PREFIX/bin/$HOST-llvm-ar + chmod +x $BUILD_PREFIX/bin/$HOST-llvm-ar + export ARCHFLAGS="-arch x86_64" +elif [[ ${target_platform} == osx-arm64 ]]; then + export MACHDEP=darwin + export ac_sys_system=Darwin + export ac_sys_release=20.0.0 + export MACOSX_DEFAULT_ARCH=arm64 + echo '#!/bin/bash' > $BUILD_PREFIX/bin/$HOST-llvm-ar + echo "$BUILD_PREFIX/bin/llvm-ar --format=darwin" '"$@"' >> $BUILD_PREFIX/bin/$HOST-llvm-ar + chmod +x $BUILD_PREFIX/bin/$HOST-llvm-ar + export ARCHFLAGS="-arch arm64" + export CFLAGS="$CFLAGS $ARCHFLAGS" +elif [[ ${target_platform} == linux-* ]]; then + export MACHDEP=linux + export ac_sys_system=Linux + export ac_sys_release= +fi + +# Not used at present but we should run 'make test' and finish up TESTOPTS (see debians rules). +declare -a TEST_EXCLUDES +TEST_EXCLUDES+=(test_ensurepip test_venv) +TEST_EXCLUDES+=(test_tcl test_codecmaps_cn test_codecmaps_hk + test_codecmaps_jp test_codecmaps_kr test_codecmaps_tw + test_normalization test_ossaudiodev test_socket) +if [[ ! -f /dev/dsp ]]; then + TEST_EXCLUDES+=(test_linuxaudiodev test_ossaudiodev) +fi +# hangs on Aarch64, see LP: #1264354 +if [[ ${CC} =~ .*-aarch64.* ]]; then + TEST_EXCLUDES+=(test_faulthandler) +fi +if [[ ${CC} =~ .*-arm.* ]]; then + TEST_EXCLUDES+=(test_ctypes) + TEST_EXCLUDES+=(test_compiler) +fi + +_common_configure_args+=(--prefix=${PREFIX}) +_common_configure_args+=(--build=${BUILD}) +_common_configure_args+=(--host=${HOST}) +_common_configure_args+=(--enable-ipv6) +_common_configure_args+=(--with-ensurepip=no) +_common_configure_args+=(--with-tzpath=${PREFIX}/share/zoneinfo) +_common_configure_args+=(--with-computed-gotos) +_common_configure_args+=(--with-system-expat) +_common_configure_args+=(--enable-loadable-sqlite-extensions) +_common_configure_args+=(--with-tcltk-includes="-I${PREFIX}/include") +_common_configure_args+=("--with-tcltk-libs=-L${PREFIX}/lib -ltcl8.6 -ltk8.6") +_common_configure_args+=(--with-platlibdir=lib) + +if [[ "${PY_INTERP_DEBUG}" == "yes" || "${target_platform}" != *"-64" || ${PY_FREETHREADING} == yes ]]; then + _common_configure_args+=(--enable-experimental-jit=no) +else + _common_configure_args+=(--enable-experimental-jit=yes-off) +fi + +if [[ "${target_platform}" == osx-* ]]; then + # This should only be used with clang 20.1+ + _common_configure_args+=(--with-tail-call-interp) +fi + +if [[ ${PY_FREETHREADING} == yes ]]; then + _common_configure_args+=(--disable-gil) +fi + +# Add more optimization flags for the static Python interpreter: +declare -a PROFILE_TASK=() +if [[ ${_OPTIMIZED} == yes ]]; then + _common_configure_args+=(--with-lto=full) + if [[ "$CONDA_BUILD_CROSS_COMPILATION" != "1" ]]; then + _common_configure_args+=(--enable-optimizations) + _MAKE_TARGET=profile-opt + # To speed up build times during testing (1): + if [[ ${QUICK_BUILD} == yes ]]; then + # TODO :: It seems this is just profiling everything, on Windows, only 40 odd tests are + # run while on Unix, all 400+ are run, making this slower and less well curated + _PROFILE_TASK+=(PROFILE_TASK="-m test --pgo") + else + # From talking to Steve Dower, who implemented pgo/pgo-extended, it is really not worth + # it to run pgo-extended (which runs the whole test-suite). The --pgo set of tests are + # curated specifically to be useful/appropriate for pgo instrumentation. + # _PROFILE_TASK+=(PROFILE_TASK="-m test --pgo-extended") + _PROFILE_TASK+=(PROFILE_TASK="-m test --pgo") + fi + fi + if [[ ${CC} =~ .*gcc.* ]]; then + LTO_CFLAGS+=(-fuse-linker-plugin) + LTO_CFLAGS+=(-ffat-lto-objects) + # -flto must come after -flto-partition due to the replacement code + # TODO :: Replace the replacement code using conda-build's in-build regex replacement. + LTO_CFLAGS+=(-flto-partition=none) + LTO_CFLAGS+=(-flto) + else + # TODO :: Check if -flto=thin gives better results. It is about faster + # compilation rather than faster execution so probably not: + # http://clang.llvm.org/docs/ThinLTO.html + # http://blog.llvm.org/2016/06/thinlto-scalable-and-incremental-lto.html + LTO_CFLAGS+=(-flto) + # -flto breaks the check to determine whether float word ordering is bigendian + # see: + # https://bugs.python.org/issue28015 + # https://bugs.python.org/issue38527 + # manually specify this setting + export ax_cv_c_float_words_bigendian=no + fi + export CFLAGS="${CFLAGS} ${LTO_CFLAGS[@]}" +else + _MAKE_TARGET= +fi + +mkdir -p ${_buildd_shared} +pushd ${_buildd_shared} + ${SRC_DIR}/configure "${_common_configure_args[@]}" \ + "${_dbg_opts[@]}" \ + --oldincludedir=${BUILD_PREFIX}/${HOST}/sysroot/usr/include \ + --enable-shared +popd + +mkdir -p ${_buildd_static} +pushd ${_buildd_static} + ${SRC_DIR}/configure "${_common_configure_args[@]}" \ + "${_dbg_opts[@]}" \ + -oldincludedir=${BUILD_PREFIX}/${HOST}/sysroot/usr/include \ + ${_DISABLE_SHARED} "${_PROFILE_TASK[@]}" +popd + +if [[ "${CI}" == "travis" ]]; then + # Travis has issues with long logs + make -j${CPU_COUNT} -C ${_buildd_static} \ + EXTRA_CFLAGS="${EXTRA_CFLAGS}" \ + ${_MAKE_TARGET} "${_PROFILE_TASK[@]}" 2>&1 >make-static.log +else + make -j${CPU_COUNT} -C ${_buildd_static} \ + EXTRA_CFLAGS="${EXTRA_CFLAGS}" \ + ${_MAKE_TARGET} "${_PROFILE_TASK[@]}" 2>&1 | tee make-static.log +fi +if rg "Failed to build these modules" make-static.log; then + echo "(static) :: Failed to build some modules, check the log" + exit 1 +fi + +if [[ "${CI}" == "travis" ]]; then + # Travis has issues with long logs + make -j${CPU_COUNT} -C ${_buildd_shared} \ + EXTRA_CFLAGS="${EXTRA_CFLAGS}" 2>&1 >make-shared.log +else + make -j${CPU_COUNT} -C ${_buildd_shared} \ + EXTRA_CFLAGS="${EXTRA_CFLAGS}" 2>&1 | tee make-shared.log +fi +if rg "Failed to build these modules" make-shared.log; then + echo "(shared) :: Failed to build some modules, check the log" + exit 1 +fi + +# build a static library with PIC objects and without LTO/PGO +make -j${CPU_COUNT} -C ${_buildd_shared} \ + EXTRA_CFLAGS="${EXTRA_CFLAGS}" \ + LIBRARY=libpython${VERABI_NO_DBG}-pic.a libpython${VERABI_NO_DBG}-pic.a + +make -C ${_buildd_static} install + +declare -a _FLAGS_REPLACE=() +if [[ ${_OPTIMIZED} == yes ]]; then + _FLAGS_REPLACE+=(-O3) + _FLAGS_REPLACE+=(-O2) + _FLAGS_REPLACE+=("-fprofile-use") + _FLAGS_REPLACE+=("") + _FLAGS_REPLACE+=("-fprofile-correction") + _FLAGS_REPLACE+=("") + _FLAGS_REPLACE+=("-L.") + _FLAGS_REPLACE+=("") + for _LTO_CFLAG in "${LTO_CFLAGS[@]}"; do + _FLAGS_REPLACE+=(${_LTO_CFLAG}) + _FLAGS_REPLACE+=("") + done +fi +# Install the shared library (for people who embed Python only, e.g. GDB). +# Linking module extensions to this on Linux is redundant (but harmless). +# Linking module extensions to this on Darwin is harmful (multiply defined symbols). +shopt -s extglob +cp -pf ${_buildd_shared}/libpython*${SHLIB_EXT}!(.lto) ${PREFIX}/lib/ +shopt -u extglob +if [[ ${target_platform} =~ .*linux.* ]]; then + ln -sf ${PREFIX}/lib/libpython${VERABI}${SHLIB_EXT}.1.0 ${PREFIX}/lib/libpython${VERABI}${SHLIB_EXT} +fi + +SYSCONFIG=$(find ${_buildd_static}/$(cat ${_buildd_static}/pybuilddir.txt) -name "_sysconfigdata*.py" -print0) +cat ${SYSCONFIG} | ${SYS_PYTHON} "${RECIPE_DIR}"/replace-word-pairs.py \ + "${_FLAGS_REPLACE[@]}" \ + > ${PREFIX}/lib/python${VERABI_NO_DBG}/$(basename ${SYSCONFIG}) +BUILD_DETAILS=${_buildd_shared}/$(cat ${_buildd_shared}/pybuilddir.txt)/build-details.json +cp ${BUILD_DETAILS} ${PREFIX}/lib/python${VERABI_NO_DBG}/ +MAKEFILE=$(find ${PREFIX}/lib/python${VERABI_NO_DBG}/ -path "*config-*/Makefile" -print0) +cp ${MAKEFILE} /tmp/Makefile-$$ +cat /tmp/Makefile-$$ | ${SYS_PYTHON} "${RECIPE_DIR}"/replace-word-pairs.py \ + "${_FLAGS_REPLACE[@]}" \ + > ${MAKEFILE} +# Check to see that our differences took. +# echo diff -urN ${SYSCONFIG} ${PREFIX}/lib/python${VERABI_NO_DBG}/$(basename ${SYSCONFIG}) +# diff -urN ${SYSCONFIG} ${PREFIX}/lib/python${VERABI_NO_DBG}/$(basename ${SYSCONFIG}) + +# Python installs python${VER}m and python${VER}, one as a hardlink to the other. conda-build breaks these +# by copying. Since the executable may be static it may be very large so change one to be a symlink +# of the other. In this case, python${VER}m will be the symlink. +if [[ -f ${PREFIX}/bin/python${VER}m ]]; then + rm -f ${PREFIX}/bin/python${VER}m + ln -s ${PREFIX}/bin/python${VER} ${PREFIX}/bin/python${VER}m +fi +ln -s ${PREFIX}/bin/python${VER} ${PREFIX}/bin/python +ln -s ${PREFIX}/bin/pydoc${VER} ${PREFIX}/bin/pydoc +# Workaround for https://github.com/conda/conda/issues/10969 +ln -s ${PREFIX}/bin/python${VER} ${PREFIX}/bin/python3.1 + +# Remove test data to save space +# Though keep `support` as some things use that. +# TODO :: Make a subpackage for this once we implement multi-level testing. +pushd ${PREFIX}/lib/python${VERABI_NO_DBG} + mkdir test_keep + mv test/__init__.py test/support test/test_support* test/test_script_helper* test_keep/ + rm -rf test */test + mv test_keep test +popd + +# Size reductions: +pushd ${PREFIX} + if [[ -f lib/libpython${VERABI}.a ]]; then + chmod +w lib/libpython${VERABI}.a + ${STRIP} -S lib/libpython${VERABI}.a + fi + CONFIG_LIBPYTHON=$(find lib/python${VERABI_NO_DBG}/config-${VERABI}* -name "libpython${VERABI}.a") + if [[ -f lib/libpython${VERABI}.a ]] && [[ -f ${CONFIG_LIBPYTHON} ]]; then + chmod +w ${CONFIG_LIBPYTHON} + rm ${CONFIG_LIBPYTHON} + fi +popd + +# Copy sysconfig that gets recorded to a non-default name +# using the new compilers with python will require setting _PYTHON_SYSCONFIGDATA_NAME +# to the name of this file (minus the .py extension) +pushd "${PREFIX}"/lib/python${VERABI_NO_DBG} + # On Python 3.5 _sysconfigdata.py was getting copied in here and compiled for some reason. + # This breaks our attempt to find the right one as recorded_name. + find lib-dynload -name "_sysconfigdata*.py*" -exec rm {} \; + recorded_name=$(find . -name "_sysconfigdata*.py") + our_compilers_name=_sysconfigdata_$(echo ${HOST} | sed -e 's/[.-]/_/g').py + # So we can see if anything has significantly diverged by looking in a built package. + cp ${recorded_name} ${recorded_name}.orig + cp ${recorded_name} sysconfigfile + # fdebug-prefix-map for python work dir is useless for extensions + sed -i.bak "s@-fdebug-prefix-map=$SRC_DIR=/usr/local/src/conda/python-$PKG_VERSION@@g" sysconfigfile + sed -i.bak "s@-fdebug-prefix-map=$PREFIX=/usr/local/src/conda-prefix@@g" sysconfigfile + # Append the conda-forge zoneinfo to the end + sed -i.bak "s@zoneinfo'@zoneinfo:$PREFIX/share/tzinfo'@g" sysconfigfile + # Remove osx sysroot as it depends on the build machine + # be sure CONDA_BUILD_SYSROOT has value, as other we will remove here instead spaces + if [[ "${target_platform}" == osx-* ]] && [[ -n ${CONDA_BUILD_SYSROOT} ]]; then + sed -i.bak "s@-isysroot @@g" sysconfigfile + sed -i.bak "s@$CONDA_BUILD_SYSROOT @@g" sysconfigfile + fi + # Remove unfilled config option + sed -i.bak "s/@SGI_ABI@//g" sysconfigfile + sed -i.bak "s@$BUILD_PREFIX/bin/${HOST}-llvm-ar@${HOST}-ar@g" sysconfigfile + # Remove GNULD=yes to make sure new-dtags are not used + sed -i.bak "s/'GNULD': 'yes'/'GNULD': 'no'/g" sysconfigfile + cp sysconfigfile ${our_compilers_name} + + # For system gcc remove the triple + sed -i.bak "s@$HOST-c++@g++@g" sysconfigfile + sed -i.bak "s@$HOST-@@g" sysconfigfile + if [[ "$target_platform" == linux* ]]; then + # For linux, make sure the system gcc uses our linker + sed -i.bak "s@-pthread@-pthread -B $PREFIX/share/python_compiler_compat@g" sysconfigfile + fi + # Don't set -march and -mtune for system gcc + sed -i.bak "s@-march=[^( |\\\"|\\\')]*@@g" sysconfigfile + sed -i.bak "s@-mtune=[^( |\\\"|\\\')]*@@g" sysconfigfile + # Remove these flags that older compilers and linkers may not know + for flag in "-fstack-protector-strong" "-ffunction-sections" "-pipe" "-fno-plt" \ + "-ftree-vectorize" "-Wl,--sort-common" "-Wl,--as-needed" "-Wl,-z,relro" \ + "-Wl,-z,now" "-Wl,--disable-new-dtags" "-Wl,--gc-sections" "-Wl,-O2" \ + "-fPIE" "-ftree-vectorize" "-mssse3" "-Wl,-pie" "-Wl,-dead_strip_dylibs" \ + "-Wl,-headerpad_max_install_names"; do + sed -i.bak "s@$flag@@g" sysconfigfile + done + # Cleanup some extra spaces from above + sed -i.bak "s@' [ ]*@'@g" sysconfigfile + cp sysconfigfile $recorded_name + echo "========================sysconfig===========================" + cat $recorded_name + echo "============================================================" + + rm sysconfigfile + rm sysconfigfile.bak +popd + +if [[ ${HOST} =~ .*linux.* ]]; then + mkdir -p ${PREFIX}/share/python_compiler_compat + ln -s ${PREFIX}/bin/${HOST}-ld ${PREFIX}/share/python_compiler_compat/ld + echo "Files in this folder are to enhance backwards compatibility of anaconda software with older compilers." > ${PREFIX}/share/python_compiler_compat/README + echo "See: https://github.com/conda/conda/issues/6030 for more information." >> ${PREFIX}/share/python_compiler_compat/README +fi + +python -c "import compileall,os;compileall.compile_dir(os.environ['PREFIX'])" +rm ${PREFIX}/lib/libpython${VERABI}.a + +if [[ ${PY_INTERP_DEBUG} == yes ]]; then + rm ${PREFIX}/bin/python${VER} + ln -s ${PREFIX}/bin/python${VERABI} ${PREFIX}/bin/python${VER} + ln -s ${PREFIX}/lib/libpython${VERABI}${SHLIB_EXT} ${PREFIX}/lib/libpython${VERABI_NO_DBG}${SHLIB_EXT} + ln -s ${PREFIX}/include/python${VERABI} ${PREFIX}/include/python${VER} +fi + +if [[ "$target_platform" == linux-* ]]; then + rm ${PREFIX}/include/uuid.h +fi + +# Workaround for https://github.com/conda/conda/issues/14053 +# Older conda versions install noarch: python packages in wrong places. +# For example python3.1 because older conda assumed python minor version +# will have only one digit. noarhc pkgs for freethreading builds are supposed +# to be installed into /lib/python3.13t/site-packages, but conda +# installs them to /lib/python3.13/site-packages. +# The workaround is to add all these wrong paths to sys.path using +# a pth file so that cpython and other tools like pip know about these +# locations to check when importing packages and uninstalling packages. +# When installing packages, pip will use the correct location +# /lib/python3.13t/site-packages. +# Note that these directories are not added to sys.path if they do not exist. +SP_DIR="${PREFIX}/lib/python${PY_VER}${THREAD}/site-packages" +if [[ ${PY_FREETHREADING} == yes ]]; then + echo "${PREFIX}/lib/python${PY_VER}/site-packages" >> $SP_DIR/conda-site.pth +fi +# Workaround for https://github.com/conda/conda/issues/10969 +echo "${PREFIX}/lib/python3.1/site-packages" >> $SP_DIR/conda-site.pth +# A python version independent directory that ABI3 and noarch packages can use. +# This is unused at the moment, but keeping it here for experimentation. +echo "${PREFIX}/lib/python/site-packages" >> $SP_DIR/conda-site.pth diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/build_static.bat b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/build_static.bat new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/build_static.sh b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/build_static.sh new file mode 100644 index 0000000000000000000000000000000000000000..9027bc0cc8776e9a6144b221aa59476a61946402 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/build_static.sh @@ -0,0 +1,33 @@ +#!/bin/bash +set -ex + +_buildd_static=build-static +_buildd_shared=build-shared +if [[ ${PY_INTERP_DEBUG} == yes ]]; then + DBG=d +else + DBG= +fi +if [[ ${PY_FREETHREADING} == yes ]]; then + # This Python will not be usable with non-free threading Python modules. + THREAD=t +else + THREAD= +fi + +VER=${PKG_VERSION%.*} +ABIFLAGS=${DBG}${THREAD} +VERABI=${VER}${THREAD}${DBG} +VERABI_NO_DBG=${VER}${THREAD} + +cp -pf ${_buildd_static}/libpython${VERABI}.a ${PREFIX}/lib/libpython${VERABI}.a +if [[ ${HOST} =~ .*linux.* ]]; then + pushd ${PREFIX}/lib/python${VERABI_NO_DBG}/config-${VERABI}-${HOST/-conda/} +elif [[ ${HOST} =~ .*darwin.* ]]; then + pushd ${PREFIX}/lib/python${VERABI_NO_DBG}/config-${VERABI}-darwin +fi +ln -s ../../libpython${VERABI}.a libpython${VERABI}.a +popd +# If the LTO info in the normal lib is problematic (using different compilers for example +# we also provide a 'nolto' version). +cp -pf ${_buildd_shared}/libpython${VERABI_NO_DBG}-pic.a ${PREFIX}/lib/libpython${VERABI_NO_DBG}.nolto.a diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/conda_build_config.yaml b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/conda_build_config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..280eac5f6ce8d72cc6a56a6e4e66217fb6126178 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/conda_build_config.yaml @@ -0,0 +1,37 @@ +MACOSX_SDK_VERSION: # [osx and x86_64] + - 11.0 # [osx and x86_64] +# See https://docs.python.org/3.14/whatsnew/3.14.html#a-new-type-of-interpreter +c_compiler_version: # [osx] + - 20.1 # [osx] +cxx_compiler_version: # [osx] + - 20.1 # [osx] + +# Override Python `zip_keys` +python: + - 3.14 +numpy: + - 1.16 +python_impl: + - cpython +is_python_min: + - no + +# Whether to build free-threaded Python (3.13+) +freethreading: + - yes + - no + +# Use Python RC components in build +channel_sources: + - conda-forge/label/python_rc,conda-forge + +# Configuration for debug and release builds +build_type: + - release + - debug # [not win] +channel_targets: + - conda-forge main + - conda-forge python_debug # [not win] +zip_keys: + - build_type + - channel_targets diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/fix_staged_scripts.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/fix_staged_scripts.py new file mode 100644 index 0000000000000000000000000000000000000000..29489b30db4f6d422168675a864233d036832b42 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/fix_staged_scripts.py @@ -0,0 +1,41 @@ +from os.path import isdir, isfile, dirname, join + +import os +import shutil + + +# Taken and adapted from conda_build/windows.py +def fix_staged_scripts(scripts_dir): + """ + Fixes scripts which have been installed unix-style to have a .bat + helper + """ + if not isdir(scripts_dir): + return + for fn in os.listdir(scripts_dir): + # process all the extensionless files + if not isfile(join(scripts_dir, fn)) or '.' in fn: + continue + + # read as binary file to ensure we don't run into encoding errors, see #1632 + with open(join(scripts_dir, fn), 'rb') as f: + line = f.readline() + # If it's a #!python script + if not (line.startswith(b'#!') and b'python' in line.lower()): + continue + print('Adjusting unix-style #! script %s, ' + 'and adding a .bat file for it' % fn) + # copy it with a .py extension (skipping that first #! line) + with open(join(scripts_dir, fn + '-script.py'), 'wb') as fo: + fo.write(f.read()) + # now create the .exe file + # This is hardcoded that conda and conda-build are in the same environment + base_env = dirname(dirname(os.environ['CONDA_EXE'])) + exe = join(base_env, 'lib', 'site-packages', 'conda_build', 'cli-64.exe') + shutil.copyfile(exe, join(scripts_dir, fn + '.exe')) + + # remove the original script + os.remove(join(scripts_dir, fn)) + + +fix_staged_scripts(os.environ['SCRIPTS']) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/install_jit_activation.bat b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/install_jit_activation.bat new file mode 100644 index 0000000000000000000000000000000000000000..799d08944fbd960e0d247ff031d7b3e3c7086f0f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/install_jit_activation.bat @@ -0,0 +1,16 @@ +@echo on + +:: Copy the [de]activate scripts to %PREFIX%\etc\conda\[de]activate.d. +:: This will allow them to be run on environment activation. +if not exist %PREFIX%\etc\conda\activate.d mkdir %PREFIX%\etc\conda\activate.d +copy %RECIPE_DIR%\scripts\activate.bat %PREFIX%\etc\conda\activate.d\%PKG_NAME%_activate.bat +if errorlevel 1 exit 1 +:: We also copy .sh scripts to be able to use them with POSIX CLI on Windows. +copy %RECIPE_DIR%\scripts\activate.sh %PREFIX%\etc\conda\activate.d\%PKG_NAME%_activate.sh +if errorlevel 1 exit 1 + +if not exist %PREFIX%\etc\conda\deactivate.d mkdir %PREFIX%\etc\conda\deactivate.d +copy %RECIPE_DIR%\scripts\deactivate.bat %PREFIX%\etc\conda\deactivate.d\%PKG_NAME%_deactivate.bat +if errorlevel 1 exit 1 +copy %RECIPE_DIR%\scripts\deactivate.sh %PREFIX%\etc\conda\deactivate.d\%PKG_NAME%_deactivate.sh +if errorlevel 1 exit 1 diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/install_jit_activation.sh b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/install_jit_activation.sh new file mode 100644 index 0000000000000000000000000000000000000000..d8e18109a347d577c411753eef86713bcc4d8bd5 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/install_jit_activation.sh @@ -0,0 +1,7 @@ +# Copy the [de]activate scripts to $PREFIX/etc/conda/[de]activate.d. +# This will allow them to be run on environment activation. +for CHANGE in "activate" "deactivate" +do + mkdir -p "${PREFIX}/etc/conda/${CHANGE}.d" + cp "${RECIPE_DIR}/scripts/${CHANGE}.sh" "${PREFIX}/etc/conda/${CHANGE}.d/${PKG_NAME}_${CHANGE}.sh" +done diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/meta.yaml b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/meta.yaml new file mode 100644 index 0000000000000000000000000000000000000000..41f14fc5f12b83dc79bc4fd70f1eb2ddb322db32 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/meta.yaml @@ -0,0 +1,414 @@ +{% set version = "3.14.4" %} +{% set dev = "" %} +{% set dev_ = "" %} +{% set ver2 = '.'.join(version.split('.')[0:2]) %} +{% set ver2nd = ''.join(version.split('.')[0:2]) %} +{% set ver3nd = ''.join(version.split('.')[0:3]) %} +{% set build_number = 0 %} + +# this makes the linter happy +{% set channel_targets = channel_targets or 'conda-forge main' %} + +# Sanitize build system env. var tweak parameters +# (passed to the build scripts via script_env). +{% if freethreading is not defined %} + {% set freethreading = "yes" %} +{% endif %} + +{% set abi_tag = "cp" + ver2nd %} +# freethreading, set using conda_build_config.yaml +{% if freethreading == "yes" %} + {% set abi_tag = abi_tag + "t" %} +{% else %} + {% set build_number = build_number + 100 %} +{% endif %} + +{% if build_type == "debug" %} + {% set py_interp_debug = "yes" %} + {% set debug = "_debug" %} +{% else %} + {% set py_interp_debug = "no" %} + {% set debug = "" %} +{% endif %} + +{% if win %} + {% set site_packages_path = "Lib/site-packages" %} +{% elif freethreading == "yes" %} + {% set site_packages_path = "lib/python" + ver2 + "t/site-packages" %} +{% else %} + {% set site_packages_path = "lib/python" + ver2 + "/site-packages" %} +{% endif %} + +package: + name: python-split + version: {{ version }}{{ dev }} + +source: + - url: https://www.python.org/ftp/python/{{ version }}/Python-{{ version }}{{ dev }}.tar.xz + # sha256 from: https://www.python.org/downloads/release/python-{{ ver3nd }}{{ dev }}/ + sha256: d923c51303e38e249136fc1bdf3568d56ecb03214efdef48516176d3d7faaef8 + patches: + - patches/0001-Win32-Change-FD_SETSIZE-from-512-to-2048.patch + - patches/0002-Win32-Do-not-download-externals.patch + - patches/0003-Fix-find_library-so-that-it-looks-in-sys.prefix-lib-.patch + - patches/0004-Disable-registry-lookup-unless-CONDA_PY_ALLOW_REG_PA.patch + - patches/0005-Unvendor-openssl.patch + - patches/0006-Unvendor-sqlite3.patch + - patches/0007-Add-CondaEcosystemModifyDllSearchPath.patch + - patches/0008-Doing-d1trimfile.patch + # https://github.com/python/cpython/pull/23523 + - patches/0009-cross-compile-darwin.patch + - patches/0010-Fix-TZPATH-on-windows.patch + # https://github.com/python/cpython/pull/24324 + - patches/0011-Make-dyld-search-work-with-SYSTEM_VERSION_COMPAT-1.patch + - patches/0012-Unvendor-bzip2.patch + - patches/0013-Unvendor-libffi.patch + - patches/0014-Unvendor-tcltk.patch + - patches/0015-unvendor-xz.patch + - patches/0016-unvendor-zlib.patch + - patches/0017-Do-not-pass-g-to-GCC-when-not-Py_DEBUG.patch + - patches/0018-Unvendor-expat.patch + - patches/0019-Remove-unused-readelf.patch + - patches/0020-Don-t-checksharedmods-if-cross-compiling.patch + - patches/0021-Override-configure-LIBFFI.patch + - patches/0022-Unvendor-libmpdec.patch +{% if 'conda-forge' in channel_targets %} + - patches/0023-Brand-conda-forge.patch +{% endif %} + - patches/0024-Do-not-define-pid_t-as-it-might-conflict-with-the-ac.patch + - patches/0025-Unvendor-zstd.patch +{% if freethreading == "yes" %} + - patches/0026-Set-Py_GIL_DISABLED-in-windows-to-match-unix.patch +{% endif %} + +build: + number: {{ build_number }} + +requirements: + build: + - patch # [not win] + - m2-patch # [win] + - m2-gcc-libs # [win] + +outputs: + - name: python + script: build_base.sh # [unix] + script: build_base.bat # [win] + build: + number: {{ build_number }} + activate_in_script: true + # Windows has issues updating python if conda is using files itself. + # Copy rather than link. + no_link: + - DLLs/_ctypes.pyd # [win] + ignore_run_exports_from: + # C++ only installed so CXX is defined for distutils/sysconfig. + - {{ compiler('cxx') }} # [unix] + # These two are just to get the headers needed for tk.h, but is unused + - xorg-libx11 # [unix] + - xorg-xorgproto # [unix] + # Disabled until verified to work correctly + detect_binary_files_with_prefix: true + # detect_binary_files_with_prefix: False + # binary_has_prefix_files: + # - lib/libpython{{ ver2 }}.*.1.0 + # - bin/python{{ ver2 }} # [linux] + # - lib/libpython{{ ver2 }}.a # [linux] + # - lib/libpython{{ ver2 }}.nolto.a # [linux] + # - lib/libpython3.so # [linux] + # - lib/python{{ ver2 }}/lib-dynload/_hashlib.cpython-{{ ver2nd }}-x86_64-linux-gnu.so # [linux] + # - lib/libpython3.dylib # [osx] + # match python.org compiler standard + skip: true # [win and int(float(vc)) < 14] + skip_compile_pyc: + - '*.py' # [build_platform != target_platform] + string: {{ dev_ }}h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}{{ debug }}_{{ abi_tag }} + python_site_packages_path: {{ site_packages_path }} + run_exports: + noarch: + - python + weak: + - python_abi {{ ver2 }}.* *_{{ abi_tag }} +{% if py_interp_debug == "yes" %} + - python {{ ver2 }}.* *_debug_{{ abi_tag }} +{% endif %} + track_features: +{% if freethreading == "yes" %} + - py_freethreading +{% endif %} + script_env: + - PY_INTERP_DEBUG={{ py_interp_debug }} + - PY_FREETHREADING={{ freethreading }} + # Putting these here means they get emitted to build_env_setup.{sh,bat} meaning we can launch IDEs + # after sourcing or calling that script without examine the contents of conda_build.{sh,bat} for + # important env. vars. + missing_dso_whitelist: # [win] + - '**/MSVCR71.dll' # [win] + - '**/MSVCR80.dll' # [win] + # I have no idea why this is not in C:\Windows\System32\downlevel + - '**/api-ms-win-core-path-l1-1-0.dll' # [win] + requirements: + build: + - {{ compiler('c') }} + - {{ stdlib('c') }} + - {{ compiler('cxx') }} + - make # [not win] + - libtool # [unix] + - pkg-config # [not win] + # configure script looks for llvm-ar for lto + - llvm-tools # [osx] + - ld_impl_{{ target_platform }} # [linux] + - binutils_impl_{{ target_platform }} # [linux] + - clang-19 # [not win] + - llvm-tools-19 # [not win] + - clang 19.* # [win] + - llvm-tools 19.* # [win] + - bzip2 # [build_platform != target_platform] + - libsqlite # [build_platform != target_platform] + - liblzma-devel # [build_platform != target_platform] + - zlib # [build_platform != target_platform] + - zstd # [build_platform != target_platform] + - openssl # [build_platform != target_platform] + - readline # [not win and build_platform != target_platform] + - tk # [build_platform != target_platform] + - ncurses # [unix and build_platform != target_platform] + - libffi # [build_platform != target_platform] + - libuuid # [linux and build_platform != target_platform] + - libmpdec-devel # [build_platform != target_platform] + - expat # [build_platform != target_platform] + host: + - bzip2 + - libsqlite + - liblzma-devel + - zlib + - zstd + - openssl + - readline # [not win] + - tk + # These two are just to get the headers needed for tk.h, but is unused + - xorg-libx11 # [unix] + - xorg-xorgproto # [unix] + - ncurses # [unix] + - libffi + - ld_impl_{{ target_platform }} >=2.36.1 # [linux] + - libuuid # [linux] + - libmpdec-devel + - expat + run: + - ld_impl_{{ target_platform }} >=2.36.1 # [linux] + - tzdata +{% if dev != '' %} + - _python_rc +{% endif %} + - python_abi {{ ver2 }}.* *_{{ abi_tag }} + test: + downstreams: + - cython + - setuptools + requires: + - ripgrep + - cmake + - ninja + - {{ stdlib('c') }} + - {{ compiler('c') }} + # Tried to use enable_language(C) to avoid needing this. It does not work. + - {{ compiler('cxx') }} + # For tkinter, but we expect from system + - xorg-libx11 # [unix] + files: + - tests/cmake/* + - tests/cython/* + - tests/prefix-replacement/* + - run_test.py + commands: + - echo on # [win] + - set # [win] + - python -V + - python3 -V # [not win] + - pydoc -h + - python3-config --help # [not win] + - set "PIP_NO_BUILD_ISOLATION=False" # [win] + - set "PIP_NO_DEPENDENCIES=True" # [win] + - set "PIP_IGNORE_INSTALLED=True" # [win] + - set "PIP_NO_INDEX=True" # [win] + - set "PIP_CACHE_DIR=%CONDA_PREFIX%/pip_cache" # [win] + - set "TEMP=%CONDA_PREFIX%/tmp" # [win] + - mkdir "%TEMP%" # [win] + - python -Im ensurepip --upgrade --default-pip # [win] + # tzdata/zoneinfo test that will need the tzdata package to pass + - python -c "from zoneinfo import ZoneInfo; from datetime import datetime; dt = datetime(2020, 10, 31, 12, tzinfo=ZoneInfo('America/Los_Angeles')); print(dt.tzname())" + - python -m venv test-venv + - test-venv\\Scripts\\python.exe -c "import ctypes" # [win] + - test-venv/bin/python -c "import ctypes" # [unix] + - python -c "import sysconfig; print(sysconfig.get_config_var('CC'))" # [not win] + - _CONDA_PYTHON_SYSCONFIGDATA_NAME=_sysconfigdata_x86_64_conda_linux_gnu python -c "import sysconfig; print(sysconfig.get_config_var('CC'))" # [linux64] + # check for unreplaced @ symbols in sysconfig files, excluding e.g. '"$@".lto' + - for f in ${CONDA_PREFIX}/lib/python*/_sysconfig*.py; do echo "Checking $f:"; if [[ `rg @[^@]*@ $f` ]]; then echo "FAILED ON $f"; cat $f; exit 1; fi; done # [linux64 or osx] + - test ! -f ${PREFIX}/lib/libpython${PKG_VERSION%.*}.a # [unix] + - test ! -f ${PREFIX}/lib/libpython${PKG_VERSION%.*}.nolto.a # [unix] + {% if freethreading == "yes" %} + - if not exist %PREFIX%\\libs\\python3t.lib exit 1 # [win] + - if not exist %PREFIX%\\libs\\python{{ ver2nd }}t.lib exit 1 # [win] + {% else %} + - if not exist %PREFIX%\\libs\\python3.lib exit 1 # [win] + - if not exist %PREFIX%\\libs\\python{{ ver2nd }}.lib exit 1 # [win] + {% endif %} + # https://github.com/conda-forge/python-feedstock/issues/384 + - if exist %PREFIX%\\Scripts\\pydoc exit 1 # [win] + - if exist %PREFIX%\\Scripts\\idle exit 1 # [win] + - if not exist %PREFIX%\\Scripts\\pydoc-script.py exit 1 # [win] + - if not exist %PREFIX%\\Scripts\\idle-script.py exit 1 # [win] + - if not exist %PREFIX%\\Scripts\\idle.exe exit 1 # [win] + - if not exist %PREFIX%\\Scripts\\pydoc.exe exit 1 # [win] + - if not exist %PREFIX%\\include\\pyconfig.h exit 1 # [win] + - pushd tests + - pushd prefix-replacement # [unix] + - bash build-and-test.sh # [unix] + - popd # [unix] + - pushd cmake +{% if freethreading == "no" %} + # TODO: use the new FindPython3 which supports freethreading + - cmake -GNinja -DPY_VER={{ version }} --debug-find --trace --debug-output --debug-trycompile . +{% endif %} + - popd + - popd + - python run_test.py + - test ! -f default.profraw # [osx] + - python3.1 --version # [unix] + # Test for segfault on osx-64 with libffi=3.4, see https://bugs.python.org/issue44556 + - python -c "from ctypes import CFUNCTYPE; CFUNCTYPE(None)(id)" + # Test for wide character supported via ncursesw + - TERM=xterm >/dev/null python -c "import curses; scr = curses.initscr(); curses.unget_wch('x'); assert 'x' == scr.get_wch()" # [unix] + + - name: libpython-static + script: build_static.sh # [unix] + script: build_static.bat # [win] + build: + number: {{ build_number }} + activate_in_script: true + ignore_run_exports: + - python_abi + script_env: + - PY_INTERP_DEBUG={{ py_interp_debug }} + - PY_FREETHREADING={{ freethreading }} + string: h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}{{ debug }}_{{ abi_tag }} + requirements: + build: + - {{ compiler('c') }} + - {{ stdlib('c') }} + - {{ compiler('cxx') }} + host: + - {{ pin_subpackage('python', exact=True) }} + run: + - {{ pin_subpackage('python', exact=True) }} + test: + files: + - tests/prefix-replacement/* + requires: + - {{ stdlib('c') }} + - {{ compiler('c') }} + - ripgrep + commands: + - VER=${PKG_VERSION%.*} # [not win] + - VERABI=${VER} # [not win] +{% if freethreading == "yes" %} + - VERABI=${VERABI}t # [not win] +{% endif %} + - VERABI_NO_DBG=${VERABI} # [not win] +{% if py_interp_debug == "yes" %} + - VERABI=${VERABI}d # [not win] +{% endif %} + - test -f ${PREFIX}/lib/libpython${VERABI}.a # [unix] + - test -f ${PREFIX}/lib/libpython${VERABI_NO_DBG}.nolto.a # [unix] + - test -f ${PREFIX}/lib/python${VERABI_NO_DBG}/config-${VERABI}-darwin/libpython${VERABI}.a # [osx] + - pushd tests/prefix-replacement # [unix] + - bash build-and-test.sh # [unix] + - popd # [unix] + + - name: cpython + build: + noarch: generic + requirements: + - python {{ version }}{{ dev }} + - python_abi * *_{{ abi_tag }} + + - name: python-freethreading + build: + noarch: generic +{% if freethreading != "yes" %} + skip: true +{% endif %} + requirements: + - cpython {{ version }}{{ dev }} + - python_abi * *_{{ abi_tag }} + + - name: python-gil + build: + noarch: generic +{% if freethreading == "yes" %} + skip: true +{% endif %} + requirements: + - cpython {{ version }}{{ dev }} + - python_abi * *_{{ abi_tag }} + + - name: python-jit + script: install_jit_activation.sh # [not win] + script: install_jit_activation.bat # [win] + build: + noarch: generic + requirements: + - cpython {{ version }}{{ dev }} + - __unix # [unix] + - __win # [win] + +about: + home: https://www.python.org/ + license: Python-2.0 + license_file: LICENSE + summary: General purpose programming language + description: | + Python is a widely used high-level, general-purpose, interpreted, dynamic + programming language. Its design philosophy emphasizes code + readability, and its syntax allows programmers to express concepts in + fewer lines of code than would be possible in languages such as C++ or + Java. The language provides constructs intended to enable clear programs + on both a small and large scale. + + We provide some meta packages for convenience. + To get a CPython flavour, use: + + conda install cpython + + To get the freethreading build (i.e. without the Global Interpreter Lock - GIL): + + conda install python-freethreading + + To get the default build (i.e. with the GIL): + + conda install python-gil + + To enable the use of the experimental JIT compiler in CPython: + + conda install python-jit + + or set the environment variable PYTHON_JIT=1. Note that the JIT support + is available for x86_64 builds only. + + doc_url: https://www.python.org/doc/versions/ + doc_source_url: https://github.com/python/pythondotorg/blob/master/docs/source/index.rst + dev_url: https://docs.python.org/devguide/ + +extra: + feedstock-name: python + recipe-maintainers: + - chrisburr + - isuruf + - jakirkham + - mbargull + - msarahan + - pelson + - ocefpaf + - scopatz + - katietz + - xhochy diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0001-Win32-Change-FD_SETSIZE-from-512-to-2048.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0001-Win32-Change-FD_SETSIZE-from-512-to-2048.patch new file mode 100644 index 0000000000000000000000000000000000000000..371daf0ec071f4bd67f95aa1af29d706f12b2ca7 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0001-Win32-Change-FD_SETSIZE-from-512-to-2048.patch @@ -0,0 +1,23 @@ +From bc87f7d41e5dbda75de04d93b6e60075f579d5f2 Mon Sep 17 00:00:00 2001 +From: Ray Donnelly +Date: Wed, 16 Aug 2017 11:53:55 +0100 +Subject: [PATCH 01/26] Win32: Change FD_SETSIZE from 512 to 2048 + +https://github.com/ContinuumIO/anaconda-issues/issues/1241 +--- + Modules/selectmodule.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/Modules/selectmodule.c b/Modules/selectmodule.c +index d234d504cb5..3856307c611 100644 +--- a/Modules/selectmodule.c ++++ b/Modules/selectmodule.c +@@ -44,7 +44,7 @@ + FD_SETSIZE higher before this; e.g., via compiler /D switch. + */ + #if defined(MS_WINDOWS) && !defined(FD_SETSIZE) +-#define FD_SETSIZE 512 ++#define FD_SETSIZE 2048 + #endif + + #if defined(HAVE_POLL_H) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0002-Win32-Do-not-download-externals.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0002-Win32-Do-not-download-externals.patch new file mode 100644 index 0000000000000000000000000000000000000000..48fab71f59008c179af0449319f2d2d571843dda --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0002-Win32-Do-not-download-externals.patch @@ -0,0 +1,22 @@ +From ac7720a49412776a03313fecf281be7aa6d9d6d3 Mon Sep 17 00:00:00 2001 +From: Ray Donnelly +Date: Thu, 7 Sep 2017 11:35:47 +0100 +Subject: [PATCH 02/26] Win32: Do not download externals + +--- + PCbuild/build.bat | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/PCbuild/build.bat b/PCbuild/build.bat +index 60235704886..717a35c9d7e 100644 +--- a/PCbuild/build.bat ++++ b/PCbuild/build.bat +@@ -113,7 +113,7 @@ if "%IncludeSSL%"=="" set IncludeSSL=true + if "%IncludeTkinter%"=="" set IncludeTkinter=true + if "%UseJIT%" NEQ "true" set IncludeLLVM=false + +-if "%IncludeExternals%"=="true" call "%dir%get_externals.bat" ++@rem if "%IncludeExternals%"=="true" call "%dir%get_externals.bat" + + if "%do_pgo%" EQU "true" if "%platf%" EQU "x64" ( + if "%PROCESSOR_ARCHITEW6432%" NEQ "AMD64" if "%PROCESSOR_ARCHITECTURE%" NEQ "AMD64" ( diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0003-Fix-find_library-so-that-it-looks-in-sys.prefix-lib-.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0003-Fix-find_library-so-that-it-looks-in-sys.prefix-lib-.patch new file mode 100644 index 0000000000000000000000000000000000000000..34b6f1632c9ac679193c09016753e39fdd8cb2a4 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0003-Fix-find_library-so-that-it-looks-in-sys.prefix-lib-.patch @@ -0,0 +1,73 @@ +From f55dbad460ad50580aac291f5f68f77b4eb5e443 Mon Sep 17 00:00:00 2001 +From: Ray Donnelly +Date: Tue, 5 Dec 2017 22:47:59 +0000 +Subject: [PATCH 03/26] Fix find_library so that it looks in sys.prefix/lib + first + +--- + Lib/ctypes/macholib/dyld.py | 4 ++++ + Lib/ctypes/util.py | 27 ++++++++++++++++++++++++--- + 2 files changed, 28 insertions(+), 3 deletions(-) + +diff --git a/Lib/ctypes/macholib/dyld.py b/Lib/ctypes/macholib/dyld.py +index 583c47daff3..ab9b01c87e2 100644 +--- a/Lib/ctypes/macholib/dyld.py ++++ b/Lib/ctypes/macholib/dyld.py +@@ -93,6 +93,10 @@ def dyld_executable_path_search(name, executable_path=None): + # If we haven't done any searching and found a library and the + # dylib_name starts with "@executable_path/" then construct the + # library name. ++ if not executable_path: ++ import sys ++ if sys.prefix: ++ executable_path = os.path.join(sys.prefix, 'bin') + if name.startswith('@executable_path/') and executable_path is not None: + yield os.path.join(executable_path, name[len('@executable_path/'):]) + +diff --git a/Lib/ctypes/util.py b/Lib/ctypes/util.py +index 3b21658433b..2c900c1e2cf 100644 +--- a/Lib/ctypes/util.py ++++ b/Lib/ctypes/util.py +@@ -135,7 +135,8 @@ def dllist(): + elif os.name == "posix" and sys.platform in {"darwin", "ios", "tvos", "watchos"}: + from ctypes.macholib.dyld import dyld_find as _dyld_find + def find_library(name): +- possible = ['lib%s.dylib' % name, ++ possible = ['@executable_path/../lib/lib%s.dylib' % name, ++ 'lib%s.dylib' % name, + '%s.dylib' % name, + '%s.framework/%s' % (name, name)] + for name in possible: +@@ -436,10 +437,30 @@ def _findLib_ld(name): + pass # result will be None + return result + ++ def _findLib_prefix(name): ++ if not name: ++ return None ++ for fullname in (name, "lib%s.so" % (name)): ++ path = os.path.join(sys.prefix, 'lib', fullname) ++ if os.path.exists(path) and not os.path.isdir(path): ++ return path ++ return None ++ + def find_library(name): + # See issue #9998 +- return _findSoname_ldconfig(name) or \ +- _get_soname(_findLib_gcc(name)) or _get_soname(_findLib_ld(name)) ++ # Yes calling _findLib_prefix twice is deliberate, because _get_soname ditches ++ # the full path. ++ # When objdump is unavailable this returns None ++ so_name = _get_soname(_findLib_prefix(name)) or name ++ if so_name != name: ++ return _findLib_prefix(so_name) or \ ++ _findLib_prefix(name) or \ ++ _findSoname_ldconfig(name) or \ ++ _get_soname(_findLib_gcc(name)) or _get_soname(_findLib_ld(name)) ++ else: ++ return _findLib_prefix(name) or \ ++ _findSoname_ldconfig(name) or \ ++ _get_soname(_findLib_gcc(name)) or _get_soname(_findLib_ld(name)) + + + # Listing loaded libraries on other systems will try to use diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0004-Disable-registry-lookup-unless-CONDA_PY_ALLOW_REG_PA.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0004-Disable-registry-lookup-unless-CONDA_PY_ALLOW_REG_PA.patch new file mode 100644 index 0000000000000000000000000000000000000000..ceeb7db68a62e360ced1d311bb6c142fc3cf03fe --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0004-Disable-registry-lookup-unless-CONDA_PY_ALLOW_REG_PA.patch @@ -0,0 +1,45 @@ +From 29f68dcae94d2ad54f7e36df12175fb2bd3ef467 Mon Sep 17 00:00:00 2001 +From: Ray Donnelly +Date: Sat, 27 Oct 2018 18:48:30 +0100 +Subject: [PATCH 04/26] Disable registry lookup unless CONDA_PY_ALLOW_REG_PATHS + is not 0 + +Co-authored-by: Isuru Fernando +--- + Modules/getpath.c | 1 + + Modules/getpath.py | 3 ++- + 2 files changed, 3 insertions(+), 1 deletion(-) + +diff --git a/Modules/getpath.c b/Modules/getpath.c +index 1e75993480a..ff96c8e1990 100644 +--- a/Modules/getpath.c ++++ b/Modules/getpath.c +@@ -937,6 +937,7 @@ _PyConfig_InitPathConfig(PyConfig *config, int compute_path_config) + !env_to_dict(dict, "ENV_PATH", 0) || + !env_to_dict(dict, "ENV_PYTHONHOME", 0) || + !env_to_dict(dict, "ENV_PYTHONEXECUTABLE", 0) || ++ !env_to_dict(dict, "ENV_CONDA_PY_ALLOW_REG_PATHS", 0) || + !env_to_dict(dict, "ENV___PYVENV_LAUNCHER__", 1) || + !progname_to_dict(dict, "real_executable") || + !library_to_dict(dict, "library") || +diff --git a/Modules/getpath.py b/Modules/getpath.py +index b89d7427e3f..21df0efac12 100644 +--- a/Modules/getpath.py ++++ b/Modules/getpath.py +@@ -52,6 +52,7 @@ + # ENV_PYTHONHOME -- [in] getenv(...) + # ENV_PYTHONEXECUTABLE -- [in] getenv(...) + # ENV___PYVENV_LAUNCHER__ -- [in] getenv(...) ++# ENV_CONDA_PY_ALLOW_REG_PATHS -- [in] getenv(...) + + # ** Values calculated at runtime ** + # config -- [in/out] dict of the PyConfig structure +@@ -704,7 +705,7 @@ def search_up(prefix, *landmarks, test=isfile): + else: + pythonpath.append(joinpath(base_prefix, ZIP_LANDMARK)) + +- if os_name == 'nt' and use_environment and winreg: ++ if os_name == 'nt' and use_environment and winreg and ENV_CONDA_PY_ALLOW_REG_PATHS and ENV_CONDA_PY_ALLOW_REG_PATHS != '0': + # QUIRK: Windows also lists paths in the registry. Paths are stored + # as the default value of each subkey of + # {HKCU,HKLM}\Software\Python\PythonCore\{winver}\PythonPath diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0005-Unvendor-openssl.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0005-Unvendor-openssl.patch new file mode 100644 index 0000000000000000000000000000000000000000..a70a24c6ac031f3fef92d6247682354201f5de1e --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0005-Unvendor-openssl.patch @@ -0,0 +1,152 @@ +From 17fc2b4af07c3e2732f8f9c62f34d0e1b57597bf Mon Sep 17 00:00:00 2001 +From: Nehal J Wani +Date: Sat, 24 Nov 2018 20:38:02 -0600 +Subject: [PATCH 05/26] Unvendor openssl + +Co-authored-by: Isuru Fernando +--- + PCbuild/openssl.props | 14 ++------------ + PCbuild/openssl.vcxproj | 32 -------------------------------- + PCbuild/python.props | 13 +------------ + PCbuild/python.vcxproj | 3 +++ + PCbuild/pythonw.vcxproj | 3 +++ + 5 files changed, 9 insertions(+), 56 deletions(-) + +diff --git a/PCbuild/openssl.props b/PCbuild/openssl.props +index 5fd708b211e..044cefd95ea 100644 +--- a/PCbuild/openssl.props ++++ b/PCbuild/openssl.props +@@ -2,10 +2,10 @@ + + + +- $(opensslIncludeDir);%(AdditionalIncludeDirectories) ++ $(condaDir)include;%(AdditionalIncludeDirectories) + + +- $(opensslOutDir);%(AdditionalLibraryDirectories) ++ $(condaDir)lib;%(AdditionalLibraryDirectories) + ws2_32.lib;libcrypto.lib;libssl.lib;%(AdditionalDependencies) + + +@@ -21,14 +21,4 @@ + <_SSLDLL Include="$(opensslOutDir)\libssl$(_DLLSuffix).dll" /> + <_SSLDLL Include="$(opensslOutDir)\libssl$(_DLLSuffix).pdb" /> + +- +- +- +- +- +- + +diff --git a/PCbuild/openssl.vcxproj b/PCbuild/openssl.vcxproj +index 7ca750dda8f..17eee400ebb 100644 +--- a/PCbuild/openssl.vcxproj ++++ b/PCbuild/openssl.vcxproj +@@ -60,40 +60,8 @@ + + + +- +- $(opensslDir)\tmp$(Bitness)dll +- $(opensslOutDir) +- setlocal +-set VCINSTALLDIR=$(VCInstallDir) +-if not exist "$(IntDir.TrimEnd('\'))" mkdir "$(IntDir.TrimEnd('\'))" +-cd /D "$(IntDir.TrimEnd('\'))" +-$(Perl) "$(opensslDir)\configure" $(OpenSSLPlatform) no-asm no-uplink +-nmake +- +- +- + + +- +- +- <_Built Include="$(opensslDir)\LICENSE" /> +- <_Built Include="$(IntDir)\libcrypto.lib;$(IntDir)\libcrypto-*.dll;$(IntDir)\libcrypto-*.pdb" /> +- <_Built Include="$(IntDir)\libssl.lib;$(IntDir)\libssl-*.dll;$(IntDir)\libssl-*.pdb" /> +- <_Include Include="$(opensslDir)\Include\openssl\*.h" /> +- <_Include Include="$(IntDir)\include\openssl\*.h" /> +- +- +- +- +- +- +- +- +- +- +- +- +- + + + +diff --git a/PCbuild/python.props b/PCbuild/python.props +index da503ca0348..253aa66f477 100644 +--- a/PCbuild/python.props ++++ b/PCbuild/python.props +@@ -68,6 +68,7 @@ + + + $(EXTERNALS_DIR) ++ $(LIBRARY_PREFIX)\ + $([System.IO.Path]::GetFullPath(`$(PySourcePath)externals`)) + $(ExternalsDir)\ + +@@ -75,20 +76,8 @@ + + + +- $(ExternalsDir)sqlite-3.50.4.0\ +- $(ExternalsDir)bzip2-1.0.8\ +- $(ExternalsDir)xz-5.2.5\ +- $(ExternalsDir)libffi-3.4.4\ +- $(libffiDir)$(ArchName)\ +- $(libffiOutDir)include + $(ExternalsDir)\mpdecimal-4.0.0\ +- $(ExternalsDir)openssl-3.0.19\ +- $(ExternalsDir)openssl-bin-3.0.19\$(ArchName)\ +- $(opensslOutDir)include + $(ExternalsDir)\nasm-2.11.06\ +- $(ExternalsDir)\zlib-1.3.1\ +- $(ExternalsDir)\zlib-ng-2.2.4\ +- $(ExternalsDir)\zstd-1.5.7\ + + + +diff --git a/PCbuild/python.vcxproj b/PCbuild/python.vcxproj +index 70dabaa3c8b..ac5f96ebafc 100644 +--- a/PCbuild/python.vcxproj ++++ b/PCbuild/python.vcxproj +@@ -110,6 +110,9 @@ + + + ++ ++ _CRT_SECURE_NO_WARNINGS;$(PreprocessorDefinitions) ++ + + + +diff --git a/PCbuild/pythonw.vcxproj b/PCbuild/pythonw.vcxproj +index c6a5b8ce90a..74bd19144f9 100644 +--- a/PCbuild/pythonw.vcxproj ++++ b/PCbuild/pythonw.vcxproj +@@ -105,6 +105,9 @@ + + + ++ ++ _CRT_SECURE_NO_WARNINGS;$(PreprocessorDefinitions) ++ + + + diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0006-Unvendor-sqlite3.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0006-Unvendor-sqlite3.patch new file mode 100644 index 0000000000000000000000000000000000000000..b5e6350f82d964e0d2991dd132c18fb09a8bbe0a --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0006-Unvendor-sqlite3.patch @@ -0,0 +1,80 @@ +From f89df782ea930b7c8c8fa3a5cedf6984c68bbe26 Mon Sep 17 00:00:00 2001 +From: Nehal J Wani +Date: Tue, 5 Oct 2021 12:42:06 -0700 +Subject: [PATCH 06/26] Unvendor sqlite3 + +--- + PCbuild/_sqlite3.vcxproj | 11 +++++------ + PCbuild/pcbuild.sln | 2 -- + PCbuild/sqlite3.vcxproj | 12 ++++++------ + 3 files changed, 11 insertions(+), 14 deletions(-) + +diff --git a/PCbuild/_sqlite3.vcxproj b/PCbuild/_sqlite3.vcxproj +index 9ae0a0fc3a0..f482734ba1d 100644 +--- a/PCbuild/_sqlite3.vcxproj ++++ b/PCbuild/_sqlite3.vcxproj +@@ -93,9 +93,12 @@ + + + +- $(sqlite3Dir);%(AdditionalIncludeDirectories) ++ $(condaDir)\include;%(AdditionalIncludeDirectories) + PY_SQLITE_HAVE_SERIALIZE;PY_SQLITE_ENABLE_LOAD_EXTENSION;%(PreprocessorDefinitions) + ++ ++ $(condaDir)\lib\sqlite3.lib;%(AdditionalDependencies) ++ + + + +@@ -127,12 +130,8 @@ + {cf7ac3d1-e2df-41d2-bea6-1e2556cdea26} + false + +- +- {a1a295e5-463c-437f-81ca-1f32367685da} +- false +- + + + + +- +\ No newline at end of file ++ +diff --git a/PCbuild/pcbuild.sln b/PCbuild/pcbuild.sln +index 7296ea75301..9dd5e07ad8a 100644 +--- a/PCbuild/pcbuild.sln ++++ b/PCbuild/pcbuild.sln +@@ -72,8 +72,6 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "_elementtree", "_elementtre + EndProject + Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "_socket", "_socket.vcxproj", "{86937F53-C189-40EF-8CE8-8759D8E7D480}" + EndProject +-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "_sqlite3", "_sqlite3.vcxproj", "{13CECB97-4119-4316-9D42-8534019A5A44}" +-EndProject + Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "_ssl", "_ssl.vcxproj", "{C6E20F84-3247-4AD6-B051-B073268F73BA}" + EndProject + Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "_testcapi", "_testcapi.vcxproj", "{6901D91C-6E48-4BB7-9FEC-700C8131DF1D}" +diff --git a/PCbuild/sqlite3.vcxproj b/PCbuild/sqlite3.vcxproj +index f12ec348b37..f9e5e449a49 100644 +--- a/PCbuild/sqlite3.vcxproj ++++ b/PCbuild/sqlite3.vcxproj +@@ -88,12 +88,12 @@ + + + <_ProjectFileVersion>10.0.30319.1 +- <_SqliteVersion>$([System.Text.RegularExpressions.Regex]::Match(`$(sqlite3Dir)`, `((\d+)\.(\d+)\.(\d+)\.(\d+))\\?$`).Groups) +- $(_SqliteVersion.Split(`;`)[1]) +- $(_SqliteVersion.Split(`;`)[2]) +- $(_SqliteVersion.Split(`;`)[3]) +- $(_SqliteVersion.Split(`;`)[4]) +- $(_SqliteVersion.Split(`;`)[5]) ++ <_SqliteVersion>$(SQLITE3_VERSION) ++ $(_SqliteVersion) ++ $(_SqliteVersion.Split(`.`)[1]) ++ $(_SqliteVersion.Split(`.`)[2]) ++ $(_SqliteVersion.Split(`.`)[3]) ++ $(_SqliteVersion.Split(`.`)[4]) + + + diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0007-Add-CondaEcosystemModifyDllSearchPath.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0007-Add-CondaEcosystemModifyDllSearchPath.patch new file mode 100644 index 0000000000000000000000000000000000000000..c4cd6b6b17f6b03a72d799491bc8c15cb34b06eb --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0007-Add-CondaEcosystemModifyDllSearchPath.patch @@ -0,0 +1,154 @@ +From 853657f2bd5774cf51d88c95cf9f7cd27ceea315 Mon Sep 17 00:00:00 2001 +From: Ray Donnelly +Date: Tue, 24 Dec 2019 18:37:17 +0100 +Subject: [PATCH 07/26] Add CondaEcosystemModifyDllSearchPath() + + The python interpreter is modifed so that it works as if the python interpreter + was called with the following conda directories. + + os.add_dll_directory(join(sys.prefix, 'bin')) + os.add_dll_directory(join(sys.prefix, 'Scripts')) + os.add_dll_directory(join(sys.prefix, 'Library', 'bin')) + os.add_dll_directory(join(sys.prefix, 'Library', 'usr', 'bin')) + os.add_dll_directory(join(sys.prefix, 'Library', 'mingw-w64', 'bin')) + + Search order + - The directory that contains the DLL (if looking for a dependency) + - Application (python.exe) directory + - Directories added with os.add_dll_directory + - The 5 conda directories + - C:\Windows\System32 + + Note that the default behaviour changed in conda python 3.10 to + make os.add_dll_directory work in user code. + + Note that in conda python <3.11, there was an option + CONDA_DLL_SEARCH_MODIFICATION=1 to add directories in PATH to the search + order, but this was deprecated in 3.10 and removed in 3.11 in favour of using + AddDllDirectory + +Co-authored-by: Isuru Fernando +--- + Python/pylifecycle.c | 95 ++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 95 insertions(+) + +diff --git a/Python/pylifecycle.c b/Python/pylifecycle.c +index 6963635213a..1790d5aad25 100644 +--- a/Python/pylifecycle.c ++++ b/Python/pylifecycle.c +@@ -80,6 +80,10 @@ + + #ifdef MS_WINDOWS + # undef BYTE ++# include ++# include ++# include ++# include + #endif + + #define PUTS(fd, str) (void)_Py_write_noraise(fd, str, (int)strlen(str)) +@@ -114,6 +118,93 @@ GENERATE_DEBUG_SECTION(PyRuntime, _PyRuntimeState _PyRuntime) + = _PyRuntimeState_INIT(_PyRuntime, _Py_Debug_Cookie); + _Py_COMP_DIAG_POP + ++#ifdef MS_WINDOWS ++/* ++ This function will modify the DLL search path so that /Library\bin ++ and other conda PATHS are added to the front of the DLL search path. ++*/ ++ ++#if !defined(LOAD_LIBRARY_SEARCH_DEFAULT_DIRS) ++#define LOAD_LIBRARY_SEARCH_DEFAULT_DIRS 0x00001000 ++#endif ++ ++typedef void (WINAPI *ADD)(PCWSTR NewDirectory); ++static ADD pAddDllDirectory = NULL; ++typedef struct ++{ ++ wchar_t *p_relative; ++ wchar_t *p_name; ++} CONDA_PATH; ++ ++#define NUM_CONDA_PATHS 5 ++ ++static CONDA_PATH condaPaths[NUM_CONDA_PATHS] = ++{ ++ {L"Library\\mingw-w64\\bin", NULL}, ++ {L"Library\\usr\\bin", NULL}, ++ {L"Library\\bin", NULL}, ++ {L"Scripts", NULL}, ++ {L"bin", NULL} ++}; ++static wchar_t sv_dll_dirname[1024]; ++ ++int CondaEcosystemModifyDllSearchPath_Init() ++{ ++ int debug_it = _wgetenv(L"CONDA_DLL_SEARCH_MODIFICATION_DEBUG") ? 1 : 0; ++ wchar_t* enable = _wgetenv(L"CONDA_DLL_SEARCH_MODIFICATION_ENABLE"); ++ int res = 0; ++ long long j; ++ CONDA_PATH *p_conda_path; ++ HMODULE dll_handle = NULL; ++ ++ if (pAddDllDirectory == NULL) ++ { ++ pAddDllDirectory = (ADD)GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "AddDllDirectory"); ++ ++ /* Determine sv_dll_dirname */ ++ if (GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, ++ (LPCSTR) &CondaEcosystemModifyDllSearchPath_Init, &dll_handle) == 0) ++ { ++ // Getting the pythonxx.dll path failed. Fall back to relative path of python.exe ++ // assuming that the executable that is running this code is python.exe ++ dll_handle = NULL; ++ } ++ GetModuleFileNameW(dll_handle, &sv_dll_dirname[0], sizeof(sv_dll_dirname)/sizeof(sv_dll_dirname[0])-1); ++ sv_dll_dirname[sizeof(sv_dll_dirname)/sizeof(sv_dll_dirname[0])-1] = L'\0'; ++ if (wcsrchr(sv_dll_dirname, L'\\')) ++ *wcsrchr(sv_dll_dirname, L'\\') = L'\0'; ++ ++ for (p_conda_path = &condaPaths[0]; p_conda_path < &condaPaths[NUM_CONDA_PATHS]; ++p_conda_path) ++ { ++ size_t n_chars_dll_dirname = wcslen(sv_dll_dirname); ++ size_t n_chars_p_relative = wcslen(p_conda_path->p_relative); ++ p_conda_path->p_name = malloc(sizeof(wchar_t) * (n_chars_dll_dirname + n_chars_p_relative + 2)); ++ wcsncpy(p_conda_path->p_name, sv_dll_dirname, n_chars_dll_dirname+1); ++ wcsncat(p_conda_path->p_name, L"\\", 2); ++ wcsncat(p_conda_path->p_name, p_conda_path->p_relative, n_chars_p_relative+1); ++ } ++ ++ } ++ ++ if (pAddDllDirectory == NULL) ++ { ++ if (debug_it) ++ fwprintf(stderr, L"CondaEcosystemModifyDllSearchPath() :: WARNING :: Please install KB2533623 from http://go.microsoft.com/fwlink/p/?linkid=217865\n"\ ++ L"CondaEcosystemModifyDllSearchPath() :: WARNING :: to improve conda ecosystem DLL isolation"); ++ res = 2; ++ } ++ else { ++ for (j = NUM_CONDA_PATHS-1, p_conda_path = &condaPaths[NUM_CONDA_PATHS-1]; j > -1; --j, --p_conda_path) ++ { ++ if (debug_it) ++ fwprintf(stderr, L"CondaEcosystemModifyDllSearchPath() :: AddDllDirectory(%ls - ExePrefix)\n", p_conda_path->p_name); ++ pAddDllDirectory(p_conda_path->p_name); ++ } ++ } ++ return res; ++} ++ ++#endif + + static int runtime_initialized = 0; + +@@ -131,6 +222,10 @@ _PyRuntime_Initialize(void) + } + runtime_initialized = 1; + ++#ifdef MS_WINDOWS ++ extern int CondaEcosystemModifyDllSearchPath_Init(); ++ CondaEcosystemModifyDllSearchPath_Init(); ++#endif + return _PyRuntimeState_Init(&_PyRuntime); + } + diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0008-Doing-d1trimfile.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0008-Doing-d1trimfile.patch new file mode 100644 index 0000000000000000000000000000000000000000..ddc6d25b2fbe61c1b72c3c9842faf8c2c2f1c601 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0008-Doing-d1trimfile.patch @@ -0,0 +1,961 @@ +From a638bbff1f76630d0b85554018670b6745b6a64e Mon Sep 17 00:00:00 2001 +From: Ray Donnelly +Date: Tue, 31 Dec 2019 21:47:47 +0100 +Subject: [PATCH 08/26] Doing d1trimfile + +--- + PCbuild/_asyncio.vcxproj | 20 ++++++++++++++++++++ + PCbuild/_bz2.vcxproj | 6 +++++- + PCbuild/_ctypes.vcxproj | 4 ++++ + PCbuild/_ctypes_test.vcxproj | 20 ++++++++++++++++++++ + PCbuild/_decimal.vcxproj | 4 ++++ + PCbuild/_elementtree.vcxproj | 6 +++++- + PCbuild/_freeze_module.vcxproj | 4 ++++ + PCbuild/_hashlib.vcxproj | 12 ++++++++++++ + PCbuild/_lzma.vcxproj | 4 ++++ + PCbuild/_multiprocessing.vcxproj | 14 +++++++++++++- + PCbuild/_overlapped.vcxproj | 14 +++++++++++++- + PCbuild/_queue.vcxproj | 20 ++++++++++++++++++++ + PCbuild/_socket.vcxproj | 14 +++++++++++++- + PCbuild/_sqlite3.vcxproj | 4 ++++ + PCbuild/_ssl.vcxproj | 12 ++++++++++++ + PCbuild/_testbuffer.vcxproj | 22 +++++++++++++++++++++- + PCbuild/_testcapi.vcxproj | 20 ++++++++++++++++++++ + PCbuild/_testconsole.vcxproj | 6 +++++- + PCbuild/_testembed.vcxproj | 6 +++++- + PCbuild/_testimportmultiple.vcxproj | 20 ++++++++++++++++++++ + PCbuild/_testinternalcapi.vcxproj | 20 ++++++++++++++++++++ + PCbuild/_testmultiphase.vcxproj | 6 +++++- + PCbuild/_tkinter.vcxproj | 4 ++++ + PCbuild/liblzma.vcxproj | 4 ++++ + PCbuild/pyexpat.vcxproj | 4 ++++ + PCbuild/pylauncher.vcxproj | 4 ++++ + PCbuild/pyshellext.vcxproj | 6 +++++- + PCbuild/python.vcxproj | 4 ++++ + PCbuild/python3dll.vcxproj | 6 +++++- + PCbuild/python_uwp.vcxproj | 2 +- + PCbuild/pythoncore.vcxproj | 2 +- + PCbuild/pythonw.vcxproj | 14 +++++++++++++- + PCbuild/pythonw_uwp.vcxproj | 2 +- + PCbuild/pywlauncher.vcxproj | 6 +++++- + PCbuild/select.vcxproj | 14 +++++++++++++- + PCbuild/unicodedata.vcxproj | 22 +++++++++++++++++++++- + PCbuild/venvlauncher.vcxproj | 4 ++++ + PCbuild/venvwlauncher.vcxproj | 4 ++++ + PCbuild/winsound.vcxproj | 14 +++++++++++++- + PCbuild/xxlimited.vcxproj | 6 ++++++ + PCbuild/xxlimited_35.vcxproj | 6 ++++++ + 41 files changed, 367 insertions(+), 19 deletions(-) + +diff --git a/PCbuild/_asyncio.vcxproj b/PCbuild/_asyncio.vcxproj +index 76b0ffd660d..1402860e19b 100644 +--- a/PCbuild/_asyncio.vcxproj ++++ b/PCbuild/_asyncio.vcxproj +@@ -91,6 +91,26 @@ + + <_ProjectFileVersion>10.0.30319.1 + ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ + + + +diff --git a/PCbuild/_bz2.vcxproj b/PCbuild/_bz2.vcxproj +index e0dc6ec187a..30ad0dc4864 100644 +--- a/PCbuild/_bz2.vcxproj ++++ b/PCbuild/_bz2.vcxproj +@@ -97,6 +97,10 @@ + $(bz2Dir);%(AdditionalIncludeDirectories) + WIN32;_FILE_OFFSET_BITS=64;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;%(PreprocessorDefinitions) + 4244;4267;%(DisableSpecificWarnings) ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% + + + +@@ -125,4 +129,4 @@ + + + +- +\ No newline at end of file ++ +diff --git a/PCbuild/_ctypes.vcxproj b/PCbuild/_ctypes.vcxproj +index 63d5fa49cd4..6329f3d960f 100644 +--- a/PCbuild/_ctypes.vcxproj ++++ b/PCbuild/_ctypes.vcxproj +@@ -95,6 +95,10 @@ + + + USING_MALLOC_CLOSURE_DOT_C=1;%(PreprocessorDefinitions) ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% + + + /EXPORT:DllGetClassObject,PRIVATE /EXPORT:DllCanUnloadNow,PRIVATE %(AdditionalOptions) +diff --git a/PCbuild/_ctypes_test.vcxproj b/PCbuild/_ctypes_test.vcxproj +index f15b80852e3..e565441ca4c 100644 +--- a/PCbuild/_ctypes_test.vcxproj ++++ b/PCbuild/_ctypes_test.vcxproj +@@ -93,6 +93,26 @@ + + <_ProjectFileVersion>10.0.30319.1 + ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ + + + +diff --git a/PCbuild/_decimal.vcxproj b/PCbuild/_decimal.vcxproj +index ee7421484b5..e9d60b4db1a 100644 +--- a/PCbuild/_decimal.vcxproj ++++ b/PCbuild/_decimal.vcxproj +@@ -99,6 +99,10 @@ + CONFIG_64;ANSI;%(PreprocessorDefinitions) + CONFIG_64;MASM;%(PreprocessorDefinitions) + ..\Modules\_decimal;..\Modules\_decimal\windows;$(mpdecimalDir)\libmpdec;%(AdditionalIncludeDirectories) ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% + + + +diff --git a/PCbuild/_elementtree.vcxproj b/PCbuild/_elementtree.vcxproj +index 3eb9c89bcb6..920656f2ee2 100644 +--- a/PCbuild/_elementtree.vcxproj ++++ b/PCbuild/_elementtree.vcxproj +@@ -94,7 +94,11 @@ + + + ..\Modules\expat;%(AdditionalIncludeDirectories) +- _CRT_SECURE_NO_WARNINGS;XML_STATIC;%(PreprocessorDefinitions) ++ _CRT_SECURE_NO_WARNINGS;USE_PYEXPAT_CAPI;XML_STATIC;%(PreprocessorDefinitions) ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% + + + +diff --git a/PCbuild/_freeze_module.vcxproj b/PCbuild/_freeze_module.vcxproj +index 5ceddf759b8..6b113ad8c2e 100644 +--- a/PCbuild/_freeze_module.vcxproj ++++ b/PCbuild/_freeze_module.vcxproj +@@ -93,6 +93,10 @@ + Disabled + false + %(AdditionalOptions) -fno-lto ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% + + + Console +diff --git a/PCbuild/_hashlib.vcxproj b/PCbuild/_hashlib.vcxproj +index 2cd205224bc..1ff3a9cdeca 100644 +--- a/PCbuild/_hashlib.vcxproj ++++ b/PCbuild/_hashlib.vcxproj +@@ -96,6 +96,18 @@ + + ws2_32.lib;%(AdditionalDependencies) + ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ + + + +diff --git a/PCbuild/_lzma.vcxproj b/PCbuild/_lzma.vcxproj +index 40107d4b76c..321f41d8d27 100644 +--- a/PCbuild/_lzma.vcxproj ++++ b/PCbuild/_lzma.vcxproj +@@ -95,6 +95,10 @@ + + $(lzmaDir)src/liblzma/api;%(AdditionalIncludeDirectories) + WIN32;_FILE_OFFSET_BITS=64;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;LZMA_API_STATIC;%(PreprocessorDefinitions) ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% + + + $(OutDir)liblzma$(PyDebugExt).lib;%(AdditionalDependencies) +diff --git a/PCbuild/_multiprocessing.vcxproj b/PCbuild/_multiprocessing.vcxproj +index a65397f532a..451ca375990 100644 +--- a/PCbuild/_multiprocessing.vcxproj ++++ b/PCbuild/_multiprocessing.vcxproj +@@ -95,6 +95,18 @@ + + ws2_32.lib;%(AdditionalDependencies) + ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ + + + +@@ -115,4 +127,4 @@ + + + +- +\ No newline at end of file ++ +diff --git a/PCbuild/_overlapped.vcxproj b/PCbuild/_overlapped.vcxproj +index 224bf05d530..f7efa63f562 100644 +--- a/PCbuild/_overlapped.vcxproj ++++ b/PCbuild/_overlapped.vcxproj +@@ -95,6 +95,18 @@ + + ws2_32.lib;%(AdditionalDependencies) + ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ + + + +@@ -111,4 +123,4 @@ + + + +- +\ No newline at end of file ++ +diff --git a/PCbuild/_queue.vcxproj b/PCbuild/_queue.vcxproj +index 80a1c3c6a4a..8d4555299ae 100644 +--- a/PCbuild/_queue.vcxproj ++++ b/PCbuild/_queue.vcxproj +@@ -91,6 +91,26 @@ + + <_ProjectFileVersion>10.0.30319.1 + ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ + + + +diff --git a/PCbuild/_socket.vcxproj b/PCbuild/_socket.vcxproj +index 41af0895921..45ecbcc4641 100644 +--- a/PCbuild/_socket.vcxproj ++++ b/PCbuild/_socket.vcxproj +@@ -95,6 +95,18 @@ + + ws2_32.lib;iphlpapi.lib;Rpcrt4.lib;%(AdditionalDependencies) + ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ + + + +@@ -114,4 +126,4 @@ + + + +- +\ No newline at end of file ++ +diff --git a/PCbuild/_sqlite3.vcxproj b/PCbuild/_sqlite3.vcxproj +index f482734ba1d..70943daa021 100644 +--- a/PCbuild/_sqlite3.vcxproj ++++ b/PCbuild/_sqlite3.vcxproj +@@ -95,6 +95,10 @@ + + $(condaDir)\include;%(AdditionalIncludeDirectories) + PY_SQLITE_HAVE_SERIALIZE;PY_SQLITE_ENABLE_LOAD_EXTENSION;%(PreprocessorDefinitions) ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% + + + $(condaDir)\lib\sqlite3.lib;%(AdditionalDependencies) +diff --git a/PCbuild/_ssl.vcxproj b/PCbuild/_ssl.vcxproj +index ce21f992ff8..34561515c12 100644 +--- a/PCbuild/_ssl.vcxproj ++++ b/PCbuild/_ssl.vcxproj +@@ -96,6 +96,18 @@ + + ws2_32.lib;crypt32.lib;%(AdditionalDependencies) + ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ + + + +diff --git a/PCbuild/_testbuffer.vcxproj b/PCbuild/_testbuffer.vcxproj +index 4e721e8ce09..3fec7516ed5 100644 +--- a/PCbuild/_testbuffer.vcxproj ++++ b/PCbuild/_testbuffer.vcxproj +@@ -92,6 +92,26 @@ + + <_ProjectFileVersion>10.0.40219.1 + ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ + + + +@@ -106,4 +126,4 @@ + + + +- +\ No newline at end of file ++ +diff --git a/PCbuild/_testcapi.vcxproj b/PCbuild/_testcapi.vcxproj +index a68f15d25aa..5c42f15c312 100644 +--- a/PCbuild/_testcapi.vcxproj ++++ b/PCbuild/_testcapi.vcxproj +@@ -92,6 +92,26 @@ + + <_ProjectFileVersion>10.0.30319.1 + ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ + + + +diff --git a/PCbuild/_testconsole.vcxproj b/PCbuild/_testconsole.vcxproj +index 69d312b17a5..bee3326ef8d 100644 +--- a/PCbuild/_testconsole.vcxproj ++++ b/PCbuild/_testconsole.vcxproj +@@ -92,6 +92,10 @@ + + + _CONSOLE;%(PreprocessorDefinitions) ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% + + + Console +@@ -112,4 +116,4 @@ + + + +- +\ No newline at end of file ++ +diff --git a/PCbuild/_testembed.vcxproj b/PCbuild/_testembed.vcxproj +index a7ea8787e0c..e8edb3dd752 100644 +--- a/PCbuild/_testembed.vcxproj ++++ b/PCbuild/_testembed.vcxproj +@@ -89,6 +89,10 @@ + + + _CONSOLE;%(PreprocessorDefinitions) ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% + + + Console +@@ -109,4 +113,4 @@ + + + +- +\ No newline at end of file ++ +diff --git a/PCbuild/_testimportmultiple.vcxproj b/PCbuild/_testimportmultiple.vcxproj +index c35ac83c1c7..c9d7f5d22b7 100644 +--- a/PCbuild/_testimportmultiple.vcxproj ++++ b/PCbuild/_testimportmultiple.vcxproj +@@ -92,6 +92,26 @@ + + <_ProjectFileVersion>10.0.30319.1 + ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ + + + +diff --git a/PCbuild/_testinternalcapi.vcxproj b/PCbuild/_testinternalcapi.vcxproj +index f7e050b7c74..58c3e10c0f0 100644 +--- a/PCbuild/_testinternalcapi.vcxproj ++++ b/PCbuild/_testinternalcapi.vcxproj +@@ -92,6 +92,26 @@ + + <_ProjectFileVersion>10.0.30319.1 + ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ + + + +diff --git a/PCbuild/_testmultiphase.vcxproj b/PCbuild/_testmultiphase.vcxproj +index e730fe308ab..a6f13ef31dc 100644 +--- a/PCbuild/_testmultiphase.vcxproj ++++ b/PCbuild/_testmultiphase.vcxproj +@@ -92,6 +92,10 @@ + + + _CONSOLE;%(PreprocessorDefinitions) ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% + + + Console +@@ -112,4 +116,4 @@ + + + +- +\ No newline at end of file ++ +diff --git a/PCbuild/_tkinter.vcxproj b/PCbuild/_tkinter.vcxproj +index 87f6005fffc..de9358312ac 100644 +--- a/PCbuild/_tkinter.vcxproj ++++ b/PCbuild/_tkinter.vcxproj +@@ -97,6 +97,10 @@ + TCL_WITH_EXTERNAL_TOMMATH;%(PreprocessorDefinitions) + WITH_APPINIT;%(PreprocessorDefinitions) + Py_TCLTK_DIR="$(tcltkDir.TrimEnd('\').Replace('\', '\\'))";%(PreprocessorDefinitions) ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% + + + $(tcltkLib);%(AdditionalDependencies) +diff --git a/PCbuild/liblzma.vcxproj b/PCbuild/liblzma.vcxproj +index 97938692328..212fb5e1ebc 100644 +--- a/PCbuild/liblzma.vcxproj ++++ b/PCbuild/liblzma.vcxproj +@@ -95,6 +95,10 @@ + $(lzmaDir)windows/vs2019;$(lzmaDir)src/liblzma/common;$(lzmaDir)src/common;$(lzmaDir)src/liblzma/api;$(lzmaDir)src/liblzma/check;$(lzmaDir)src/liblzma/delta;$(lzmaDir)src/liblzma/lz;$(lzmaDir)src/liblzma/lzma;$(lzmaDir)src/liblzma/rangecoder;$(lzmaDir)src/liblzma/simple;%(AdditionalIncludeDirectories) + 4244;4267;4996;%(DisableSpecificWarnings) + %(AdditionalOptions) -Wno-deprecated-declarations ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% + + + +diff --git a/PCbuild/pyexpat.vcxproj b/PCbuild/pyexpat.vcxproj +index dc9161a8b29..3bcef600a3e 100644 +--- a/PCbuild/pyexpat.vcxproj ++++ b/PCbuild/pyexpat.vcxproj +@@ -92,6 +92,10 @@ + + $(PySourcePath)Modules\expat;%(AdditionalIncludeDirectories) + _CRT_SECURE_NO_WARNINGS;PYEXPAT_EXPORTS;XML_STATIC;%(PreprocessorDefinitions) ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% + + + +diff --git a/PCbuild/pylauncher.vcxproj b/PCbuild/pylauncher.vcxproj +index ca422ef4d02..0c692649ed6 100644 +--- a/PCbuild/pylauncher.vcxproj ++++ b/PCbuild/pylauncher.vcxproj +@@ -93,6 +93,10 @@ + + _CONSOLE;%(PreprocessorDefinitions) + MultiThreaded ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% + + + shell32.lib;pathcch.lib;%(AdditionalDependencies) +diff --git a/PCbuild/pyshellext.vcxproj b/PCbuild/pyshellext.vcxproj +index ea432d6bc9a..50397324a20 100644 +--- a/PCbuild/pyshellext.vcxproj ++++ b/PCbuild/pyshellext.vcxproj +@@ -92,6 +92,10 @@ + + + _CONSOLE;%(PreprocessorDefinitions) ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% + + + version.lib;shlwapi.lib;%(AdditionalDependencies) +@@ -114,4 +118,4 @@ + + + +- +\ No newline at end of file ++ +diff --git a/PCbuild/python.vcxproj b/PCbuild/python.vcxproj +index ac5f96ebafc..3d0caa906cf 100644 +--- a/PCbuild/python.vcxproj ++++ b/PCbuild/python.vcxproj +@@ -92,6 +92,10 @@ + + + Py_BUILD_CORE;_CONSOLE;%(PreprocessorDefinitions) ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% + + + Console +diff --git a/PCbuild/python3dll.vcxproj b/PCbuild/python3dll.vcxproj +index 235ea1cf9d3..d861f6c6a43 100644 +--- a/PCbuild/python3dll.vcxproj ++++ b/PCbuild/python3dll.vcxproj +@@ -93,6 +93,10 @@ + + PYTHON_DLL_NAME="$(PyDllName)";%(PreprocessorDefinitions) + false ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% + + + true +@@ -107,4 +111,4 @@ + + + +- +\ No newline at end of file ++ +diff --git a/PCbuild/python_uwp.vcxproj b/PCbuild/python_uwp.vcxproj +index 3f8772d30b4..d80968e351a 100644 +--- a/PCbuild/python_uwp.vcxproj ++++ b/PCbuild/python_uwp.vcxproj +@@ -90,7 +90,7 @@ + + + %(PreprocessorDefinitions) +- /EHsc /std:c++17 %(AdditionalOptions) ++ /d1trimfile:%SRC_DIR% + + + windowsapp.lib;%(AdditionalDependencies) +diff --git a/PCbuild/pythoncore.vcxproj b/PCbuild/pythoncore.vcxproj +index b911c938563..8e45967a83c 100644 +--- a/PCbuild/pythoncore.vcxproj ++++ b/PCbuild/pythoncore.vcxproj +@@ -99,7 +99,7 @@ + + + +- /Zm200 %(AdditionalOptions) ++ /d1trimfile:%SRC_DIR% + $(PySourcePath)Modules\_hacl;$(PySourcePath)Modules\_hacl\include;$(PySourcePath)Python;%(AdditionalIncludeDirectories) + $(zlibNgDir);$(GeneratedZlibNgDir);%(AdditionalIncludeDirectories) + $(GeneratedJitStencilsDir);%(AdditionalIncludeDirectories) +diff --git a/PCbuild/pythonw.vcxproj b/PCbuild/pythonw.vcxproj +index 74bd19144f9..6fea2e1f70c 100644 +--- a/PCbuild/pythonw.vcxproj ++++ b/PCbuild/pythonw.vcxproj +@@ -96,6 +96,18 @@ + + 3000000 + ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ + + + +@@ -118,4 +130,4 @@ + + + +- +\ No newline at end of file ++ +diff --git a/PCbuild/pythonw_uwp.vcxproj b/PCbuild/pythonw_uwp.vcxproj +index f548d022642..fa4e75f9712 100644 +--- a/PCbuild/pythonw_uwp.vcxproj ++++ b/PCbuild/pythonw_uwp.vcxproj +@@ -90,7 +90,7 @@ + + + PYTHONW;%(PreprocessorDefinitions) +- /EHsc /std:c++17 %(AdditionalOptions) ++ /d1trimfile:%SRC_DIR% + + + windowsapp.lib;%(AdditionalDependencies) +diff --git a/PCbuild/pywlauncher.vcxproj b/PCbuild/pywlauncher.vcxproj +index 1694548935a..9be580e2663 100644 +--- a/PCbuild/pywlauncher.vcxproj ++++ b/PCbuild/pywlauncher.vcxproj +@@ -93,6 +93,10 @@ + + _WINDOWS;%(PreprocessorDefinitions) + MultiThreaded ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% + + + shell32.lib;pathcch.lib;%(AdditionalDependencies) +@@ -111,4 +115,4 @@ + + + +- +\ No newline at end of file ++ +diff --git a/PCbuild/select.vcxproj b/PCbuild/select.vcxproj +index d7448fd4d72..9fab5e8a638 100644 +--- a/PCbuild/select.vcxproj ++++ b/PCbuild/select.vcxproj +@@ -94,6 +94,18 @@ + + ws2_32.lib;%(AdditionalDependencies) + ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ + + + +@@ -110,4 +122,4 @@ + + + +- +\ No newline at end of file ++ +diff --git a/PCbuild/unicodedata.vcxproj b/PCbuild/unicodedata.vcxproj +index 781f938e2ab..3870c85adf7 100644 +--- a/PCbuild/unicodedata.vcxproj ++++ b/PCbuild/unicodedata.vcxproj +@@ -91,6 +91,26 @@ + + <_ProjectFileVersion>10.0.30319.1 + ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ + + + +@@ -110,4 +130,4 @@ + + + +- +\ No newline at end of file ++ +diff --git a/PCbuild/venvlauncher.vcxproj b/PCbuild/venvlauncher.vcxproj +index abaf3a979af..324aadcd782 100644 +--- a/PCbuild/venvlauncher.vcxproj ++++ b/PCbuild/venvlauncher.vcxproj +@@ -94,6 +94,10 @@ + + EXENAME=L"$(PyExeName)$(PyDebugExt).exe";_CONSOLE;%(PreprocessorDefinitions) + MultiThreaded ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% + + + PY_ICON;%(PreprocessorDefinitions) +diff --git a/PCbuild/venvwlauncher.vcxproj b/PCbuild/venvwlauncher.vcxproj +index c58280deb8a..4dacf7f2724 100644 +--- a/PCbuild/venvwlauncher.vcxproj ++++ b/PCbuild/venvwlauncher.vcxproj +@@ -94,6 +94,10 @@ + + EXENAME=L"$(PyWExeName)$(PyDebugExt).exe";_WINDOWS;%(PreprocessorDefinitions) + MultiThreaded ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% + + + PYW_ICON;%(PreprocessorDefinitions) +diff --git a/PCbuild/winsound.vcxproj b/PCbuild/winsound.vcxproj +index c26029b15a3..1e543b31c41 100644 +--- a/PCbuild/winsound.vcxproj ++++ b/PCbuild/winsound.vcxproj +@@ -96,6 +96,18 @@ + + winmm.lib;%(AdditionalDependencies) + ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ ++ ++ /d1trimfile:%SRC_DIR% ++ + + + +@@ -112,4 +124,4 @@ + + + +- +\ No newline at end of file ++ +diff --git a/PCbuild/xxlimited.vcxproj b/PCbuild/xxlimited.vcxproj +index 093e6920c0b..19dd43c19c2 100644 +--- a/PCbuild/xxlimited.vcxproj ++++ b/PCbuild/xxlimited.vcxproj +@@ -93,6 +93,12 @@ + <_ProjectFileVersion>10.0.30319.1 + + ++ ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ + + wsock32.lib;%(AdditionalDependencies) + +diff --git a/PCbuild/xxlimited_35.vcxproj b/PCbuild/xxlimited_35.vcxproj +index 3f4d4463f24..2572449ba0c 100644 +--- a/PCbuild/xxlimited_35.vcxproj ++++ b/PCbuild/xxlimited_35.vcxproj +@@ -93,6 +93,12 @@ + <_ProjectFileVersion>10.0.30319.1 + + ++ ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ /d1trimfile:%SRC_DIR% ++ + + wsock32.lib;%(AdditionalDependencies) + diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0009-cross-compile-darwin.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0009-cross-compile-darwin.patch new file mode 100644 index 0000000000000000000000000000000000000000..f7341d9a32da785fa828f3187d0250eedb725824 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0009-cross-compile-darwin.patch @@ -0,0 +1,78 @@ +From 8b28429cdaf8b18f8a5f41b640c4c72c8e45897a Mon Sep 17 00:00:00 2001 +From: Ray Donnelly +Date: Fri, 2 Oct 2020 00:03:12 +0200 +Subject: [PATCH 09/26] cross compile darwin + +By Isuru Fernando. +--- + Lib/platform.py | 7 ++++++- + configure | 6 ++++++ + configure.ac | 6 ++++++ + 3 files changed, 18 insertions(+), 1 deletion(-) + +diff --git a/Lib/platform.py b/Lib/platform.py +index b017b841311..f7821ae7f28 100644 +--- a/Lib/platform.py ++++ b/Lib/platform.py +@@ -477,7 +477,12 @@ def win32_ver(release='', version='', csd='', ptype=''): + def _mac_ver_xml(): + fn = '/System/Library/CoreServices/SystemVersion.plist' + if not os.path.exists(fn): +- return None ++ if 'SDKROOT' in os.environ: ++ fn = os.environ['SDKROOT'] + fn ++ if not os.path.exists(fn): ++ return None ++ else: ++ return None + + try: + import plistlib +diff --git a/configure b/configure +index 8cfdda5a29b..be7e9c6713d 100755 +--- a/configure ++++ b/configure +@@ -4111,6 +4111,9 @@ then + *-*-linux*) + ac_sys_system=Linux + ;; ++ *-*-darwin*) ++ ac_sys_system=Darwin ++ ;; + *-*-cygwin*) + ac_sys_system=Cygwin + ;; +@@ -4590,6 +4593,9 @@ if test "$cross_compiling" = yes; then + _host_ident=$host_cpu + esac + ;; ++ *-*-darwin*) ++ _host_ident=$host_cpu ++ ;; + *-*-cygwin*) + _host_ident= + ;; +diff --git a/configure.ac b/configure.ac +index 1acb91fd27b..73fe005fa3d 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -324,6 +324,9 @@ then + *-*-linux*) + ac_sys_system=Linux + ;; ++ *-*-darwin*) ++ ac_sys_system=Darwin ++ ;; + *-*-cygwin*) + ac_sys_system=Cygwin + ;; +@@ -771,6 +774,9 @@ if test "$cross_compiling" = yes; then + _host_ident=$host_cpu + esac + ;; ++ *-*-darwin*) ++ _host_ident=$host_cpu ++ ;; + *-*-cygwin*) + _host_ident= + ;; diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0010-Fix-TZPATH-on-windows.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0010-Fix-TZPATH-on-windows.patch new file mode 100644 index 0000000000000000000000000000000000000000..6aacbd362888d88d98dd60772412fcabfd8ec412 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0010-Fix-TZPATH-on-windows.patch @@ -0,0 +1,29 @@ +From f82fdb4890d33fa85807a8d9d8285df2c7580520 Mon Sep 17 00:00:00 2001 +From: Isuru Fernando +Date: Wed, 7 Oct 2020 10:08:30 -0500 +Subject: [PATCH 10/26] Fix TZPATH on windows + +--- + Lib/sysconfig/__init__.py | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/Lib/sysconfig/__init__.py b/Lib/sysconfig/__init__.py +index faf8273bd0b..9e6d9257cf7 100644 +--- a/Lib/sysconfig/__init__.py ++++ b/Lib/sysconfig/__init__.py +@@ -175,6 +175,7 @@ def joinuser(*args): + _PY_VERSION = sys.version.split()[0] + _PY_VERSION_SHORT = f'{sys.version_info[0]}.{sys.version_info[1]}' + _PY_VERSION_SHORT_NO_DOT = f'{sys.version_info[0]}{sys.version_info[1]}' ++_PREFIX = os.path.normpath(sys.prefix) + _BASE_PREFIX = os.path.normpath(sys.base_prefix) + _BASE_EXEC_PREFIX = os.path.normpath(sys.base_exec_prefix) + # Mutex guarding initialization of _CONFIG_VARS. +@@ -555,6 +556,7 @@ def _init_config_vars(): + if os.name == 'nt': + _init_non_posix(_CONFIG_VARS) + _CONFIG_VARS['VPATH'] = sys._vpath ++ _CONFIG_VARS['TZPATH'] = os.path.join(_PREFIX, "share", "zoneinfo") + if _HAS_USER_BASE: + # Setting 'userbase' is done below the call to the + # init function to enable using 'get_config_var' in diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0011-Make-dyld-search-work-with-SYSTEM_VERSION_COMPAT-1.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0011-Make-dyld-search-work-with-SYSTEM_VERSION_COMPAT-1.patch new file mode 100644 index 0000000000000000000000000000000000000000..c944159931f9caf7f6007734c4810b1893b0b3c7 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0011-Make-dyld-search-work-with-SYSTEM_VERSION_COMPAT-1.patch @@ -0,0 +1,44 @@ +From 4bedca8871c1bbe2f5a5a90db8559791f6e9247b Mon Sep 17 00:00:00 2001 +From: Isuru Fernando +Date: Mon, 25 Jan 2021 03:28:08 -0600 +Subject: [PATCH 11/26] Make dyld search work with SYSTEM_VERSION_COMPAT=1 + +In macOS Big Sur, if the executable was compiled with `MACOSX_DEPLOYMENT_TARGET=10.15` +or below, then SYSTEM_VERSION_COMPAT=1 is the default which means that Big Sur +reports itself as 10.16 which means that `__builtin_available(macOS 11.0)` will not be triggered. + +This can be observed by using the python 3.9.1 universal2 installer and using it on +x86_64 Big Sur or with Rossetta 2 on arm64 Big Sur. (Not an issue with native arm64 +as that part is compiled with `MACOSX_DEPLOYMENT_TARGET=11.0`) + +We also suppress a warning due to the mismatch between header using 11.0 +and this code using 10.16 +--- + Modules/_ctypes/callproc.c | 6 ++++-- + 1 file changed, 4 insertions(+), 2 deletions(-) + +diff --git a/Modules/_ctypes/callproc.c b/Modules/_ctypes/callproc.c +index 856b0376e5e..8d269ac5969 100644 +--- a/Modules/_ctypes/callproc.c ++++ b/Modules/_ctypes/callproc.c +@@ -1509,7 +1509,7 @@ copy_com_pointer(PyObject *self, PyObject *args) + #ifdef HAVE_DYLD_SHARED_CACHE_CONTAINS_PATH + # ifdef HAVE_BUILTIN_AVAILABLE + # define HAVE_DYLD_SHARED_CACHE_CONTAINS_PATH_RUNTIME \ +- __builtin_available(macOS 11.0, iOS 14.0, tvOS 14.0, watchOS 7.0, *) ++ __builtin_available(macOS 10.16, iOS 14.0, tvOS 14.0, watchOS 7.0, *) + # else + # define HAVE_DYLD_SHARED_CACHE_CONTAINS_PATH_RUNTIME \ + (_dyld_shared_cache_contains_path != NULL) +@@ -1552,8 +1552,10 @@ static PyObject *py_dyld_shared_cache_contains_path(PyObject *self, PyObject *ar + if (PyUnicode_FSConverter(name, &name2) == 0) + return NULL; + name_str = PyBytes_AS_STRING(name2); +- ++#pragma clang diagnostic push ++#pragma clang diagnostic ignored "-Wunguarded-availability-new" + r = _dyld_shared_cache_contains_path(name_str); ++#pragma clang diagnostic pop + Py_DECREF(name2); + + if (r) { diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0012-Unvendor-bzip2.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0012-Unvendor-bzip2.patch new file mode 100644 index 0000000000000000000000000000000000000000..cb3f8751d42f987f32bbdb7a9d2be2f7e537a48f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0012-Unvendor-bzip2.patch @@ -0,0 +1,94 @@ +From a29058e2c62aea787df5ae1bc3e7e7c3d9f4e153 Mon Sep 17 00:00:00 2001 +From: Isuru Fernando +Date: Mon, 16 Aug 2021 02:56:27 -0700 +Subject: [PATCH 12/26] Unvendor bzip2 + +--- + PCbuild/_bz2.vcxproj | 15 +++++---------- + PCbuild/_bz2.vcxproj.filters | 28 ++-------------------------- + 2 files changed, 7 insertions(+), 36 deletions(-) + +diff --git a/PCbuild/_bz2.vcxproj b/PCbuild/_bz2.vcxproj +index 30ad0dc4864..1d46cc8198f 100644 +--- a/PCbuild/_bz2.vcxproj ++++ b/PCbuild/_bz2.vcxproj +@@ -94,7 +94,7 @@ + + + +- $(bz2Dir);%(AdditionalIncludeDirectories) ++ $(condaDir)\include;%(AdditionalIncludeDirectories) + WIN32;_FILE_OFFSET_BITS=64;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;%(PreprocessorDefinitions) + 4244;4267;%(DisableSpecificWarnings) + /d1trimfile:%SRC_DIR% +@@ -102,20 +102,15 @@ + /d1trimfile:%SRC_DIR% + /d1trimfile:%SRC_DIR% + ++ ++ $(condaDir)\lib\bzip2.lib;%(AdditionalDependencies) ++ + + + +- +- +- +- +- +- +- + + +- +- ++ + + + +diff --git a/PCbuild/_bz2.vcxproj.filters b/PCbuild/_bz2.vcxproj.filters +index 7c0b5162537..ed9510978f1 100644 +--- a/PCbuild/_bz2.vcxproj.filters ++++ b/PCbuild/_bz2.vcxproj.filters +@@ -21,33 +21,9 @@ + + Source Files + +- +- Source Files\bzip2 +- +- +- Source Files\bzip2 +- +- +- Source Files\bzip2 +- +- +- Source Files\bzip2 +- +- +- Source Files\bzip2 +- +- +- Source Files\bzip2 +- +- +- Source Files\bzip2 +- + + +- +- Header Files\bzip2 +- +- ++ + Header Files\bzip2 + + +@@ -56,4 +32,4 @@ + Resource Files + + +- +\ No newline at end of file ++ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0013-Unvendor-libffi.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0013-Unvendor-libffi.patch new file mode 100644 index 0000000000000000000000000000000000000000..adbecf617375c49fcffe80e5a689e18bf32e5c3f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0013-Unvendor-libffi.patch @@ -0,0 +1,39 @@ +From 0d896e048d3b7994ebce253e3210fddc3a6a004b Mon Sep 17 00:00:00 2001 +From: Isuru Fernando +Date: Mon, 16 Aug 2021 03:07:40 -0700 +Subject: [PATCH 13/26] Unvendor libffi + +--- + PCbuild/libffi.props | 17 ++++------------- + 1 file changed, 4 insertions(+), 13 deletions(-) + +diff --git a/PCbuild/libffi.props b/PCbuild/libffi.props +index 22c9550e2c0..40ddb08d2b0 100644 +--- a/PCbuild/libffi.props ++++ b/PCbuild/libffi.props +@@ -2,20 +2,11 @@ + + + +- $(libffiIncludeDir);%(AdditionalIncludeDirectories) ++ $(condaDir)\include;%(AdditionalIncludeDirectories) + + +- $(libffiOutDir);%(AdditionalLibraryDirectories) +- libffi-8.lib;%(AdditionalDependencies) ++ $(condaDir)\lib;%(AdditionalLibraryDirectories) ++ ffi.lib;%(AdditionalDependencies) + + +- +- <_LIBFFIDLL Include="$(libffiOutDir)\libffi-8.dll" /> +- +- +- +- +- +- +- +- +\ No newline at end of file ++ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0014-Unvendor-tcltk.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0014-Unvendor-tcltk.patch new file mode 100644 index 0000000000000000000000000000000000000000..090887176c7aaeb0064461a0acd8e4239c37565e --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0014-Unvendor-tcltk.patch @@ -0,0 +1,49 @@ +From c5d8868e9c9862196d1f58eca51af9e6bf276a02 Mon Sep 17 00:00:00 2001 +From: Isuru Fernando +Date: Fri, 20 Aug 2021 10:23:51 -0700 +Subject: [PATCH 14/26] Unvendor tcltk + +--- + PCbuild/_tkinter.vcxproj | 6 ------ + PCbuild/tcltk.props | 11 +++++------ + 2 files changed, 5 insertions(+), 12 deletions(-) + +diff --git a/PCbuild/_tkinter.vcxproj b/PCbuild/_tkinter.vcxproj +index de9358312ac..3fe2c29c823 100644 +--- a/PCbuild/_tkinter.vcxproj ++++ b/PCbuild/_tkinter.vcxproj +@@ -128,12 +128,6 @@ + + + +- +- +- +- +- +- + + + +diff --git a/PCbuild/tcltk.props b/PCbuild/tcltk.props +index d26b36ba98e..40327f181d8 100644 +--- a/PCbuild/tcltk.props ++++ b/PCbuild/tcltk.props +@@ -12,12 +12,11 @@ + $([System.Version]::Parse($(TkVersion)).Minor) + $([System.Version]::Parse($(TkVersion)).Build) + $([System.Version]::Parse($(TkVersion)).Revision) +- $(ExternalsDir)tcl-core-$(TclVersion)\ +- $(ExternalsDir)tk-$(TkVersion)\ +- $(ExternalsDir)tcltk-$(TclVersion)\$(ArchName)\ +- $(tcltkDir)\bin\tclsh$(TclMajorVersion)$(TclMinorVersion)t.exe +- $(tcltkDir)\..\win32\bin\tclsh$(TclMajorVersion)$(TclMinorVersion)t.exe +- TCL_WITH_EXTERNAL_TOMMATH; ++ $(condaDir) ++ $(condaDir) ++ $(condaDir) ++ $(condaDir) ++ $(condaDir)\bin\tclsh$(TclMajorVersion)$(TclMinorVersion)t.exe + + + t diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0015-unvendor-xz.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0015-unvendor-xz.patch new file mode 100644 index 0000000000000000000000000000000000000000..af29c9c2c1e81d40d85f8e75ad19b1ea249b4462 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0015-unvendor-xz.patch @@ -0,0 +1,43 @@ +From a6696e3a1910a1f70febf1dc65c7ae0ebb4e9da9 Mon Sep 17 00:00:00 2001 +From: Isuru Fernando +Date: Sat, 25 Sep 2021 10:07:05 -0700 +Subject: [PATCH 15/26] unvendor xz + +--- + PCbuild/_lzma.vcxproj | 10 +++------- + 1 file changed, 3 insertions(+), 7 deletions(-) + +diff --git a/PCbuild/_lzma.vcxproj b/PCbuild/_lzma.vcxproj +index 321f41d8d27..6811fd1709e 100644 +--- a/PCbuild/_lzma.vcxproj ++++ b/PCbuild/_lzma.vcxproj +@@ -93,15 +93,15 @@ + + + +- $(lzmaDir)src/liblzma/api;%(AdditionalIncludeDirectories) +- WIN32;_FILE_OFFSET_BITS=64;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;LZMA_API_STATIC;%(PreprocessorDefinitions) ++ $(condaDir)\include;%(AdditionalIncludeDirectories) ++ WIN32;_FILE_OFFSET_BITS=64;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;%(PreprocessorDefinitions) + /d1trimfile:%SRC_DIR% + /d1trimfile:%SRC_DIR% + /d1trimfile:%SRC_DIR% + /d1trimfile:%SRC_DIR% + + +- $(OutDir)liblzma$(PyDebugExt).lib;%(AdditionalDependencies) ++ $(condaDir)\lib\lzma.lib;%(AdditionalDependencies) + + + +@@ -115,10 +115,6 @@ + {cf7ac3d1-e2df-41d2-bea6-1e2556cdea26} + false + +- +- {12728250-16eC-4dc6-94d7-e21dd88947f8} +- false +- + + + diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0016-unvendor-zlib.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0016-unvendor-zlib.patch new file mode 100644 index 0000000000000000000000000000000000000000..30757e8016f0d0ffd730ff921b1dde08bcc5d35b --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0016-unvendor-zlib.patch @@ -0,0 +1,140 @@ +From 5a3effe6f9518217a3343ff7f7aa17ec4a950f24 Mon Sep 17 00:00:00 2001 +From: Isuru Fernando +Date: Wed, 29 Sep 2021 15:21:55 -0700 +Subject: [PATCH 16/26] unvendor zlib + +--- + PCbuild/pythoncore.vcxproj | 14 ++----- + PCbuild/pythoncore.vcxproj.filters | 66 ------------------------------ + 2 files changed, 4 insertions(+), 76 deletions(-) + +diff --git a/PCbuild/pythoncore.vcxproj b/PCbuild/pythoncore.vcxproj +index 8e45967a83c..3674ca1b267 100644 +--- a/PCbuild/pythoncore.vcxproj ++++ b/PCbuild/pythoncore.vcxproj +@@ -82,7 +82,7 @@ + + true + true +- true ++ true + false + + +@@ -101,7 +101,7 @@ + + /d1trimfile:%SRC_DIR% + $(PySourcePath)Modules\_hacl;$(PySourcePath)Modules\_hacl\include;$(PySourcePath)Python;%(AdditionalIncludeDirectories) +- $(zlibNgDir);$(GeneratedZlibNgDir);%(AdditionalIncludeDirectories) ++ $(condaDir)\include;%(AdditionalIncludeDirectories) + $(GeneratedJitStencilsDir);%(AdditionalIncludeDirectories) + _USRDLL;Py_BUILD_CORE;Py_BUILD_CORE_BUILTIN;Py_ENABLE_SHARED;MS_DLL_ID="$(SysWinVer)";ZLIB_COMPAT;%(PreprocessorDefinitions) + _Py_HAVE_ZLIB;%(PreprocessorDefinitions) +@@ -112,8 +112,8 @@ + Py_REMOTE_DEBUG;%(PreprocessorDefinitions) + + +- version.lib;ws2_32.lib;pathcch.lib;bcrypt.lib;%(AdditionalDependencies) +- zlib-ng$(PyDebugExt).lib;%(AdditionalDependencies) ++ version.lib;ws2_32.lib;pathcch.lib;bcrypt.lib;zlib.lib;%(AdditionalDependencies) ++ $(condaDir)\lib;%(AdditionalLibraryDirectories) + + + +@@ -681,12 +681,6 @@ + + + +- +- +- {fb91c8b2-6fbc-3a01-b644-1637111f902d} +- false +- +- + + + +diff --git a/PCbuild/pythoncore.vcxproj.filters b/PCbuild/pythoncore.vcxproj.filters +index 0e6d42cc959..144a0e3425a 100644 +--- a/PCbuild/pythoncore.vcxproj.filters ++++ b/PCbuild/pythoncore.vcxproj.filters +@@ -900,39 +900,6 @@ + + Include\internal\mimalloc + +- +- Modules\zlib +- +- +- Modules\zlib +- +- +- Modules\zlib +- +- +- Modules\zlib +- +- +- Modules\zlib +- +- +- Modules\zlib +- +- +- Modules\zlib +- +- +- Modules\zlib +- +- +- Modules\zlib +- +- +- Modules\zlib +- +- +- Modules\zlib +- + + Include\internal + +@@ -1580,39 +1547,6 @@ + + Objects + +- +- Modules\zlib +- +- +- Modules\zlib +- +- +- Modules\zlib +- +- +- Modules\zlib +- +- +- Modules\zlib +- +- +- Modules\zlib +- +- +- Modules\zlib +- +- +- Modules\zlib +- +- +- Modules\zlib +- +- +- Modules\zlib +- +- +- Modules\zlib +- + + Python + diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0017-Do-not-pass-g-to-GCC-when-not-Py_DEBUG.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0017-Do-not-pass-g-to-GCC-when-not-Py_DEBUG.patch new file mode 100644 index 0000000000000000000000000000000000000000..7180c8c8714a5ddf4b5872bb3328ea0b936a76ff --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0017-Do-not-pass-g-to-GCC-when-not-Py_DEBUG.patch @@ -0,0 +1,49 @@ +From b10930f94b1032084975cfe5e38c2678932e88de Mon Sep 17 00:00:00 2001 +From: Ray Donnelly +Date: Wed, 16 Aug 2017 11:45:28 +0100 +Subject: [PATCH 17/26] Do not pass -g to GCC when not Py_DEBUG + +This bloats our exe and our modules a lot. +--- + configure | 6 +++--- + configure.ac | 2 +- + 2 files changed, 4 insertions(+), 4 deletions(-) + +diff --git a/configure b/configure +index be7e9c6713d..62acbe693c6 100755 +--- a/configure ++++ b/configure +@@ -5795,9 +5795,9 @@ if test $ac_test_CFLAGS; then + CFLAGS=$ac_save_CFLAGS + elif test $ac_cv_prog_cc_g = yes; then + if test "$GCC" = yes; then +- CFLAGS="-g -O2" ++ CFLAGS="-O2" + else +- CFLAGS="-g" ++ CFLAGS= + fi + else + if test "$GCC" = yes; then +@@ -9625,7 +9625,7 @@ then + if test "$Py_DEBUG" = 'true' ; then + OPT="-g $PYDEBUG_CFLAGS -Wall" + else +- OPT="-g -O3 -Wall" ++ OPT="-O3 -Wall" + fi + ;; + *) +diff --git a/configure.ac b/configure.ac +index 73fe005fa3d..da7353cd686 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -2317,7 +2317,7 @@ then + if test "$Py_DEBUG" = 'true' ; then + OPT="-g $PYDEBUG_CFLAGS -Wall" + else +- OPT="-g -O3 -Wall" ++ OPT="-O3 -Wall" + fi + ;; + *) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0018-Unvendor-expat.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0018-Unvendor-expat.patch new file mode 100644 index 0000000000000000000000000000000000000000..c433b567e076add7a1d17117ff3fce6af2916450 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0018-Unvendor-expat.patch @@ -0,0 +1,200 @@ +From 71fa4441a757e1e9dad7ae3ffaeb252700a86106 Mon Sep 17 00:00:00 2001 +From: Isuru Fernando +Date: Wed, 29 Mar 2023 23:07:10 -0500 +Subject: [PATCH 18/26] Unvendor expat + +--- + PCbuild/_elementtree.vcxproj | 24 ++---------- + PCbuild/_elementtree.vcxproj.filters | 55 +--------------------------- + PCbuild/pyexpat.vcxproj | 12 ++---- + PCbuild/pyexpat.vcxproj.filters | 19 +--------- + 4 files changed, 10 insertions(+), 100 deletions(-) + +diff --git a/PCbuild/_elementtree.vcxproj b/PCbuild/_elementtree.vcxproj +index 920656f2ee2..f47bcd8e4e6 100644 +--- a/PCbuild/_elementtree.vcxproj ++++ b/PCbuild/_elementtree.vcxproj +@@ -93,35 +93,19 @@ + + + +- ..\Modules\expat;%(AdditionalIncludeDirectories) ++ $(condaDir)\include;%(AdditionalIncludeDirectories) + _CRT_SECURE_NO_WARNINGS;USE_PYEXPAT_CAPI;XML_STATIC;%(PreprocessorDefinitions) + /d1trimfile:%SRC_DIR% + /d1trimfile:%SRC_DIR% + /d1trimfile:%SRC_DIR% + /d1trimfile:%SRC_DIR% + ++ ++ $(condaDir)\lib\expat.lib;%(AdditionalDependencies) ++ + +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- + + +- +- +- + + + +diff --git a/PCbuild/_elementtree.vcxproj.filters b/PCbuild/_elementtree.vcxproj.filters +index a5368024cce..7cc8e9a3b9b 100644 +--- a/PCbuild/_elementtree.vcxproj.filters ++++ b/PCbuild/_elementtree.vcxproj.filters +@@ -17,67 +17,14 @@ + {f99990ba-cd06-40cc-8f28-d2d424ec13be} + + +- +- +- Header Files\expat +- +- +- Header Files\expat +- +- +- Header Files\expat +- +- +- Header Files\expat +- +- +- Header Files\expat +- +- +- Header Files\expat +- +- +- Header Files\expat +- +- +- Header Files\expat +- +- +- Header Files\expat +- +- +- Header Files\expat +- +- +- Header Files\expat +- +- +- Header Files\expat +- +- +- Header Files\expat +- +- +- Header Files\expat +- +- + + + Source Files + +- +- Source Files\expat +- +- +- Source Files\expat +- +- +- Source Files\expat +- + + + + Resource Files + + +- +\ No newline at end of file ++ +diff --git a/PCbuild/pyexpat.vcxproj b/PCbuild/pyexpat.vcxproj +index 3bcef600a3e..ec5d4b64b3c 100644 +--- a/PCbuild/pyexpat.vcxproj ++++ b/PCbuild/pyexpat.vcxproj +@@ -90,23 +90,19 @@ + + + +- $(PySourcePath)Modules\expat;%(AdditionalIncludeDirectories) ++ $(condaDir)\include;%(AdditionalIncludeDirectories) + _CRT_SECURE_NO_WARNINGS;PYEXPAT_EXPORTS;XML_STATIC;%(PreprocessorDefinitions) + /d1trimfile:%SRC_DIR% + /d1trimfile:%SRC_DIR% + /d1trimfile:%SRC_DIR% + /d1trimfile:%SRC_DIR% + ++ ++ $(condaDir)\lib\expat.lib;%(AdditionalDependencies) ++ + +- +- +- +- + + +- +- +- + + + +diff --git a/PCbuild/pyexpat.vcxproj.filters b/PCbuild/pyexpat.vcxproj.filters +index fd22fc8c477..41c73b434b9 100644 +--- a/PCbuild/pyexpat.vcxproj.filters ++++ b/PCbuild/pyexpat.vcxproj.filters +@@ -11,31 +11,14 @@ + {f1dbbdb5-41e5-4a88-bf8e-13da010c0ce4} + + +- +- +- Header Files +- +- +- Header Files +- +- + + + Source Files + +- +- Source Files +- +- +- Source Files +- +- +- Source Files +- + + + + Resource Files + + +- +\ No newline at end of file ++ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0019-Remove-unused-readelf.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0019-Remove-unused-readelf.patch new file mode 100644 index 0000000000000000000000000000000000000000..8267177a6aa7949c8cb8c4588f35110211f7ec45 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0019-Remove-unused-readelf.patch @@ -0,0 +1,28 @@ +From d22b97f0708600e81541f2b7b6a1167ee5036c00 Mon Sep 17 00:00:00 2001 +From: Charles Bousseau +Date: Thu, 25 May 2023 17:56:53 -0400 +Subject: [PATCH 19/26] Remove unused readelf + +readelf has been dropped. +.. date: 2022-11-02-10-56-40 +.. gh-issue: 98949 +.. nonce: 3SRD8C +.. section: Build + +Drop unused build dependency on ``readelf``. +--- + Makefile.pre.in | 1 - + 1 file changed, 1 deletion(-) + +diff --git a/Makefile.pre.in b/Makefile.pre.in +index 80a1b590c2f..0b3e988571d 100644 +--- a/Makefile.pre.in ++++ b/Makefile.pre.in +@@ -38,7 +38,6 @@ CC= @CC@ + CXX= @CXX@ + LINKCC= @LINKCC@ + AR= @AR@ +-READELF= @READELF@ + SOABI= @SOABI@ + ABIFLAGS= @ABIFLAGS@ + ABI_THREAD= @ABI_THREAD@ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0020-Don-t-checksharedmods-if-cross-compiling.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0020-Don-t-checksharedmods-if-cross-compiling.patch new file mode 100644 index 0000000000000000000000000000000000000000..1dbd309dc37a71a2189644926eb1a4b2fbee8ebe --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0020-Don-t-checksharedmods-if-cross-compiling.patch @@ -0,0 +1,40 @@ +From 3feeb1c1d8a5f839f917784a163b74392722cebe Mon Sep 17 00:00:00 2001 +From: "Uwe L. Korn" +Date: Fri, 1 Sep 2023 23:32:14 +0200 +Subject: [PATCH 20/26] Don't checksharedmods if cross-compiling + +--- + Makefile.pre.in | 2 +- + if_runnable.sh | 10 ++++++++++ + 2 files changed, 11 insertions(+), 1 deletion(-) + create mode 100755 if_runnable.sh + +diff --git a/Makefile.pre.in b/Makefile.pre.in +index 0b3e988571d..20f6c243f4c 100644 +--- a/Makefile.pre.in ++++ b/Makefile.pre.in +@@ -1597,7 +1597,7 @@ sharedmods: $(SHAREDMODS) pybuilddir.txt + # dependency on BUILDPYTHON ensures that the target is run last + .PHONY: checksharedmods + checksharedmods: sharedmods $(PYTHON_FOR_BUILD_DEPS) $(BUILDPYTHON) +- @$(RUNSHARED) $(PYTHON_FOR_BUILD) $(srcdir)/Tools/build/check_extension_modules.py ++ @$(RUNSHARED) $(srcdir)/if_runnable.sh $(PYTHON_FOR_BUILD) $(srcdir)/Tools/build/check_extension_modules.py + + .PHONY: rundsymutil + rundsymutil: sharedmods $(PYTHON_FOR_BUILD_DEPS) $(BUILDPYTHON) +diff --git a/if_runnable.sh b/if_runnable.sh +new file mode 100755 +index 00000000000..dcfde5b751e +--- /dev/null ++++ b/if_runnable.sh +@@ -0,0 +1,10 @@ ++#!/bin/bash ++ ++if [[ "${target_platform}" == "${build_platform}" || "${CROSSCOMPILING_EMULATOR:-}" != "" ]]; then ++ if [[ "$1" == "./"* ]]; then ++ exec $@ ++ else ++ export ${@:1:$#-2} ++ exec ${@: -2} ++ fi ++fi diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0021-Override-configure-LIBFFI.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0021-Override-configure-LIBFFI.patch new file mode 100644 index 0000000000000000000000000000000000000000..ed6214204ddf68cba75735dfe71bd190e3c9f885 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0021-Override-configure-LIBFFI.patch @@ -0,0 +1,22 @@ +From fe59652c1d2b368168c8b0b2d99239b634774661 Mon Sep 17 00:00:00 2001 +From: "Uwe L. Korn" +Date: Tue, 5 Sep 2023 21:51:31 +0200 +Subject: [PATCH 21/26] Override configure LIBFFI + +--- + configure | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/configure b/configure +index 62acbe693c6..966aaf6a29d 100755 +--- a/configure ++++ b/configure +@@ -15304,7 +15304,7 @@ if test "x$ac_cv_lib_ffi_ffi_call" = xyes + then : + + have_libffi=yes +- LIBFFI_CFLAGS="-I${SDKROOT}/usr/include/ffi -DUSING_APPLE_OS_LIBFFI=1" ++ LIBFFI_CFLAGS="-I${PREFIX}/include -DUSING_APPLE_OS_LIBFFI=0" + LIBFFI_LIBS="-lffi" + + fi diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0022-Unvendor-libmpdec.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0022-Unvendor-libmpdec.patch new file mode 100644 index 0000000000000000000000000000000000000000..1e2d04b82147bdea81db39558be5a8c8c85760d8 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0022-Unvendor-libmpdec.patch @@ -0,0 +1,85 @@ +From 65928acddcde36a49500e3d002e69d2ee8f77c1a Mon Sep 17 00:00:00 2001 +From: Isuru Fernando +Date: Fri, 16 Aug 2024 21:34:43 -0500 +Subject: [PATCH 22/26] Unvendor libmpdec + +--- + PCbuild/_decimal.vcxproj | 50 +++++----------------------------------- + 1 file changed, 6 insertions(+), 44 deletions(-) + +diff --git a/PCbuild/_decimal.vcxproj b/PCbuild/_decimal.vcxproj +index e9d60b4db1a..0f49d7923f5 100644 +--- a/PCbuild/_decimal.vcxproj ++++ b/PCbuild/_decimal.vcxproj +@@ -93,65 +93,27 @@ + + + +- BUILD_LIBMPDEC;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) ++ _CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + CONFIG_32;PPRO;MASM;%(PreprocessorDefinitions) + CONFIG_32;ANSI;%(PreprocessorDefinitions) + CONFIG_64;ANSI;%(PreprocessorDefinitions) + CONFIG_64;MASM;%(PreprocessorDefinitions) +- ..\Modules\_decimal;..\Modules\_decimal\windows;$(mpdecimalDir)\libmpdec;%(AdditionalIncludeDirectories) ++ ..\Modules\_decimal;$(condaDir)\include;%(AdditionalIncludeDirectories) + /d1trimfile:%SRC_DIR% + /d1trimfile:%SRC_DIR% + /d1trimfile:%SRC_DIR% + /d1trimfile:%SRC_DIR% + ++ ++ $(condaDir)\lib;%(AdditionalLibraryDirectories) ++ mpdec.lib;%(AdditionalDependencies) ++ + + +- +- +- +- +- +- + +- +- +- +- +- +- +- +- +- +- +- +- +- + + + +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- true +- true +- true +- ml64 /nologo /c /Zi /Fo "$(IntDir)vcdiv64.obj" "%(FullPath)" +- $(IntDir)vcdiv64.obj;%(Outputs) +- + + + diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0023-Brand-conda-forge.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0023-Brand-conda-forge.patch new file mode 100644 index 0000000000000000000000000000000000000000..8b643c27e410316132a071c4f2206893c5d13107 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0023-Brand-conda-forge.patch @@ -0,0 +1,38 @@ +From 42032895b96cd9ec5cba9e81544dd2684cf11f7c Mon Sep 17 00:00:00 2001 +From: Isuru Fernando +Date: Wed, 28 Aug 2024 11:12:22 -0500 +Subject: [PATCH 23/26] Brand conda-forge + +--- + Lib/platform.py | 1 + + Python/getversion.c | 4 ++-- + 2 files changed, 3 insertions(+), 2 deletions(-) + +diff --git a/Lib/platform.py b/Lib/platform.py +index f7821ae7f28..628af468297 100644 +--- a/Lib/platform.py ++++ b/Lib/platform.py +@@ -1215,6 +1215,7 @@ def _sys_version(sys_version=None): + cpython_sys_version_parser = re.compile( + r'([\w.+]+)\s*' # "version" + r'(?:free-threading build\s+)?' # "free-threading-build" ++ r'(?:\| packaged by conda-forge \|\s+)?' # "| packaged by conda-forge |" + r'\(#?([^,]+)' # "(#buildno" + r'(?:,\s*([\w ]*)' # ", builddate" + r'(?:,\s*([\w :]*))?)?\)\s*' # ", buildtime)" +diff --git a/Python/getversion.c b/Python/getversion.c +index 8d8bc6ea700..2fc5c13dbfb 100644 +--- a/Python/getversion.c ++++ b/Python/getversion.c +@@ -15,9 +15,9 @@ void _Py_InitVersion(void) + } + initialized = 1; + #ifdef Py_GIL_DISABLED +- const char *buildinfo_format = "%.80s free-threading build (%.80s) %.80s"; ++ const char *buildinfo_format = "%.80s free-threading build | packaged by conda-forge | (%.80s) %.80s"; + #else +- const char *buildinfo_format = "%.80s (%.80s) %.80s"; ++ const char *buildinfo_format = "%.80s | packaged by conda-forge | (%.80s) %.80s"; + #endif + PyOS_snprintf(version, sizeof(version), buildinfo_format, + PY_VERSION, Py_GetBuildInfo(), Py_GetCompiler()); diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0024-Do-not-define-pid_t-as-it-might-conflict-with-the-ac.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0024-Do-not-define-pid_t-as-it-might-conflict-with-the-ac.patch new file mode 100644 index 0000000000000000000000000000000000000000..5629123aafac017999397c9ff672cd4e212a2c71 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0024-Do-not-define-pid_t-as-it-might-conflict-with-the-ac.patch @@ -0,0 +1,115 @@ +From 8b136967da9cfa41060e54e64ad4ee0ebe9a048e Mon Sep 17 00:00:00 2001 +From: Isuru Fernando +Date: Sun, 12 Jan 2025 10:37:29 +0530 +Subject: [PATCH 24/26] Do not define pid_t as it might conflict with the + actual definition + +--- + Modules/_testcapi/long.c | 4 ++++ + Modules/_testcapimodule.c | 4 ++++ + Modules/_testlimitedcapi/long.c | 4 ++++ + Modules/clinic/posixmodule.c.h | 4 ++++ + Modules/posixmodule.c | 1 + + PC/pyconfig.h | 2 -- + Python/remote_debug.h | 3 +++ + 7 files changed, 20 insertions(+), 2 deletions(-) + +diff --git a/Modules/_testcapi/long.c b/Modules/_testcapi/long.c +index 6313abf5485..bc8169e2f68 100644 +--- a/Modules/_testcapi/long.c ++++ b/Modules/_testcapi/long.c +@@ -6,6 +6,10 @@ + #include "util.h" + #include "clinic/long.c.h" + ++#ifdef _MSC_VER ++typedef int pid_t; ++#endif ++ + /*[clinic input] + module _testcapi + [clinic start generated code]*/ +diff --git a/Modules/_testcapimodule.c b/Modules/_testcapimodule.c +index 53f630832f8..8cc5b40a8d0 100644 +--- a/Modules/_testcapimodule.c ++++ b/Modules/_testcapimodule.c +@@ -23,6 +23,10 @@ + # include // W_STOPCODE + #endif + ++#ifdef _MSC_VER ++typedef int pid_t; ++#endif ++ + #ifdef bool + # error "The public headers should not include , see gh-48924" + #endif +diff --git a/Modules/_testlimitedcapi/long.c b/Modules/_testlimitedcapi/long.c +index 34bc7331da9..abae4b19bf0 100644 +--- a/Modules/_testlimitedcapi/long.c ++++ b/Modules/_testlimitedcapi/long.c +@@ -8,6 +8,10 @@ + #include "util.h" + #include "clinic/long.c.h" + ++#ifdef _MSC_VER ++typedef int pid_t; ++#endif ++ + /*[clinic input] + module _testlimitedcapi + [clinic start generated code]*/ +diff --git a/Modules/clinic/posixmodule.c.h b/Modules/clinic/posixmodule.c.h +index 1c7a860e1ec..64bdbdf23db 100644 +--- a/Modules/clinic/posixmodule.c.h ++++ b/Modules/clinic/posixmodule.c.h +@@ -10,6 +10,10 @@ preserve + #include "pycore_long.h" // _PyLong_UnsignedInt_Converter() + #include "pycore_modsupport.h" // _PyArg_UnpackKeywords() + ++#if (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_APP) || defined(MS_WINDOWS_SYSTEM)) ++typedef int pid_t; ++#endif ++ + PyDoc_STRVAR(os_stat__doc__, + "stat($module, /, path, *, dir_fd=None, follow_symlinks=True)\n" + "--\n" +diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c +index 31b2d28200c..cc7e40c0283 100644 +--- a/Modules/posixmodule.c ++++ b/Modules/posixmodule.c +@@ -219,6 +219,7 @@ + # if defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) + # define HAVE_SYMLINK + # endif /* MS_WINDOWS_DESKTOP | MS_WINDOWS_SYSTEM */ ++typedef int pid_t; + #endif + + +diff --git a/PC/pyconfig.h b/PC/pyconfig.h +index 710a737ebcc..92d327b1e35 100644 +--- a/PC/pyconfig.h ++++ b/PC/pyconfig.h +@@ -235,8 +235,6 @@ typedef _W64 int Py_ssize_t; + #endif + #endif /* MS_WIN32 && !MS_WIN64 */ + +-typedef int pid_t; +- + /* define some ANSI types that are not defined in earlier Win headers */ + #if _MSC_VER >= 1200 + /* This file only exists in VC 6.0 or higher */ +diff --git a/Python/remote_debug.h b/Python/remote_debug.h +index df1225f2eda..93b11c59309 100644 +--- a/Python/remote_debug.h ++++ b/Python/remote_debug.h +@@ -28,6 +28,9 @@ extern "C" { + #endif + + #include "pyconfig.h" ++#ifdef _WIN32 ++typedef int pid_t; ++#endif + #include "internal/pycore_ceval.h" + + #ifdef __linux__ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0025-Unvendor-zstd.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0025-Unvendor-zstd.patch new file mode 100644 index 0000000000000000000000000000000000000000..5394f086dc2988b12ce98995ca5918811463d648 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0025-Unvendor-zstd.patch @@ -0,0 +1,268 @@ +From 9fbb5ed9fcf079c56d8cb68c82bff97d7ca47735 Mon Sep 17 00:00:00 2001 +From: "Uwe L. Korn" +Date: Tue, 22 Jul 2025 18:07:54 +0200 +Subject: [PATCH 25/26] Unvendor zstd + +--- + PCbuild/_zstd.vcxproj | 58 +------------ + PCbuild/_zstd.vcxproj.filters | 157 +--------------------------------- + 2 files changed, 6 insertions(+), 209 deletions(-) + +diff --git a/PCbuild/_zstd.vcxproj b/PCbuild/_zstd.vcxproj +index 6f91b8d05cc..cc6f99cb002 100644 +--- a/PCbuild/_zstd.vcxproj ++++ b/PCbuild/_zstd.vcxproj +@@ -95,72 +95,22 @@ + + + WIN32;ZSTD_MULTITHREAD=1;%(PreprocessorDefinitions) +- $(zstdDir)lib\;$(zstdDir)lib\common;$(zstdDir)lib\compress;$(zstdDir)lib\decompress;$(zstdDir)lib\dictBuilder;%(AdditionalIncludeDirectories) ++ $(condaDir)\include;%(AdditionalIncludeDirectories) + ++ ++ $(condaDir)\lib\zstd.lib;%(AdditionalDependencies) ++ + + + + + + +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- + + + + + +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- + + + +diff --git a/PCbuild/_zstd.vcxproj.filters b/PCbuild/_zstd.vcxproj.filters +index eec666e5eaf..5028bb5592d 100644 +--- a/PCbuild/_zstd.vcxproj.filters ++++ b/PCbuild/_zstd.vcxproj.filters +@@ -30,96 +30,6 @@ + + Source Files + +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- +- +- Source Files\zstd +- + + + +@@ -131,73 +41,10 @@ + + Header Files + +- ++ + Header Files\zstd + +- +- Header Files\zstd +- +- +- Header Files\zstd +- +- +- Header Files\zstd +- +- +- Header Files\zstd +- +- +- Header Files\zstd +- +- +- Header Files\zstd +- +- +- Header Files\zstd +- +- +- Header Files\zstd +- +- +- Header Files\zstd +- +- +- Header Files\zstd +- +- +- Header Files\zstd +- +- +- Header Files\zstd +- +- +- Header Files\zstd +- +- +- Header Files\zstd +- +- +- Header Files\zstd +- +- +- Header Files\zstd +- +- +- Header Files\zstd +- +- +- Header Files\zstd +- +- +- Header Files\zstd +- +- +- Header Files\zstd +- +- +- Header Files\zstd +- +- ++ + Header Files\zstd + + diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0026-Set-Py_GIL_DISABLED-in-windows-to-match-unix.patch b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0026-Set-Py_GIL_DISABLED-in-windows-to-match-unix.patch new file mode 100644 index 0000000000000000000000000000000000000000..eb9639088729af71e9c9e4ee6ceedd0447686fb6 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/0026-Set-Py_GIL_DISABLED-in-windows-to-match-unix.patch @@ -0,0 +1,25 @@ +From 9fc166d6187fd4dc1be91b3e42b84840acf05bfc Mon Sep 17 00:00:00 2001 +From: Isuru Fernando +Date: Tue, 2 Dec 2025 09:46:56 -0800 +Subject: [PATCH 26/26] Set Py_GIL_DISABLED in windows to match unix + +This is not set upstream because the windows distribution supports +free-threaded and default builds at the same time. We have the +luxury of not having to do that. +--- + PC/pyconfig.h | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/PC/pyconfig.h b/PC/pyconfig.h +index 92d327b1e35..ed0d9c0592b 100644 +--- a/PC/pyconfig.h ++++ b/PC/pyconfig.h +@@ -105,6 +105,8 @@ WIN32 is still required for the locale module. + #if Py_GIL_DISABLED == 0 + #undef Py_GIL_DISABLED + #endif ++#else ++#define Py_GIL_DISABLED 1 + #endif + + /* Compiler specific defines */ diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/README.md b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/README.md new file mode 100644 index 0000000000000000000000000000000000000000..29825132aa481ab0e85d35776541719e5683f7d9 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/README.md @@ -0,0 +1,24 @@ +### How to re-generate patches +```bash +old=v3.9.6 +new=v3.10.0 +git clone git@github.com:python/cpython && cd cpython +git reset --hard $old +for f in ../recipe/patches/*.patch; do + git am $f; +done +head=$(git rev-parse HEAD) +git reset --hard $new +git cherry-pick $old...$head # fix conflicts and make sure the editor doesn't add end of file line ending +git format-patch --no-signature $new +for f in *.patch; do + python ../recipe/patches/make-mixed-crlf-patch.py $f; +done +cp 00*.patch ../recipe/patches/ +``` + +On windows, the last loop can be done as follows (once the patches +have been copied; executed within the `recipe/patch` folder): +```bash +for /f %f in ('dir /b /S .') do python make-mixed-crlf-patch.py %f +``` diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/make-mixed-crlf-patch.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/make-mixed-crlf-patch.py new file mode 100644 index 0000000000000000000000000000000000000000..d52b6be27282cbad8e8358afb2ac80f01760b417 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/patches/make-mixed-crlf-patch.py @@ -0,0 +1,52 @@ +import sys +import re +import tempfile +import shutil + + +# Reads from argv[1] line-by-line, writes to same file. The patch +# header lines are given LF line endings and the rest CRLF line endings. +# Does not currently deal with the prelude (up to the -- in git patches). + +def main(argv): + filename = argv[1] + lines = [] + with open(filename, 'rb') as fi: + try: + for line in fi: + line = line.decode('utf-8').strip('\n').strip('\r\n') + lines.append(line) + except: + pass + is_git_diff = False + for line in lines: + if line.startswith('diff --git'): + is_git_diff = True + in_real_patch = False if is_git_diff else True + + text = "\n".join(lines) + + if ".bat" not in text and ".vcxproj" not in text and ".props" not in text: + return + + with open(filename, 'wb') as fo: + for i, line in enumerate(lines): + if not in_real_patch: + fo.write((line + '\n').encode('utf-8')) + if line.startswith('diff --git'): + in_real_patch = True + else: + if line.startswith('diff ') or \ + line.startswith('diff --git') or \ + line.startswith('--- ') or \ + line.startswith('+++ ') or \ + line.startswith('@@ ') or \ + line.startswith('index ') or \ + (i < len(lines) - 1 and lines[i+1].startswith(r"\ No newline at end of file")): + fo.write((line + '\n').encode('utf-8')) + else: + fo.write((line + '\r\n').encode('utf-8')) + + +if __name__ == '__main__': + main(sys.argv) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/recipe-license.txt b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/recipe-license.txt new file mode 100644 index 0000000000000000000000000000000000000000..0490acc59477931de4af397ddbbe87ea7ddf8af0 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/recipe-license.txt @@ -0,0 +1,28 @@ +This recipe is based upon the python-3.5 recipe from +https://github.com/ContinuumIO/anaconda-recipes +which is released under the following BSD license: + +(c) 2016 Continuum Analytics, Inc. / http://continuum.io +All Rights Reserved + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of Continuum Analytics, Inc. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL CONTINUUM ANALYTICS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/recipe-scripts-license.txt b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/recipe-scripts-license.txt new file mode 100644 index 0000000000000000000000000000000000000000..37f86184003c2b95ccdf45542a54b3629fb46a3f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/recipe-scripts-license.txt @@ -0,0 +1,26 @@ +BSD-3-Clause license +Copyright (c) 2015-2026, conda-forge contributors + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + 3. Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +DAMAGE. diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/replace-word-pairs.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/replace-word-pairs.py new file mode 100644 index 0000000000000000000000000000000000000000..9093d79f5fe377c9b05f34079f711ecab74d03fd --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/replace-word-pairs.py @@ -0,0 +1,29 @@ +import sys +import re + +# Reads from stdin line by line, writes to stdout line by line replacing +# each odd argument with the subsequent even argument. + +def pairs(it): + it = iter(it) + try: + while True: + yield next(it), next(it) + except StopIteration: + return + +def main(): + rep_dict = dict() + for fro, to in pairs(sys.argv[1:]): + rep_dict[fro] = to + if len(rep_dict): + regex = re.compile("(%s)" % "|".join(map(re.escape, rep_dict.keys()))) + for line in iter(sys.stdin.readline, ''): + sys.stdout.write(regex.sub(lambda mo: rep_dict[mo.string[mo.start():mo.end()]], line)) + else: + for line in iter(sys.stdin.readline, ''): + sys.stdout.write(line) + + +if __name__ == '__main__': + main() diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/run_test.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/run_test.py new file mode 100644 index 0000000000000000000000000000000000000000..e4fb0302210bf2adc0044c2465281cfd70b24ff1 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/run_test.py @@ -0,0 +1,109 @@ +import os +import platform +import sys +import subprocess + +armv6l = bool(platform.machine() == 'armv6l') +armv7l = bool(platform.machine() == 'armv7l') +ppc64le = bool(platform.machine() == 'ppc64le') +if sys.platform == 'darwin': + osx105 = b'10.5.' in subprocess.check_output('sw_vers') +else: + osx105 = False + +print('sys.version:', sys.version) +print('sys.platform:', sys.platform) +print('tuple.__itemsize__:', tuple.__itemsize__) +if sys.platform == 'win32': + assert 'MSC v.19' in sys.version +if hasattr(sys, "abiflags"): + print('sys.abiflags', sys.abiflags) +print('sys.maxunicode:', sys.maxunicode) +print('platform.architecture:', platform.architecture()) +print('platform.python_version:', platform.python_version()) + +import _bisect +import _codecs_cn +import _codecs_hk +import _codecs_iso2022 +import _codecs_jp +import _codecs_kr +import _codecs_tw +import _collections +import _csv +import _ctypes +import _ctypes_test +import _decimal +import _elementtree +import _functools +import _hashlib +import _heapq +import _io +import _json +import _locale +import _lsprof +import _lzma +import _multibytecodec +import _multiprocessing +import _random +import _socket +import _sqlite3 +import _ssl +import _struct +import _testcapi +import array +import binascii +import bz2 +import cmath +import compression.zstd +import datetime +import itertools +import lzma +import math +import mmap +import operator +import pyexpat +import select +import time +import test +import test.support +import unicodedata +import zlib +from os import urandom +import os + +t = 100 * b'Foo ' +assert lzma.decompress(lzma.compress(t)) == t + +if sys.platform != 'win32': + if not (ppc64le or armv7l): + import _curses + import _curses_panel + import fcntl + import grp + import readline + import resource + import syslog + import termios + +if os.getenv('PY_INTERP_DEBUG') == 'yes': + if sys.platform != 'win32': + assert 'd' in sys.abiflags + assert 'gettotalrefcount' in dir(sys) + +if not (armv6l or armv7l or ppc64le or osx105): + import tkinter + import turtle + import _tkinter + print('TK_VERSION: %s' % _tkinter.TK_VERSION) + print('TCL_VERSION: %s' % _tkinter.TCL_VERSION) + TCLTK_VER = os.getenv('tk') + assert _tkinter.TK_VERSION == _tkinter.TCL_VERSION == TCLTK_VER + +import ssl +print('OPENSSL_VERSION:', ssl.OPENSSL_VERSION) +CONDA_OPENSSL_VERSION = os.getenv('openssl').split(".")[0] +assert CONDA_OPENSSL_VERSION in ssl.OPENSSL_VERSION + +# See https://github.com/conda-forge/python-feedstock/issues/718 for context: +assert sys.hash_info.algorithm.startswith("siphash") diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/scripts/activate.bat b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/scripts/activate.bat new file mode 100644 index 0000000000000000000000000000000000000000..6b77adc305b8d57b66441bd8fd2898c302fe25a2 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/scripts/activate.bat @@ -0,0 +1,3 @@ +@echo off +set "PYTHON_JIT_CONDA_BACKUP=%PYTHON_JIT%" +set "PYTHON_JIT=1" diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/scripts/activate.sh b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/scripts/activate.sh new file mode 100644 index 0000000000000000000000000000000000000000..df79e7e7a339cf659a8817b6c33d4b6b490315e5 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/scripts/activate.sh @@ -0,0 +1,4 @@ +if [ "${PYTHON_JIT+x}" ] ; then + export PYTHON_JIT_CONDA_BACKUP="${PYTHON_JIT}" +fi +export PYTHON_JIT=1 diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/scripts/deactivate.bat b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/scripts/deactivate.bat new file mode 100644 index 0000000000000000000000000000000000000000..44d9649ada90fab32f2087ec353fcf2f304f5e6a --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/scripts/deactivate.bat @@ -0,0 +1,3 @@ +@echo off +set "PYTHON_JIT=%PYTHON_JIT_CONDA_BACKUP%" +set "PYTHON_JIT_CONDA_BACKUP=" diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/scripts/deactivate.sh b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/scripts/deactivate.sh new file mode 100644 index 0000000000000000000000000000000000000000..61f6082f76481b9526f362eda6d0ba6a9b6202c6 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/scripts/deactivate.sh @@ -0,0 +1,4 @@ +if [ "${PYTHON_JIT_CONDA_BACKUP+x}" ] ; then + export PYTHON_JIT=$PYTHON_JIT_CONDA_BACKUP + unset PYTHON_JIT_CONDA_BACKUP +fi diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/sitecustomize.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/sitecustomize.py new file mode 100644 index 0000000000000000000000000000000000000000..22b9e1176cac9cb332360d621fb5dcc8ed09d557 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/sitecustomize.py @@ -0,0 +1,25 @@ +import site, sys, os + +dirs_to_add = [] +# Workaround for https://github.com/conda/conda/issues/14053 +# Older conda versions install noarch: python packages in wrong places. +# For example python3.1 because older conda assumed python minor version +# will have only one digit. noarhc pkgs for freethreading builds are supposed +# to be installed into /lib/python3.13t/site-packages, but conda +# installs them to /lib/python3.13/site-packages. +# The workaround is to add all these wrong paths to sys.path using +# site.addsitedir so that cpython and other tools like pip know about these +# locations to check when importing packages and uninstalling packages. +# When installing packages, pip will use the correct location +# /lib/python3.13t/site-packages. +if 't' in sys.abiflags: + dirs_to_add.append(os.path.join(sys.prefix, 'lib', f'python3.{sys.version_info[1]}', 'site-packages')) +# Workaround for https://github.com/conda/conda/issues/10969 +dirs_to_add.append(os.path.join(sys.prefix, 'lib', f'python3.1', 'site-packages')) +# A python version independent directory that ABI3 and noarch packages can use. +# This is unused at the moment, but keeping it here for experimentation. +dirs_to_add.append(os.path.join(sys.prefix, 'lib', f'python', 'site-packages')) + +for d in dirs_to_add: + if os.path.exists(d): + site.addsitedir(d) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/tests/cmake/CMakeLists.txt b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/tests/cmake/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..6acf308527499136444198477edf824b788868a3 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/tests/cmake/CMakeLists.txt @@ -0,0 +1,16 @@ +# https://martinopilia.com/posts/2018/09/15/building-python-extension.html +# FindPythonInterp and FindPythonLibs are deprecated since cmake 3.12 +# These can be replaced by find_package(Python ${PY_VER} REQUIRED) +# But these are still used by other packages, so we keep them. + +cmake_minimum_required(VERSION 3.10) +enable_language(C) +project(mymath) + +option(PY_VER, "Python version to use") + +find_package(PythonInterp ${PY_VER} REQUIRED) +# PATHS $ENV{CONDA_PREFIX} + +# This goes after, since it uses PythonInterp as hint +find_package(PythonLibs ${PY_VER} REQUIRED) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/tests/distutils.cext/foo.c b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/tests/distutils.cext/foo.c new file mode 100644 index 0000000000000000000000000000000000000000..b9c9b180a4aa814039aafa2d63a981954be18c18 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/tests/distutils.cext/foo.c @@ -0,0 +1,36 @@ +#include + +static PyObject * +greet_name(PyObject *self, PyObject *args) +{ + const char *name; + + if (!PyArg_ParseTuple(args, "s", &name)) + { + return NULL; + } + + printf("Hello %s!\n", name); + + Py_RETURN_NONE; +} + +static PyMethodDef GreetMethods[] = { + {"greet", greet_name, METH_VARARGS, "Greet an entity."}, + {NULL, NULL, 0, NULL} +}; + +static struct PyModuleDef greet = +{ + PyModuleDef_HEAD_INIT, + "greet", /* name of module */ + "", /* module documentation, may be NULL */ + -1, /* size of per-interpreter state of the module, or -1 if the module keeps state in global variables. */ + GreetMethods +}; + +PyMODINIT_FUNC PyInit_greet(void) +{ + return PyModule_Create(&greet); +} + diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/tests/distutils.cext/foo.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/tests/distutils.cext/foo.py new file mode 100644 index 0000000000000000000000000000000000000000..913de8f4ada0b6b40311bda55879081553cf9b66 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/tests/distutils.cext/foo.py @@ -0,0 +1,7 @@ +import greet + +def main(): + greet.greet('World') + +if __name__ == "__main__": + main() diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/tests/distutils.cext/setup.py.do_not_run_me_on_0_releases b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/tests/distutils.cext/setup.py.do_not_run_me_on_0_releases new file mode 100644 index 0000000000000000000000000000000000000000..3135045d3ed913300238e51382c6fbdb5ef3ab2f --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/tests/distutils.cext/setup.py.do_not_run_me_on_0_releases @@ -0,0 +1,14 @@ +from setuptools import setup, Extension + + +setup( + name='greet', + version='1.0', + description='Python Package with Hello World C Extension', + ext_modules=[ + Extension( + 'greet', + sources=['foo.c'], + py_limited_api=True) + ], +) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/tests/prefix-replacement/a.c b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/tests/prefix-replacement/a.c new file mode 100644 index 0000000000000000000000000000000000000000..861bbb055f73cd92b510a3067281756421def361 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/tests/prefix-replacement/a.c @@ -0,0 +1,23 @@ +#define PY_SSIZE_T_CLEAN +#include + +int +main(int argc, char *argv[]) +{ + wchar_t *program = Py_DecodeLocale(argv[0], NULL); + if (program == NULL) { + fprintf(stderr, "Fatal error: cannot decode argv[0]\n"); + exit(1); + } + // Removed in Python 3.13 and needs to be replaced with https://docs.python.org/3.13/c-api/init_config.html#c.PyConfig.program_name + // Py_SetProgramName(program); /* optional but recommended */ + Py_Initialize(); + PyRun_SimpleString("from time import time,ctime\n" + "print('Today is', ctime(time()))\n"); + if (Py_FinalizeEx() < 0) { + exit(120); + } + PyMem_RawFree(program); + return 0; +} + diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/tests/prefix-replacement/build-and-test.sh b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/tests/prefix-replacement/build-and-test.sh new file mode 100644 index 0000000000000000000000000000000000000000..acd3bf8bbd9ed797968040ba50ea0f0da703c845 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/recipe/parent/tests/prefix-replacement/build-and-test.sh @@ -0,0 +1,47 @@ +#!/usr/bin/env bash + +set -ex + +if [[ "$PKG_NAME" == "libpython-static" ]]; then + # see bpo44182 for why -L${CONDA_PREFIX}/lib is added + ${CC} a.c $(python3-config --cflags) $(python3-config --embed --ldflags) -L${CONDA_PREFIX}/lib -o ${CONDA_PREFIX}/bin/embedded-python-static + if [[ "$target_platform" == linux-* ]]; then + if ${READELF} -d ${CONDA_PREFIX}/bin/embedded-python-static | rg libpython; then + echo "ERROR :: Embedded python linked to shared python library. It is expected to link to the static library." + fi + elif [[ "$target_platform" == osx-* ]]; then + if ${OTOOL} -l ${CONDA_PREFIX}/bin/embedded-python-static | rg libpython; then + echo "ERROR :: Embedded python linked to shared python library. It is expected to link to the static library." + fi + fi + ${CONDA_PREFIX}/bin/embedded-python-static + + # I thought this would prefer the shared library for Python. I was wrong: + # EMBED_LDFLAGS=$(python3-config --ldflags) + # re='^(.*)(-lpython[^ ]*)(.*)$' + # if [[ ${EMBED_LDFLAGS} =~ $re ]]; then + # EMBED_LDFLAGS="${BASH_REMATCH[1]} ${BASH_REMATCH[3]} -Wl,-Bdynamic ${BASH_REMATCH[2]}" + # fi + # ${CC} a.c $(python3-config --cflags) ${EMBED_LDFLAGS} -o ${CONDA_PREFIX}/bin/embedded-python-shared + + # Brute-force way of linking to the shared library, sorry! + rm -rf ${CONDA_PREFIX}/lib/libpython*.a +fi + +${CC} a.c $(python3-config --cflags) \ + $(python3-config --embed --ldflags) \ + -L${CONDA_PREFIX}/lib -Wl,-rpath,${CONDA_PREFIX}/lib \ + -o ${CONDA_PREFIX}/bin/embedded-python-shared + +if [[ "$target_platform" == linux-* ]]; then + if ! ${READELF} -d ${CONDA_PREFIX}/bin/embedded-python-shared | rg libpython; then + echo "ERROR :: Embedded python linked to static python library. We tried to force it to use the shared library." + fi +elif [[ "$target_platform" == osx-* ]]; then + if ! ${OTOOL} -l ${CONDA_PREFIX}/bin/embedded-python-shared | rg libpython; then + echo "ERROR :: Embedded python linked to static python library. We tried to force it to use the shared library." + fi +fi +${CONDA_PREFIX}/bin/embedded-python-shared + +set +x diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/test/run_test.bat b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/test/run_test.bat new file mode 100644 index 0000000000000000000000000000000000000000..7b212e9fdcab2f0d03857759c8724785c6dcdf1b --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/test/run_test.bat @@ -0,0 +1,67 @@ + + +@echo on + +echo on +IF %ERRORLEVEL% NEQ 0 exit /B 1 +set +IF %ERRORLEVEL% NEQ 0 exit /B 1 +python -V +IF %ERRORLEVEL% NEQ 0 exit /B 1 +pydoc -h +IF %ERRORLEVEL% NEQ 0 exit /B 1 +set "PIP_NO_BUILD_ISOLATION=False" +IF %ERRORLEVEL% NEQ 0 exit /B 1 +set "PIP_NO_DEPENDENCIES=True" +IF %ERRORLEVEL% NEQ 0 exit /B 1 +set "PIP_IGNORE_INSTALLED=True" +IF %ERRORLEVEL% NEQ 0 exit /B 1 +set "PIP_NO_INDEX=True" +IF %ERRORLEVEL% NEQ 0 exit /B 1 +set "PIP_CACHE_DIR=%CONDA_PREFIX%/pip_cache" +IF %ERRORLEVEL% NEQ 0 exit /B 1 +set "TEMP=%CONDA_PREFIX%/tmp" +IF %ERRORLEVEL% NEQ 0 exit /B 1 +mkdir "%TEMP%" +IF %ERRORLEVEL% NEQ 0 exit /B 1 +python -Im ensurepip --upgrade --default-pip +IF %ERRORLEVEL% NEQ 0 exit /B 1 +python -c "from zoneinfo import ZoneInfo; from datetime import datetime; dt = datetime(2020, 10, 31, 12, tzinfo=ZoneInfo('America/Los_Angeles')); print(dt.tzname())" +IF %ERRORLEVEL% NEQ 0 exit /B 1 +python -m venv test-venv +IF %ERRORLEVEL% NEQ 0 exit /B 1 +test-venv\\Scripts\\python.exe -c "import ctypes" +IF %ERRORLEVEL% NEQ 0 exit /B 1 +if not exist %PREFIX%\\libs\\python3.lib exit 1 +IF %ERRORLEVEL% NEQ 0 exit /B 1 +if not exist %PREFIX%\\libs\\python314.lib exit 1 +IF %ERRORLEVEL% NEQ 0 exit /B 1 +if exist %PREFIX%\\Scripts\\pydoc exit 1 +IF %ERRORLEVEL% NEQ 0 exit /B 1 +if exist %PREFIX%\\Scripts\\idle exit 1 +IF %ERRORLEVEL% NEQ 0 exit /B 1 +if not exist %PREFIX%\\Scripts\\pydoc-script.py exit 1 +IF %ERRORLEVEL% NEQ 0 exit /B 1 +if not exist %PREFIX%\\Scripts\\idle-script.py exit 1 +IF %ERRORLEVEL% NEQ 0 exit /B 1 +if not exist %PREFIX%\\Scripts\\idle.exe exit 1 +IF %ERRORLEVEL% NEQ 0 exit /B 1 +if not exist %PREFIX%\\Scripts\\pydoc.exe exit 1 +IF %ERRORLEVEL% NEQ 0 exit /B 1 +if not exist %PREFIX%\\include\\pyconfig.h exit 1 +IF %ERRORLEVEL% NEQ 0 exit /B 1 +pushd tests +IF %ERRORLEVEL% NEQ 0 exit /B 1 +pushd cmake +IF %ERRORLEVEL% NEQ 0 exit /B 1 +cmake -GNinja -DPY_VER=3.14.4 --debug-find --trace --debug-output --debug-trycompile . +IF %ERRORLEVEL% NEQ 0 exit /B 1 +popd +IF %ERRORLEVEL% NEQ 0 exit /B 1 +popd +IF %ERRORLEVEL% NEQ 0 exit /B 1 +python run_test.py +IF %ERRORLEVEL% NEQ 0 exit /B 1 +python -c "from ctypes import CFUNCTYPE; CFUNCTYPE(None)(id)" +IF %ERRORLEVEL% NEQ 0 exit /B 1 +exit /B 0 diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/test/run_test.py b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/test/run_test.py new file mode 100644 index 0000000000000000000000000000000000000000..e4fb0302210bf2adc0044c2465281cfd70b24ff1 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/test/run_test.py @@ -0,0 +1,109 @@ +import os +import platform +import sys +import subprocess + +armv6l = bool(platform.machine() == 'armv6l') +armv7l = bool(platform.machine() == 'armv7l') +ppc64le = bool(platform.machine() == 'ppc64le') +if sys.platform == 'darwin': + osx105 = b'10.5.' in subprocess.check_output('sw_vers') +else: + osx105 = False + +print('sys.version:', sys.version) +print('sys.platform:', sys.platform) +print('tuple.__itemsize__:', tuple.__itemsize__) +if sys.platform == 'win32': + assert 'MSC v.19' in sys.version +if hasattr(sys, "abiflags"): + print('sys.abiflags', sys.abiflags) +print('sys.maxunicode:', sys.maxunicode) +print('platform.architecture:', platform.architecture()) +print('platform.python_version:', platform.python_version()) + +import _bisect +import _codecs_cn +import _codecs_hk +import _codecs_iso2022 +import _codecs_jp +import _codecs_kr +import _codecs_tw +import _collections +import _csv +import _ctypes +import _ctypes_test +import _decimal +import _elementtree +import _functools +import _hashlib +import _heapq +import _io +import _json +import _locale +import _lsprof +import _lzma +import _multibytecodec +import _multiprocessing +import _random +import _socket +import _sqlite3 +import _ssl +import _struct +import _testcapi +import array +import binascii +import bz2 +import cmath +import compression.zstd +import datetime +import itertools +import lzma +import math +import mmap +import operator +import pyexpat +import select +import time +import test +import test.support +import unicodedata +import zlib +from os import urandom +import os + +t = 100 * b'Foo ' +assert lzma.decompress(lzma.compress(t)) == t + +if sys.platform != 'win32': + if not (ppc64le or armv7l): + import _curses + import _curses_panel + import fcntl + import grp + import readline + import resource + import syslog + import termios + +if os.getenv('PY_INTERP_DEBUG') == 'yes': + if sys.platform != 'win32': + assert 'd' in sys.abiflags + assert 'gettotalrefcount' in dir(sys) + +if not (armv6l or armv7l or ppc64le or osx105): + import tkinter + import turtle + import _tkinter + print('TK_VERSION: %s' % _tkinter.TK_VERSION) + print('TCL_VERSION: %s' % _tkinter.TCL_VERSION) + TCLTK_VER = os.getenv('tk') + assert _tkinter.TK_VERSION == _tkinter.TCL_VERSION == TCLTK_VER + +import ssl +print('OPENSSL_VERSION:', ssl.OPENSSL_VERSION) +CONDA_OPENSSL_VERSION = os.getenv('openssl').split(".")[0] +assert CONDA_OPENSSL_VERSION in ssl.OPENSSL_VERSION + +# See https://github.com/conda-forge/python-feedstock/issues/718 for context: +assert sys.hash_info.algorithm.startswith("siphash") diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/test/test_time_dependencies.json b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/test/test_time_dependencies.json new file mode 100644 index 0000000000000000000000000000000000000000..a0df1c52a5332c8d97356241dec9360a5d7f5761 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/test/test_time_dependencies.json @@ -0,0 +1 @@ +["ripgrep", "vs_win-64", "vs2022_win-64", "ninja", "cmake"] \ No newline at end of file diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/test/tests/cmake/CMakeLists.txt b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/test/tests/cmake/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..6acf308527499136444198477edf824b788868a3 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/test/tests/cmake/CMakeLists.txt @@ -0,0 +1,16 @@ +# https://martinopilia.com/posts/2018/09/15/building-python-extension.html +# FindPythonInterp and FindPythonLibs are deprecated since cmake 3.12 +# These can be replaced by find_package(Python ${PY_VER} REQUIRED) +# But these are still used by other packages, so we keep them. + +cmake_minimum_required(VERSION 3.10) +enable_language(C) +project(mymath) + +option(PY_VER, "Python version to use") + +find_package(PythonInterp ${PY_VER} REQUIRED) +# PATHS $ENV{CONDA_PREFIX} + +# This goes after, since it uses PythonInterp as hint +find_package(PythonLibs ${PY_VER} REQUIRED) diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/test/tests/prefix-replacement/a.c b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/test/tests/prefix-replacement/a.c new file mode 100644 index 0000000000000000000000000000000000000000..861bbb055f73cd92b510a3067281756421def361 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/test/tests/prefix-replacement/a.c @@ -0,0 +1,23 @@ +#define PY_SSIZE_T_CLEAN +#include + +int +main(int argc, char *argv[]) +{ + wchar_t *program = Py_DecodeLocale(argv[0], NULL); + if (program == NULL) { + fprintf(stderr, "Fatal error: cannot decode argv[0]\n"); + exit(1); + } + // Removed in Python 3.13 and needs to be replaced with https://docs.python.org/3.13/c-api/init_config.html#c.PyConfig.program_name + // Py_SetProgramName(program); /* optional but recommended */ + Py_Initialize(); + PyRun_SimpleString("from time import time,ctime\n" + "print('Today is', ctime(time()))\n"); + if (Py_FinalizeEx() < 0) { + exit(120); + } + PyMem_RawFree(program); + return 0; +} + diff --git a/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/test/tests/prefix-replacement/build-and-test.sh b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/test/tests/prefix-replacement/build-and-test.sh new file mode 100644 index 0000000000000000000000000000000000000000..acd3bf8bbd9ed797968040ba50ea0f0da703c845 --- /dev/null +++ b/micromamba_root/pkgs/https/conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314/info/test/tests/prefix-replacement/build-and-test.sh @@ -0,0 +1,47 @@ +#!/usr/bin/env bash + +set -ex + +if [[ "$PKG_NAME" == "libpython-static" ]]; then + # see bpo44182 for why -L${CONDA_PREFIX}/lib is added + ${CC} a.c $(python3-config --cflags) $(python3-config --embed --ldflags) -L${CONDA_PREFIX}/lib -o ${CONDA_PREFIX}/bin/embedded-python-static + if [[ "$target_platform" == linux-* ]]; then + if ${READELF} -d ${CONDA_PREFIX}/bin/embedded-python-static | rg libpython; then + echo "ERROR :: Embedded python linked to shared python library. It is expected to link to the static library." + fi + elif [[ "$target_platform" == osx-* ]]; then + if ${OTOOL} -l ${CONDA_PREFIX}/bin/embedded-python-static | rg libpython; then + echo "ERROR :: Embedded python linked to shared python library. It is expected to link to the static library." + fi + fi + ${CONDA_PREFIX}/bin/embedded-python-static + + # I thought this would prefer the shared library for Python. I was wrong: + # EMBED_LDFLAGS=$(python3-config --ldflags) + # re='^(.*)(-lpython[^ ]*)(.*)$' + # if [[ ${EMBED_LDFLAGS} =~ $re ]]; then + # EMBED_LDFLAGS="${BASH_REMATCH[1]} ${BASH_REMATCH[3]} -Wl,-Bdynamic ${BASH_REMATCH[2]}" + # fi + # ${CC} a.c $(python3-config --cflags) ${EMBED_LDFLAGS} -o ${CONDA_PREFIX}/bin/embedded-python-shared + + # Brute-force way of linking to the shared library, sorry! + rm -rf ${CONDA_PREFIX}/lib/libpython*.a +fi + +${CC} a.c $(python3-config --cflags) \ + $(python3-config --embed --ldflags) \ + -L${CONDA_PREFIX}/lib -Wl,-rpath,${CONDA_PREFIX}/lib \ + -o ${CONDA_PREFIX}/bin/embedded-python-shared + +if [[ "$target_platform" == linux-* ]]; then + if ! ${READELF} -d ${CONDA_PREFIX}/bin/embedded-python-shared | rg libpython; then + echo "ERROR :: Embedded python linked to static python library. We tried to force it to use the shared library." + fi +elif [[ "$target_platform" == osx-* ]]; then + if ! ${OTOOL} -l ${CONDA_PREFIX}/bin/embedded-python-shared | rg libpython; then + echo "ERROR :: Embedded python linked to static python library. We tried to force it to use the shared library." + fi +fi +${CONDA_PREFIX}/bin/embedded-python-shared + +set +x