gh-73487: Convert `_decimal` to use Argument Clinic (part 4) (#137931)

Co-authored-by: Serhiy Storchaka <storchaka@gmail.com>

Modules/_decimal/_decimal.c

@@ -923,14 +923,34 @@ context_getallcr(PyObject *self, void *Py_UNUSED(closure))
 }
 #endif
 
+/*[clinic input]
+_decimal.Context.Etiny
+
+Return a value equal to Emin - prec + 1.
+
+This is the minimum exponent value for subnormal results.  When
+underflow occurs, the exponent is set to Etiny.
+[clinic start generated code]*/
+
 static PyObject *
-context_getetiny(PyObject *self, PyObject *Py_UNUSED(dummy))
+_decimal_Context_Etiny_impl(PyObject *self)
+/*[clinic end generated code: output=c9a4a1a3e3575289 input=1274040f303f2244]*/
 {
     return PyLong_FromSsize_t(mpd_etiny(CTX(self)));
 }
 
+/*[clinic input]
+_decimal.Context.Etop
+
+Return a value equal to Emax - prec + 1.
+
+This is the maximum exponent if the _clamp field of the context is set
+to 1 (IEEE clamp mode).  Etop() must not be negative.
+[clinic start generated code]*/
+
 static PyObject *
-context_getetop(PyObject *self, PyObject *Py_UNUSED(dummy))
+_decimal_Context_Etop_impl(PyObject *self)
+/*[clinic end generated code: output=f0a3f6e1b829074e input=838a4409316ec728]*/
 {
     return PyLong_FromSsize_t(mpd_etop(CTX(self)));
 }
@@ -3149,21 +3169,29 @@ PyDec_FromObject(PyObject *v, PyObject *context)
     }
 }
 
-static PyObject *
+/*[clinic input]
-dec_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+@classmethod
-{
+_decimal.Decimal.__new__ as dec_new
-    static char *kwlist[] = {"value", "context", NULL};
-    PyObject *v = NULL;
-    PyObject *context = Py_None;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist,
+    value: object(c_default="NULL") = "0"
-                                     &v, &context)) {
+    context: object = None
-        return NULL;
+
-    }
+Construct a new Decimal object.
+
+value can be an integer, string, tuple, or another Decimal object.  If
+no value is given, return Decimal('0'). The context does not affect
+the conversion and is only passed to determine if the InvalidOperation
+trap is active.
+[clinic start generated code]*/
+
+static PyObject *
+dec_new_impl(PyTypeObject *type, PyObject *value, PyObject *context)
+/*[clinic end generated code: output=35f48a40c65625ba input=5f8a0892d3fcef80]*/
+{
     decimal_state *state = get_module_state_by_def(type);
     CONTEXT_CHECK_VA(state, context);
 
-    return PyDecType_FromObjectExact(type, v, context);
+    return PyDecType_FromObjectExact(type, value, context);
 }
 
 static PyObject *
@@ -4105,32 +4133,36 @@ PyDec_AsFloat(PyObject *dec)
     return f;
 }
 
+/*[clinic input]
+_decimal.Decimal.__round__
+
+    ndigits: object = NULL
+    /
+
+Return the Integral closest to self, rounding half toward even.
+[clinic start generated code]*/
+
 static PyObject *
