pytron-kit 0.3.12__py3-none-macosx_11_0_universal2.whl

pytron/platforms/android/shell/app/src/main/cpp/include/internal/pycore_tracemalloc.h

@@ -0,0 +1,164 @@
+#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(). */
+    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: "<unknown>" 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

pytron/platforms/android/shell/app/src/main/cpp/include/internal/pycore_tstate.h

@@ -0,0 +1,88 @@
+#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;
+
+} _PyThreadStateImpl;
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_TSTATE_H */

pytron/platforms/android/shell/app/src/main/cpp/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 */

pytron/platforms/android/shell/app/src/main/cpp/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

pytron/platforms/android/shell/app/src/main/cpp/include/internal/pycore_typeobject.h

@@ -0,0 +1,155 @@
+#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);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_TYPEOBJECT_H */

pytron/platforms/android/shell/app/src/main/cpp/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 */

pytron/platforms/android/shell/app/src/main/cpp/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 */