PyTime C API
************

 Dodane w wersji 3.13.

The clock C API provides access to system clocks. It is similar to the
Python "time" module.

For C API related to the "datetime" module, see DateTime Objects.


Typy
====

type PyTime_t

   A timestamp or duration in nanoseconds, represented as a signed
   64-bit integer.

   The reference point for timestamps depends on the clock used. For
   example, "PyTime_Time()" returns timestamps relative to the UNIX
   epoch.

   The supported range is around [-292.3 years; +292.3 years]. Using
   the Unix epoch (January 1st, 1970) as reference, the supported date
   range is around [1677-09-21; 2262-04-11]. The exact limits are
   exposed as constants:

PyTime_t PyTime_MIN

   Minimum value of "PyTime_t".

PyTime_t PyTime_MAX

   Maximum value of "PyTime_t".


Clock Functions
===============

The following functions take a pointer to a PyTime_t that they set to
the value of a particular clock. Details of each clock are given in
the documentation of the corresponding Python function.

The functions return "0" on success, or "-1" (with an exception set)
on failure.

On integer overflow, they set the "PyExc_OverflowError" exception and
set "*result" to the value clamped to the "[PyTime_MIN; PyTime_MAX]"
range. (On current systems, integer overflows are likely caused by
misconfigured system time.)

As any other C API (unless otherwise specified), the functions must be
called with an *attached thread state*.

int PyTime_Monotonic(PyTime_t *result)

   Read the monotonic clock. See "time.monotonic()" for important
   details on this clock.

int PyTime_PerfCounter(PyTime_t *result)

   Read the performance counter. See "time.perf_counter()" for
   important details on this clock.

int PyTime_Time(PyTime_t *result)

   Read the “wall clock” time. See "time.time()" for details important
   on this clock.


Raw Clock Functions
===================

Similar to clock functions, but don't set an exception on error and
don't require the caller to have an *attached thread state*.

On success, the functions return "0".

On failure, they set "*result" to "0" and return "-1", *without*
setting an exception. To get the cause of the error, *attach* a
*thread state*, and call the regular (non-"Raw") function. Note that
the regular function may succeed after the "Raw" one failed.

int PyTime_MonotonicRaw(PyTime_t *result)

   Similar to "PyTime_Monotonic()", but don't set an exception on
   error and don't require an *attached thread state*.

int PyTime_PerfCounterRaw(PyTime_t *result)

   Similar to "PyTime_PerfCounter()", but don't set an exception on
   error and don't require an *attached thread state*.

int PyTime_TimeRaw(PyTime_t *result)

   Similar to "PyTime_Time()", but don't set an exception on error and
   don't require an *attached thread state*.


Conversion functions
====================

double PyTime_AsSecondsDouble(PyTime_t t)

   Convert a timestamp to a number of seconds as a C double.

   The function cannot fail, but note that double has limited accuracy
   for large values.