-PyDec_Round(PyObject *dec, PyObject *args)
+_decimal_Decimal___round___impl(PyObject *self, PyObject *ndigits)
+/*[clinic end generated code: output=ca6b3570a8df0c91 input=dc72084114f59380]*/
 {
     PyObject *result;
-    PyObject *x = NULL;
     uint32_t status = 0;
     PyObject *context;
-
+    decimal_state *state = get_module_state_by_def(Py_TYPE(self));
-    decimal_state *state = get_module_state_by_def(Py_TYPE(dec));
     CURRENT_CONTEXT(state, context);
-    if (!PyArg_ParseTuple(args, "|O", &x)) {
+    if (ndigits) {
-        return NULL;
-    }
-
-    if (x) {
         mpd_uint_t dq[1] = {1};
         mpd_t q = {MPD_STATIC|MPD_CONST_DATA,0,1,1,1,dq};
         mpd_ssize_t y;
 
-        if (!PyLong_Check(x)) {
+        if (!PyLong_Check(ndigits)) {
             PyErr_SetString(PyExc_TypeError,
                 "optional arg must be an integer");
             return NULL;
         }
 
-        y = PyLong_AsSsize_t(x);
+        y = PyLong_AsSsize_t(ndigits);
         if (y == -1 && PyErr_Occurred()) {
             return NULL;
         }
@@ -4140,7 +4172,7 @@ PyDec_Round(PyObject *dec, PyObject *args)
         }
 
         q.exp = (y == MPD_SSIZE_MIN) ? MPD_SSIZE_MAX : -y;
-        mpd_qquantize(MPD(result), MPD(dec), &q, CTX(context), &status);
+        mpd_qquantize(MPD(result), MPD(self), &q, CTX(context), &status);
         if (dec_addstatus(context, status)) {
             Py_DECREF(result);
             return NULL;
@@ -4149,7 +4181,7 @@ PyDec_Round(PyObject *dec, PyObject *args)
         return result;
     }
     else {
-        return dec_as_long(dec, context, MPD_ROUND_HALF_EVEN);
+        return dec_as_long(self, context, MPD_ROUND_HALF_EVEN);
     }
 }
 
@@ -5418,9 +5450,15 @@ dec_richcompare(PyObject *v, PyObject *w, int op)
     return PyBool_FromLong(r);
 }
 
-/* __ceil__ */
+/*[clinic input]
+_decimal.Decimal.__ceil__
+
+Return the ceiling as an Integral.
+[clinic start generated code]*/
+
 static PyObject *
-dec_ceil(PyObject *self, PyObject *Py_UNUSED(dummy))
+_decimal_Decimal___ceil___impl(PyObject *self)
+/*[clinic end generated code: output=e755a6fb7bceac19 input=4a18ef307ac57da0]*/
 {
     PyObject *context;
 
@@ -5429,9 +5467,15 @@ dec_ceil(PyObject *self, PyObject *Py_UNUSED(dummy))
     return dec_as_long(self, context, MPD_ROUND_CEILING);
 }
 
-/* __complex__ */
+/*[clinic input]
+_decimal.Decimal.__complex__
+
+Convert this value to exact type complex.
+[clinic start generated code]*/
+
 static PyObject *
-dec_complex(PyObject *self, PyObject *Py_UNUSED(dummy))
+_decimal_Decimal___complex___impl(PyObject *self)
+/*[clinic end generated code: output=c9b5b4a9fdebc912 input=6b11c6f20af7061a]*/
 {
     PyObject *f;
     double x;
@@ -5450,16 +5494,42 @@ dec_complex(PyObject *self, PyObject *Py_UNUSED(dummy))
     return PyComplex_FromDoubles(x, 0);
 }
 
-/* __copy__ (METH_NOARGS) and __deepcopy__ (METH_O) */
+/*[clinic input]
+_decimal.Decimal.__copy__
+
+[clinic start generated code]*/
+
 static PyObject *
-dec_copy(PyObject *self, PyObject *Py_UNUSED(dummy))
+_decimal_Decimal___copy___impl(PyObject *self)
+/*[clinic end generated code: output=8eb3656c0250762b input=3dfd30a3e1493c01]*/
 {
     return Py_NewRef(self);
 }
 
-/* __floor__ */
+/*[clinic input]
+_decimal.Decimal.__deepcopy__
+
+    memo: object
+    /
+
+[clinic start generated code]*/
+
 static PyObject *
-dec_floor(PyObject *self, PyObject *Py_UNUSED(dummy))
+_decimal_Decimal___deepcopy__(PyObject *self, PyObject *memo)
+/*[clinic end generated code: output=988fb34e0136b376 input=f95598c6f43233aa]*/
+{
+    return Py_NewRef(self);
+}
+
+/*[clinic input]
+_decimal.Decimal.__floor__
+
+Return the floor as an Integral.
+[clinic start generated code]*/
+
+static PyObject *
+_decimal_Decimal___floor___impl(PyObject *self)
+/*[clinic end generated code: output=56767050ac1a1d5a input=cabcc5618564548b]*/
 {
     PyObject *context;
 
@@ -5595,9 +5665,15 @@ dec_hash(PyObject *op)
     return self->hash;
 }
 
-/* __reduce__ */
+/*[clinic input]
+_decimal.Decimal.__reduce__
+
+Return state information for pickling.
+[clinic start generated code]*/
+
 static PyObject *
-dec_reduce(PyObject *self, PyObject *Py_UNUSED(dummy))
+_decimal_Decimal___reduce___impl(PyObject *self)
+/*[clinic end generated code: output=84fa6648a496a8d2 input=0345ea951d9b986f]*/
 {
     PyObject *result, *str;
 
@@ -5612,9 +5688,17 @@ dec_reduce(PyObject *self, PyObject *Py_UNUSED(dummy))
     return result;
 }
 
-/* __sizeof__ */
+/*[clinic input]
+_decimal.Decimal.__sizeof__
+
+    self as v: self
+
+Returns size in memory, in bytes
+[clinic start generated code]*/
+
 static PyObject *
-dec_sizeof(PyObject *v, PyObject *Py_UNUSED(dummy))
+_decimal_Decimal___sizeof___impl(PyObject *v)
+/*[clinic end generated code: output=f16de05097c62b79 input=a557db538cfddbb7]*/
 {
     size_t res = _PyObject_SIZE(Py_TYPE(v));
     if (mpd_isdynamic_data(MPD(v))) {
@@ -5623,9 +5707,15 @@ dec_sizeof(PyObject *v, PyObject *Py_UNUSED(dummy))
     return PyLong_FromSize_t(res);
 }
 
-/* __trunc__ */
+/*[clinic input]
+_decimal.Decimal.__trunc__
+
+Return the Integral closest to x between 0 and x.
+[clinic start generated code]*/
+
 static PyObject *
-dec_trunc(PyObject *self, PyObject *Py_UNUSED(dummy))
+_decimal_Decimal___trunc___impl(PyObject *self)
+/*[clinic end generated code: output=9ef59578960f80c0 input=a965a61096dcefeb]*/
 {
     PyObject *context;
 
@@ -5743,16 +5833,16 @@ static PyMethodDef dec_methods [] =
   _DECIMAL_DECIMAL_AS_INTEGER_RATIO_METHODDEF
 
   /* Special methods */
-  { "__copy__", dec_copy, METH_NOARGS, NULL },
+  _DECIMAL_DECIMAL___COPY___METHODDEF
-  { "__deepcopy__", dec_copy, METH_O, NULL },
+  _DECIMAL_DECIMAL___DEEPCOPY___METHODDEF
   _DECIMAL_DECIMAL___FORMAT___METHODDEF
-  { "__reduce__", dec_reduce, METH_NOARGS, NULL },
+  _DECIMAL_DECIMAL___REDUCE___METHODDEF
-  { "__round__", PyDec_Round, METH_VARARGS, NULL },
+  _DECIMAL_DECIMAL___ROUND___METHODDEF
-  { "__ceil__", dec_ceil, METH_NOARGS, NULL },
+  _DECIMAL_DECIMAL___CEIL___METHODDEF
-  { "__floor__", dec_floor, METH_NOARGS, NULL },
+  _DECIMAL_DECIMAL___FLOOR___METHODDEF
-  { "__trunc__", dec_trunc, METH_NOARGS, NULL },
+  _DECIMAL_DECIMAL___TRUNC___METHODDEF
-  { "__complex__", dec_complex, METH_NOARGS, NULL },
+  _DECIMAL_DECIMAL___COMPLEX___METHODDEF
-  { "__sizeof__", dec_sizeof, METH_NOARGS, NULL },
+  _DECIMAL_DECIMAL___SIZEOF___METHODDEF
 
   { NULL, NULL, 1 }
 };
@@ -5765,7 +5855,7 @@ static PyType_Slot dec_slots[] = {
     {Py_tp_repr, dec_repr},
     {Py_tp_hash, dec_hash},
     {Py_tp_str, dec_str},
-    {Py_tp_doc, (void *)doc_decimal},
+    {Py_tp_doc, (void *)dec_new__doc__},
     {Py_tp_richcompare, dec_richcompare},
     {Py_tp_methods, dec_methods},
     {Py_tp_getset, dec_getsets},
@@ -6119,8 +6209,18 @@ _decimal_Context_power_impl(PyObject *context, PyObject *base, PyObject *exp,
 DecCtx_TernaryFunc(mpd_qfma)
 
 /* No argument */
+
+/*[clinic input]
+_decimal.Context.radix
+
+    self as context: self
+
+Return 10.
+[clinic start generated code]*/
+
 static PyObject *
-ctx_mpd_radix(PyObject *context, PyObject *dummy)
+_decimal_Context_radix_impl(PyObject *context)
+/*[clinic end generated code: output=9218fa309e0fcaa1 input=faeaa5b71f838c38]*/
 {
     decimal_state *state = get_module_state_from_ctx(context);
     return _dec_mpd_radix(state);
@@ -6403,9 +6503,9 @@ static PyMethodDef context_methods [] =
   { "fma", ctx_mpd_qfma, METH_VARARGS, doc_ctx_fma },
 
   /* No argument */
-  { "Etiny", context_getetiny, METH_NOARGS, doc_ctx_Etiny },
+  _DECIMAL_CONTEXT_ETINY_METHODDEF
-  { "Etop", context_getetop, METH_NOARGS, doc_ctx_Etop },
+  _DECIMAL_CONTEXT_ETOP_METHODDEF
-  { "radix", ctx_mpd_radix, METH_NOARGS, doc_ctx_radix },
+  _DECIMAL_CONTEXT_RADIX_METHODDEF
 
   /* Boolean functions */
   { "is_canonical", ctx_iscanonical, METH_O, doc_ctx_is_canonical },
@@ -6932,7 +7032,7 @@ static struct PyModuleDef_Slot _decimal_slots[] = {
 static struct PyModuleDef _decimal_module = {
     PyModuleDef_HEAD_INIT,
     .m_name = "decimal",
-    .m_doc = doc__decimal,
+    .m_doc = "C decimal arithmetic module",
     .m_size = sizeof(decimal_state),
     .m_methods = _decimal_methods,
     .m_slots = _decimal_slots,

Modules/_decimal/clinic/_decimal.c.h

@@ -9,6 +9,48 @@ preserve
 #include "pycore_abstract.h"      // _PyNumber_Index()
 #include "pycore_modsupport.h"    // _PyArg_UnpackKeywords()
 
+PyDoc_STRVAR(_decimal_Context_Etiny__doc__,
+"Etiny($self, /)\n"
+"--\n"
+"\n"
+"Return a value equal to Emin - prec + 1.\n"
+"\n"
+"This is the minimum exponent value for subnormal results.  When\n"
+"underflow occurs, the exponent is set to Etiny.");
+
+#define _DECIMAL_CONTEXT_ETINY_METHODDEF    \
+    {"Etiny", (PyCFunction)_decimal_Context_Etiny, METH_NOARGS, _decimal_Context_Etiny__doc__},
+
+static PyObject *
+_decimal_Context_Etiny_impl(PyObject *self);
+
+static PyObject *
+_decimal_Context_Etiny(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _decimal_Context_Etiny_impl(self);
+}
+
+PyDoc_STRVAR(_decimal_Context_Etop__doc__,
+"Etop($self, /)\n"
+"--\n"
+"\n"
+"Return a value equal to Emax - prec + 1.\n"
+"\n"
+"This is the maximum exponent if the _clamp field of the context is set\n"
+"to 1 (IEEE clamp mode).  Etop() must not be negative.");
+
+#define _DECIMAL_CONTEXT_ETOP_METHODDEF    \
+    {"Etop", (PyCFunction)_decimal_Context_Etop, METH_NOARGS, _decimal_Context_Etop__doc__},
+
+static PyObject *
+_decimal_Context_Etop_impl(PyObject *self);
+
+static PyObject *
+_decimal_Context_Etop(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _decimal_Context_Etop_impl(self);
+}
+
 PyDoc_STRVAR(_decimal_IEEEContext__doc__,
 "IEEEContext($module, bits, /)\n"
 "--\n"
@@ -269,6 +311,80 @@ _decimal_Decimal_from_number(PyObject *type, PyObject *number)
     return return_value;
 }
 
+PyDoc_STRVAR(dec_new__doc__,
+"Decimal(value=\'0\', context=None)\n"
+"--\n"
+"\n"
+"Construct a new Decimal object.\n"
+"\n"
+"value can be an integer, string, tuple, or another Decimal object.  If\n"
+"no value is given, return Decimal(\'0\'). The context does not affect\n"
+"the conversion and is only passed to determine if the InvalidOperation\n"
+"trap is active.");
+
+static PyObject *
+dec_new_impl(PyTypeObject *type, PyObject *value, PyObject *context);
+
+static PyObject *
+dec_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
+{
+    PyObject *return_value = NULL;
+    #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+    #define NUM_KEYWORDS 2
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        Py_hash_t ob_hash;
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_hash = -1,
+        .ob_item = { &_Py_ID(value), &_Py_ID(context), },
+    };
+    #undef NUM_KEYWORDS
+    #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+    #else  // !Py_BUILD_CORE
+    #  define KWTUPLE NULL
+    #endif  // !Py_BUILD_CORE
+
+    static const char * const _keywords[] = {"value", "context", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "Decimal",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[2];
+    PyObject * const *fastargs;
+    Py_ssize_t nargs = PyTuple_GET_SIZE(args);
+    Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
+    PyObject *value = NULL;
+    PyObject *context = Py_None;
+
+    fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser,
+            /*minpos*/ 0, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
+    if (!fastargs) {
+        goto exit;
+    }
+    if (!noptargs) {
+        goto skip_optional_pos;
+    }
+    if (fastargs[0]) {
+        value = fastargs[0];
+        if (!--noptargs) {
+            goto skip_optional_pos;
+        }
+    }
+    context = fastargs[1];
+skip_optional_pos:
+    return_value = dec_new_impl(type, value, context);
+
+exit:
+    return return_value;
+}
+
 PyDoc_STRVAR(_decimal_Decimal___format____doc__,
 "__format__($self, format_spec, override=<unrepresentable>, /)\n"
 "--\n"
@@ -554,6 +670,38 @@ exit:
     return return_value;
 }
 
+PyDoc_STRVAR(_decimal_Decimal___round____doc__,
+"__round__($self, ndigits=<unrepresentable>, /)\n"
+"--\n"
+"\n"
+"Return the Integral closest to self, rounding half toward even.");
+
+#define _DECIMAL_DECIMAL___ROUND___METHODDEF    \
+    {"__round__", _PyCFunction_CAST(_decimal_Decimal___round__), METH_FASTCALL, _decimal_Decimal___round____doc__},
+
+static PyObject *
+_decimal_Decimal___round___impl(PyObject *self, PyObject *ndigits);
+
+static PyObject *
+_decimal_Decimal___round__(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *ndigits = NULL;
+
+    if (!_PyArg_CheckPositional("__round__", nargs, 0, 1)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    ndigits = args[0];
+skip_optional:
+    return_value = _decimal_Decimal___round___impl(self, ndigits);
+
+exit:
+    return return_value;
+}
+
 PyDoc_STRVAR(_decimal_Decimal_as_tuple__doc__,
 "as_tuple($self, /)\n"
 "--\n"
@@ -2841,6 +2989,139 @@ exit:
     return return_value;
 }
 
+PyDoc_STRVAR(_decimal_Decimal___ceil____doc__,
+"__ceil__($self, /)\n"
+"--\n"
+"\n"
+"Return the ceiling as an Integral.");
+
+#define _DECIMAL_DECIMAL___CEIL___METHODDEF    \
+    {"__ceil__", (PyCFunction)_decimal_Decimal___ceil__, METH_NOARGS, _decimal_Decimal___ceil____doc__},
+
+static PyObject *
+_decimal_Decimal___ceil___impl(PyObject *self);
+
+static PyObject *
+_decimal_Decimal___ceil__(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _decimal_Decimal___ceil___impl(self);
+}
+
+PyDoc_STRVAR(_decimal_Decimal___complex____doc__,
+"__complex__($self, /)\n"
+"--\n"
+"\n"
+"Convert this value to exact type complex.");
+
+#define _DECIMAL_DECIMAL___COMPLEX___METHODDEF    \
+    {"__complex__", (PyCFunction)_decimal_Decimal___complex__, METH_NOARGS, _decimal_Decimal___complex____doc__},
+
+static PyObject *
+_decimal_Decimal___complex___impl(PyObject *self);
+
+static PyObject *
+_decimal_Decimal___complex__(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _decimal_Decimal___complex___impl(self);
+}
+
+PyDoc_STRVAR(_decimal_Decimal___copy____doc__,
+"__copy__($self, /)\n"
+"--\n"
+"\n");
+
+#define _DECIMAL_DECIMAL___COPY___METHODDEF    \
+    {"__copy__", (PyCFunction)_decimal_Decimal___copy__, METH_NOARGS, _decimal_Decimal___copy____doc__},
+
+static PyObject *
+_decimal_Decimal___copy___impl(PyObject *self);
+
+static PyObject *
+_decimal_Decimal___copy__(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _decimal_Decimal___copy___impl(self);
+}
+
+PyDoc_STRVAR(_decimal_Decimal___deepcopy____doc__,
+"__deepcopy__($self, memo, /)\n"
+"--\n"
+"\n");
+
+#define _DECIMAL_DECIMAL___DEEPCOPY___METHODDEF    \
+    {"__deepcopy__", (PyCFunction)_decimal_Decimal___deepcopy__, METH_O, _decimal_Decimal___deepcopy____doc__},
+
+PyDoc_STRVAR(_decimal_Decimal___floor____doc__,
+"__floor__($self, /)\n"
+"--\n"
+"\n"
+"Return the floor as an Integral.");
+
+#define _DECIMAL_DECIMAL___FLOOR___METHODDEF    \
+    {"__floor__", (PyCFunction)_decimal_Decimal___floor__, METH_NOARGS, _decimal_Decimal___floor____doc__},
+
+static PyObject *
+_decimal_Decimal___floor___impl(PyObject *self);
+
+static PyObject *
+_decimal_Decimal___floor__(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _decimal_Decimal___floor___impl(self);
+}
+
+PyDoc_STRVAR(_decimal_Decimal___reduce____doc__,
+"__reduce__($self, /)\n"
+"--\n"
+"\n"
+"Return state information for pickling.");
+
+#define _DECIMAL_DECIMAL___REDUCE___METHODDEF    \
+    {"__reduce__", (PyCFunction)_decimal_Decimal___reduce__, METH_NOARGS, _decimal_Decimal___reduce____doc__},
+
+static PyObject *
+_decimal_Decimal___reduce___impl(PyObject *self);
+
+static PyObject *
+_decimal_Decimal___reduce__(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _decimal_Decimal___reduce___impl(self);
+}
+
+PyDoc_STRVAR(_decimal_Decimal___sizeof____doc__,
+"__sizeof__($self, /)\n"
+"--\n"
+"\n"
+"Returns size in memory, in bytes");
+
+#define _DECIMAL_DECIMAL___SIZEOF___METHODDEF    \
+    {"__sizeof__", (PyCFunction)_decimal_Decimal___sizeof__, METH_NOARGS, _decimal_Decimal___sizeof____doc__},
+
+static PyObject *
+_decimal_Decimal___sizeof___impl(PyObject *v);
+
+static PyObject *
+_decimal_Decimal___sizeof__(PyObject *v, PyObject *Py_UNUSED(ignored))
+{
+    return _decimal_Decimal___sizeof___impl(v);
+}
+
+PyDoc_STRVAR(_decimal_Decimal___trunc____doc__,
+"__trunc__($self, /)\n"
+"--\n"
+"\n"
+"Return the Integral closest to x between 0 and x.");
+
+#define _DECIMAL_DECIMAL___TRUNC___METHODDEF    \
+    {"__trunc__", (PyCFunction)_decimal_Decimal___trunc__, METH_NOARGS, _decimal_Decimal___trunc____doc__},
+
+static PyObject *
+_decimal_Decimal___trunc___impl(PyObject *self);
+
+static PyObject *
+_decimal_Decimal___trunc__(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _decimal_Decimal___trunc___impl(self);
+}
+
 PyDoc_STRVAR(_decimal_Context_power__doc__,
 "power($self, /, a, b, modulo=None)\n"
 "--\n"
@@ -2922,4 +3203,22 @@ skip_optional_pos:
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=9bbde3e723166dd3 input=a9049054013a1b77]*/
+
+PyDoc_STRVAR(_decimal_Context_radix__doc__,
+"radix($self, /)\n"
+"--\n"
+"\n"
+"Return 10.");
+
+#define _DECIMAL_CONTEXT_RADIX_METHODDEF    \
+    {"radix", (PyCFunction)_decimal_Context_radix, METH_NOARGS, _decimal_Context_radix__doc__},
+
+static PyObject *
+_decimal_Context_radix_impl(PyObject *context);
+
+static PyObject *
+_decimal_Context_radix(PyObject *context, PyObject *Py_UNUSED(ignored))
+{
+    return _decimal_Context_radix_impl(context);
+}
+/*[clinic end generated code: output=ffc58f98fffed531 input=a9049054013a1b77]*/

Modules/_decimal/docstrings.h

@@ -10,61 +10,6 @@
 
 #include "pymacro.h"
 
-
-/******************************************************************************/
-/*                                Module                                      */
-/******************************************************************************/
-
-
-PyDoc_STRVAR(doc__decimal,
-"C decimal arithmetic module");
-
-/******************************************************************************/
-/*                       Decimal Object and Methods                           */
-/******************************************************************************/
-
-PyDoc_STRVAR(doc_decimal,
-"Decimal(value=\"0\", context=None)\n--\n\n\
-Construct a new Decimal object. 'value' can be an integer, string, tuple,\n\
-or another Decimal object. If no value is given, return Decimal('0'). The\n\
-context does not affect the conversion and is only passed to determine if\n\
-the InvalidOperation trap is active.\n\
-\n");
-
-PyDoc_STRVAR(doc_compare_total,
-"compare_total($self, /, other, context=None)\n--\n\n\
-Compare two operands using their abstract representation rather than\n\
-their numerical value.  Similar to the compare() method, but the result\n\
-gives a total ordering on Decimal instances.  Two Decimal instances with\n\
-the same numeric value but different representations compare unequal\n\
-in this ordering:\n\
-\n\
-    >>> Decimal('12.0').compare_total(Decimal('12'))\n\
-    Decimal('-1')\n\
-\n\
-Quiet and signaling NaNs are also included in the total ordering. The result\n\
-of this function is Decimal('0') if both operands have the same representation,\n\
-Decimal('-1') if the first operand is lower in the total order than the second,\n\
-and Decimal('1') if the first operand is higher in the total order than the\n\
-second operand. See the specification for details of the total order.\n\
-\n\
-This operation is unaffected by context and is quiet: no flags are changed\n\
-and no rounding is performed. As an exception, the C version may raise\n\
-InvalidOperation if the second operand cannot be converted exactly.\n\
-\n");
-
-PyDoc_STRVAR(doc_compare_total_mag,
-"compare_total_mag($self, /, other, context=None)\n--\n\n\
-Compare two operands using their abstract representation rather than their\n\
-value as in compare_total(), but ignoring the sign of each operand.\n\
-\n\
-x.compare_total_mag(y) is equivalent to x.copy_abs().compare_total(y.copy_abs()).\n\
-\n\
-This operation is unaffected by context and is quiet: no flags are changed\n\
-and no rounding is performed. As an exception, the C version may raise\n\
-InvalidOperation if the second operand cannot be converted exactly.\n\
-\n");
-
 PyDoc_STRVAR(doc_is_canonical,
 "is_canonical($self, /)\n--\n\n\
 Return True if the argument is canonical and False otherwise.  Currently,\n\
@@ -169,19 +114,6 @@ Create a new Decimal instance from float f.  Unlike the Decimal.from_float()\n\
 class method, this function observes the context limits.\n\
 \n");
 
-PyDoc_STRVAR(doc_ctx_Etiny,
-"Etiny($self, /)\n--\n\n\
-Return a value equal to Emin - prec + 1, which is the minimum exponent value\n\
-for subnormal results.  When underflow occurs, the exponent is set to Etiny.\n\
-\n");
-
-PyDoc_STRVAR(doc_ctx_Etop,
-"Etop($self, /)\n--\n\n\
-Return a value equal to Emax - prec + 1.  This is the maximum exponent\n\
-if the _clamp field of the context is set to 1 (IEEE clamp mode).  Etop()\n\
-must not be negative.\n\
-\n");
-
 PyDoc_STRVAR(doc_ctx_abs,
 "abs($self, x, /)\n--\n\n\
 Return the absolute value of x.\n\
@@ -257,6 +189,40 @@ PyDoc_STRVAR(doc_ctx_fma,
 Return x multiplied by y, plus z.\n\
 \n");
 
+PyDoc_STRVAR(doc_compare_total,
+"compare_total($self, /, other, context=None)\n--\n\n\
+Compare two operands using their abstract representation rather than\n\
+their numerical value.  Similar to the compare() method, but the result\n\
+gives a total ordering on Decimal instances.  Two Decimal instances with\n\
+the same numeric value but different representations compare unequal\n\
+in this ordering:\n\
+\n\
+    >>> Decimal('12.0').compare_total(Decimal('12'))\n\
+    Decimal('-1')\n\
+\n\
+Quiet and signaling NaNs are also included in the total ordering. The result\n\
+of this function is Decimal('0') if both operands have the same representation,\n\
+Decimal('-1') if the first operand is lower in the total order than the second,\n\
+and Decimal('1') if the first operand is higher in the total order than the\n\
+second operand. See the specification for details of the total order.\n\
+\n\
+This operation is unaffected by context and is quiet: no flags are changed\n\
+and no rounding is performed. As an exception, the C version may raise\n\
+InvalidOperation if the second operand cannot be converted exactly.\n\
+\n");
+
+PyDoc_STRVAR(doc_compare_total_mag,
+"compare_total_mag($self, /, other, context=None)\n--\n\n\
+Compare two operands using their abstract representation rather than their\n\
+value as in compare_total(), but ignoring the sign of each operand.\n\
+\n\
+x.compare_total_mag(y) is equivalent to x.copy_abs().compare_total(y.copy_abs()).\n\
+\n\
+This operation is unaffected by context and is quiet: no flags are changed\n\
+and no rounding is performed. As an exception, the C version may raise\n\
+InvalidOperation if the second operand cannot be converted exactly.\n\
+\n");
+
 PyDoc_STRVAR(doc_ctx_is_canonical,
 "is_canonical($self, x, /)\n--\n\n\
 Return True if x is canonical, False otherwise.\n\
@@ -409,11 +375,6 @@ PyDoc_STRVAR(doc_ctx_quantize,
 Return a value equal to x (rounded), having the exponent of y.\n\
 \n");
 
-PyDoc_STRVAR(doc_ctx_radix,
-"radix($self, /)\n--\n\n\
-Return 10.\n\
-\n");
-
 PyDoc_STRVAR(doc_ctx_remainder,
 "remainder($self, x, y, /)\n--\n\n\
 Return the remainder from integer division.  The sign of the result,\n\