pytron-kit 0.3.12__py3-none-macosx_11_0_universal2.whl

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

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

pytron/platforms/android/shell/app/src/main/cpp/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 <xxx>
+         File "xxx", line xxx in <xxx>
+         ...
+         File "xxx", line xxx in <xxx>
+
+   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 */