/*[clinic input]
+@permit_long_summary
@critical_section
bytearray.translate
Return a copy with each character mapped by the given translation table.
-All characters occurring in the optional argument delete are removed.
-The remaining characters are mapped through the given translation table.
+All characters occurring in the optional argument delete are
+removed. The remaining characters are mapped through the given
+translation table.
[clinic start generated code]*/
static PyObject *
bytearray_translate_impl(PyByteArrayObject *self, PyObject *table,
PyObject *deletechars)
-/*[clinic end generated code: output=b6a8f01c2a74e446 input=cd6fa93ca04e05bc]*/
+/*[clinic end generated code: output=b6a8f01c2a74e446 input=e30d2ae004365ed9]*/
{
char *input, *output;
const char *table_chars;
/*[clinic input]
@permit_long_summary
-@permit_long_docstring_body
@staticmethod
bytearray.maketrans
Return a translation table usable for the bytes or bytearray translate method.
-The returned table will be one where each byte in frm is mapped to the byte at
-the same position in to.
+The returned table will be one where each byte in frm is mapped to
+the byte at the same position in to.
The bytes objects frm and to must be of the same length.
[clinic start generated code]*/
static PyObject *
bytearray_maketrans_impl(Py_buffer *frm, Py_buffer *to)
-/*[clinic end generated code: output=1df267d99f56b15e input=1146b43a592eca13]*/
+/*[clinic end generated code: output=1df267d99f56b15e input=c2f5f6e7e6b0221d]*/
{
return _Py_bytes_maketrans(frm, to);
}
sep: object = None
The delimiter according which to split the bytearray.
- None (the default value) means split on ASCII whitespace characters
- (space, tab, return, newline, formfeed, vertical tab).
+ None (the default value) means split on ASCII whitespace
+ characters (space, tab, return, newline, formfeed, vertical tab).
maxsplit: Py_ssize_t = -1
Maximum number of splits to do.
-1 (the default value) means no limit.
static PyObject *
bytearray_split_impl(PyByteArrayObject *self, PyObject *sep,
Py_ssize_t maxsplit)
-/*[clinic end generated code: output=833e2cf385d9a04d input=dd9f6e2910cc3a34]*/
+/*[clinic end generated code: output=833e2cf385d9a04d input=45605178023b52ac]*/
{
PyObject *list = NULL;
}
/*[clinic input]
-@permit_long_docstring_body
@critical_section
bytearray.partition
Partition the bytearray into three parts using the given separator.
-This will search for the separator sep in the bytearray. If the separator is
-found, returns a 3-tuple containing the part before the separator, the
-separator itself, and the part after it as new bytearray objects.
+This will search for the separator sep in the bytearray. If the
+separator is found, returns a 3-tuple containing the part before the
+separator, the separator itself, and the part after it as new
+bytearray objects.
-If the separator is not found, returns a 3-tuple containing the copy of the
-original bytearray object and two empty bytearray objects.
+If the separator is not found, returns a 3-tuple containing the copy
+of the original bytearray object and two empty bytearray objects.
[clinic start generated code]*/
static PyObject *
bytearray_partition_impl(PyByteArrayObject *self, PyObject *sep)
-/*[clinic end generated code: output=b5fa1e03f10cfccb input=b87276af883f39d9]*/
+/*[clinic end generated code: output=b5fa1e03f10cfccb input=d76673ed03acf5dd]*/
{
PyObject *bytesep, *result;
}
/*[clinic input]
-@permit_long_docstring_body
@critical_section
bytearray.rpartition
Partition the bytearray into three parts using the given separator.
-This will search for the separator sep in the bytearray, starting at the end.
-If the separator is found, returns a 3-tuple containing the part before the
-separator, the separator itself, and the part after it as new bytearray
-objects.
+This will search for the separator sep in the bytearray, starting at
+the end. If the separator is found, returns a 3-tuple containing
+the part before the separator, the separator itself, and the part
+after it as new bytearray objects.
-If the separator is not found, returns a 3-tuple containing two empty bytearray
-objects and the copy of the original bytearray object.
+If the separator is not found, returns a 3-tuple containing two
+empty bytearray objects and the copy of the original bytearray
+object.
[clinic start generated code]*/
static PyObject *
bytearray_rpartition_impl(PyByteArrayObject *self, PyObject *sep)
-/*[clinic end generated code: output=0186ce7b1ef61289 input=5bdcfc4c333bcfab]*/
+/*[clinic end generated code: output=0186ce7b1ef61289 input=b9216a2074174a36]*/
{
PyObject *bytesep, *result;
/*[clinic input]
@permit_long_summary
-@permit_long_docstring_body
@critical_section
bytearray.rsplit = bytearray.split
Return a list of the sections in the bytearray, using sep as the delimiter.
-Splitting is done starting at the end of the bytearray and working to the front.
+Splitting is done starting at the end of the bytearray and working
+to the front.
[clinic start generated code]*/
static PyObject *
bytearray_rsplit_impl(PyByteArrayObject *self, PyObject *sep,
Py_ssize_t maxsplit)
-/*[clinic end generated code: output=a55e0b5a03cb6190 input=60e9abf305128ff4]*/
+/*[clinic end generated code: output=a55e0b5a03cb6190 input=e201671c9a0c19ee]*/
{
PyObject *list = NULL;
}
/*[clinic input]
-@permit_long_docstring_body
@critical_section
bytearray.strip
Strip leading and trailing bytes contained in the argument.
-If the argument is omitted or None, strip leading and trailing ASCII whitespace.
+If the argument is omitted or None, strip leading and trailing ASCII
+whitespace.
[clinic start generated code]*/
static PyObject *
bytearray_strip_impl(PyByteArrayObject *self, PyObject *bytes)
-/*[clinic end generated code: output=760412661a34ad5a input=6acaf88b2ec9daa7]*/
+/*[clinic end generated code: output=760412661a34ad5a input=f4ec5fa609df7d14]*/
{
return bytearray_strip_impl_helper(self, bytes, BOTHSTRIP);
}
encoding: str(c_default="NULL") = 'utf-8'
The encoding with which to decode the bytearray.
errors: str(c_default="NULL") = 'strict'
- The error handling scheme to use for the handling of decoding errors.
- The default is 'strict' meaning that decoding errors raise a
- UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
- as well as any other name registered with codecs.register_error that
- can handle UnicodeDecodeErrors.
+ The error handling scheme to use for the handling of decoding
+ errors. The default is 'strict' meaning that decoding errors
+ raise a UnicodeDecodeError. Other possible values are 'ignore'
+ and 'replace' as well as any other name registered with
+ codecs.register_error that can handle UnicodeDecodeErrors.
Decode the bytearray using the codec registered for encoding.
[clinic start generated code]*/
static PyObject *
bytearray_decode_impl(PyByteArrayObject *self, const char *encoding,
const char *errors)
-/*[clinic end generated code: output=f57d43f4a00b42c5 input=86c303ee376b8453]*/
+/*[clinic end generated code: output=f57d43f4a00b42c5 input=e51ce9b82b51e2ca]*/
{
if (encoding == NULL)
encoding = PyUnicode_GetDefaultEncoding();
Concatenate any number of bytes/bytearray objects.
-The bytearray whose method is called is inserted in between each pair.
+The bytearray whose method is called is inserted in between each
+pair.
The result is returned as a new bytearray object.
[clinic start generated code]*/
static PyObject *
bytearray_join_impl(PyByteArrayObject *self, PyObject *iterable_of_bytes)
-/*[clinic end generated code: output=0ced382b5846a7ee input=49627e07ca31ca26]*/
+/*[clinic end generated code: output=0ced382b5846a7ee input=0a31db349efcd7fa]*/
{
PyObject *ret;
self->ob_exports++; // this protects `self` from being cleared/resized if `iterable_of_bytes` is a custom iterator
/*[clinic input]
@permit_long_summary
-@permit_long_docstring_body
@critical_section
bytearray.splitlines
Return a list of the lines in the bytearray, breaking at line boundaries.
-Line breaks are not included in the resulting list unless keepends is given and
-true.
+Line breaks are not included in the resulting list unless keepends
+is given and true.
[clinic start generated code]*/
static PyObject *
bytearray_splitlines_impl(PyByteArrayObject *self, int keepends)
-/*[clinic end generated code: output=4223c94b895f6ad9 input=21bc3f02bf1be832]*/
+/*[clinic end generated code: output=4223c94b895f6ad9 input=cc2bb740eed19f27]*/
{
return stringlib_splitlines(
(PyObject*) self, PyByteArray_AS_STRING(self),
Create a bytearray object from a string of hexadecimal numbers.
Spaces between two numbers are accepted.
-Example: bytearray.fromhex('B9 01EF') -> bytearray(b'\\xb9\\x01\\xef')
+Example:
+ bytearray.fromhex('B9 01EF') -> bytearray(b'\\xb9\\x01\\xef')
[clinic start generated code]*/
static PyObject *
bytearray_fromhex_impl(PyTypeObject *type, PyObject *string)
-/*[clinic end generated code: output=8f0f0b6d30fb3ba0 input=7e314e5b2d7ab484]*/
+/*[clinic end generated code: output=8f0f0b6d30fb3ba0 input=2243a8b0b9e66cd5]*/
{
PyObject *result = _PyBytes_FromHex(string, type == &PyByteArray_Type);
if (type != &PyByteArray_Type && result != NULL) {
sep: object = NULL
An optional single character or byte to separate hex bytes.
bytes_per_sep: Py_ssize_t = 1
- How many bytes between separators. Positive values count from the
- right, negative values count from the left.
+ How many bytes between separators. Positive values count from
+ the right, negative values count from the left.
Create a string of hexadecimal numbers from a bytearray object.
static PyObject *
bytearray_hex_impl(PyByteArrayObject *self, PyObject *sep,
Py_ssize_t bytes_per_sep)
-/*[clinic end generated code: output=c9563921aff1262b input=d2b23ef057cfcad5]*/
+/*[clinic end generated code: output=c9563921aff1262b input=9ed746203691e894]*/
{
char* argbuf = PyByteArray_AS_STRING(self);
Py_ssize_t arglen = PyByteArray_GET_SIZE(self);
PyDoc_STRVAR_shared(_Py_title__doc__,
"B.title() -> copy of B\n\
\n\
-Return a titlecased version of B, i.e. ASCII words start with uppercase\n\
-characters, all remaining cased characters have lowercase.");
+Return a titlecased version of B, i.e. ASCII words start with\n\
+uppercase characters, all remaining cased characters have lowercase.");
void
_Py_bytes_title(char *result, const char *s, Py_ssize_t len)
#define BOTHSTRIP 2
/*[clinic input]
+@permit_long_summary
bytes.split
sep: object = None
The delimiter according which to split the bytes.
- None (the default value) means split on ASCII whitespace characters
- (space, tab, return, newline, formfeed, vertical tab).
+ None (the default value) means split on ASCII whitespace
+ characters (space, tab, return, newline, formfeed, vertical tab).
maxsplit: Py_ssize_t = -1
Maximum number of splits to do.
-1 (the default value) means no limit.
static PyObject *
bytes_split_impl(PyBytesObject *self, PyObject *sep, Py_ssize_t maxsplit)
-/*[clinic end generated code: output=52126b5844c1d8ef input=8b809b39074abbfa]*/
+/*[clinic end generated code: output=52126b5844c1d8ef input=330ff95d92544b05]*/
{
Py_ssize_t len = PyBytes_GET_SIZE(self), n;
const char *s = PyBytes_AS_STRING(self), *sub;
}
/*[clinic input]
-@permit_long_docstring_body
bytes.partition
sep: Py_buffer
Partition the bytes into three parts using the given separator.
-This will search for the separator sep in the bytes. If the separator is found,
-returns a 3-tuple containing the part before the separator, the separator
-itself, and the part after it.
+This will search for the separator sep in the bytes. If the
+separator is found, returns a 3-tuple containing the part before the
+separator, the separator itself, and the part after it.
-If the separator is not found, returns a 3-tuple containing the original bytes
-object and two empty bytes objects.
+If the separator is not found, returns a 3-tuple containing the
+original bytes object and two empty bytes objects.
[clinic start generated code]*/
static PyObject *
bytes_partition_impl(PyBytesObject *self, Py_buffer *sep)
-/*[clinic end generated code: output=f532b392a17ff695 input=31c55a0cebaf7722]*/
+/*[clinic end generated code: output=f532b392a17ff695 input=2e6e551ea4f8b95a]*/
{
return stringlib_partition(
(PyObject*) self,
}
/*[clinic input]
-@permit_long_docstring_body
bytes.rpartition
sep: Py_buffer
Partition the bytes into three parts using the given separator.
-This will search for the separator sep in the bytes, starting at the end. If
-the separator is found, returns a 3-tuple containing the part before the
-separator, the separator itself, and the part after it.
+This will search for the separator sep in the bytes, starting at the
+end. If the separator is found, returns a 3-tuple containing the
+part before the separator, the separator itself, and the part after
+it.
-If the separator is not found, returns a 3-tuple containing two empty bytes
-objects and the original bytes object.
+If the separator is not found, returns a 3-tuple containing two
+empty bytes objects and the original bytes object.
[clinic start generated code]*/
static PyObject *
bytes_rpartition_impl(PyBytesObject *self, Py_buffer *sep)
-/*[clinic end generated code: output=191b114cbb028e50 input=9ea5a3ab0b02bf52]*/
+/*[clinic end generated code: output=191b114cbb028e50 input=f7d24f722a5470a4]*/
{
return stringlib_rpartition(
(PyObject*) self,
}
/*[clinic input]
-@permit_long_docstring_body
+@permit_long_summary
bytes.rsplit = bytes.split
Return a list of the sections in the bytes, using sep as the delimiter.
-Splitting is done starting at the end of the bytes and working to the front.
+Splitting is done starting at the end of the bytes and working to
+the front.
[clinic start generated code]*/
static PyObject *
bytes_rsplit_impl(PyBytesObject *self, PyObject *sep, Py_ssize_t maxsplit)
-/*[clinic end generated code: output=ba698d9ea01e1c8f input=55b6eaea1f3d7046]*/
+/*[clinic end generated code: output=ba698d9ea01e1c8f input=ba9bee56285f43e4]*/
{
Py_ssize_t len = PyBytes_GET_SIZE(self), n;
const char *s = PyBytes_AS_STRING(self), *sub;
}
/*[clinic input]
-@permit_long_docstring_body
bytes.strip
bytes: object = None
Strip leading and trailing bytes contained in the argument.
-If the argument is omitted or None, strip leading and trailing ASCII whitespace.
+If the argument is omitted or None, strip leading and trailing ASCII
+whitespace.
[clinic start generated code]*/
static PyObject *
bytes_strip_impl(PyBytesObject *self, PyObject *bytes)
-/*[clinic end generated code: output=c7c228d3bd104a1b input=71904cd278c0ee03]*/
+/*[clinic end generated code: output=c7c228d3bd104a1b input=9ffea5f752032bd0]*/
{
return do_argstrip(self, BOTHSTRIP, bytes);
}
/*[clinic input]
+@permit_long_summary
bytes.translate
table: object
Return a copy with each character mapped by the given translation table.
-All characters occurring in the optional argument delete are removed.
-The remaining characters are mapped through the given translation table.
+All characters occurring in the optional argument delete are
+removed. The remaining characters are mapped through the given
+translation table.
[clinic start generated code]*/
static PyObject *
bytes_translate_impl(PyBytesObject *self, PyObject *table,
PyObject *deletechars)
-/*[clinic end generated code: output=43be3437f1956211 input=0ecdf159f654233c]*/
+/*[clinic end generated code: output=43be3437f1956211 input=bddcdef0a87895d2]*/
{
const char *input;
char *output;
/*[clinic input]
@permit_long_summary
-@permit_long_docstring_body
@staticmethod
bytes.maketrans
Return a translation table usable for the bytes or bytearray translate method.
-The returned table will be one where each byte in frm is mapped to the byte at
-the same position in to.
+The returned table will be one where each byte in frm is mapped to
+the byte at the same position in to.
The bytes objects frm and to must be of the same length.
[clinic start generated code]*/
static PyObject *
bytes_maketrans_impl(Py_buffer *frm, Py_buffer *to)
-/*[clinic end generated code: output=a36f6399d4b77f6f input=a06b75f44d933fb3]*/
+/*[clinic end generated code: output=a36f6399d4b77f6f input=3a577e5badfea8f7]*/
{
return _Py_bytes_maketrans(frm, to);
}
/** End DALKE **/
/*[clinic input]
+@permit_long_summary
bytes.removeprefix as bytes_removeprefix
prefix: Py_buffer
Return a bytes object with the given prefix string removed if present.
-If the bytes starts with the prefix string, return bytes[len(prefix):].
-Otherwise, return a copy of the original bytes.
+If the bytes starts with the prefix string, return
+bytes[len(prefix):]. Otherwise, return a copy of the original
+bytes.
[clinic start generated code]*/
static PyObject *
bytes_removeprefix_impl(PyBytesObject *self, Py_buffer *prefix)
-/*[clinic end generated code: output=f006865331a06ab6 input=0c93bac817a8502c]*/
+/*[clinic end generated code: output=f006865331a06ab6 input=3a2672bcee61d7a7]*/
{
const char *self_start = PyBytes_AS_STRING(self);
Py_ssize_t self_len = PyBytes_GET_SIZE(self);
}
/*[clinic input]
+@permit_long_summary
bytes.removesuffix as bytes_removesuffix
suffix: Py_buffer
Return a bytes object with the given suffix string removed if present.
-If the bytes ends with the suffix string and that suffix is not empty,
-return bytes[:-len(prefix)]. Otherwise, return a copy of the original
-bytes.
+If the bytes ends with the suffix string and that suffix is not
+empty, return bytes[:-len(prefix)]. Otherwise, return a copy of the
+original bytes.
[clinic start generated code]*/
static PyObject *
bytes_removesuffix_impl(PyBytesObject *self, Py_buffer *suffix)
-/*[clinic end generated code: output=d887d308e3242eeb input=9f4e1da8c637bbf1]*/
+/*[clinic end generated code: output=d887d308e3242eeb input=04df5f18a36f69d7]*/
{
const char *self_start = PyBytes_AS_STRING(self);
Py_ssize_t self_len = PyBytes_GET_SIZE(self);
encoding: str(c_default="NULL") = 'utf-8'
The encoding with which to decode the bytes.
errors: str(c_default="NULL") = 'strict'
- The error handling scheme to use for the handling of decoding errors.
- The default is 'strict' meaning that decoding errors raise a
- UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
- as well as any other name registered with codecs.register_error that
- can handle UnicodeDecodeErrors.
+ The error handling scheme to use for the handling of decoding
+ errors. The default is 'strict' meaning that decoding errors
+ raise a UnicodeDecodeError. Other possible values are 'ignore'
+ and 'replace' as well as any other name registered with
+ codecs.register_error that can handle UnicodeDecodeErrors.
Decode the bytes using the codec registered for encoding.
[clinic start generated code]*/
static PyObject *
bytes_decode_impl(PyBytesObject *self, const char *encoding,
const char *errors)
-/*[clinic end generated code: output=5649a53dde27b314 input=958174769d2a40ca]*/
+/*[clinic end generated code: output=5649a53dde27b314 input=94e9b8524f1d7f37]*/
{
return PyUnicode_FromEncodedObject((PyObject*)self, encoding, errors);
}
/*[clinic input]
-@permit_long_docstring_body
+@permit_long_summary
bytes.splitlines
keepends: bool = False
Return a list of the lines in the bytes, breaking at line boundaries.
-Line breaks are not included in the resulting list unless keepends is given and
-true.
+Line breaks are not included in the resulting list unless keepends
+is given and true.
[clinic start generated code]*/
static PyObject *
bytes_splitlines_impl(PyBytesObject *self, int keepends)
-/*[clinic end generated code: output=3484149a5d880ffb input=d17968d2a355fe55]*/
+/*[clinic end generated code: output=3484149a5d880ffb input=8734672f34430514]*/
{
return stringlib_splitlines(
(PyObject*) self, PyBytes_AS_STRING(self),
sep: object = NULL
An optional single character or byte to separate hex bytes.
bytes_per_sep: Py_ssize_t = 1
- How many bytes between separators. Positive values count from the
- right, negative values count from the left.
+ How many bytes between separators. Positive values count from
+ the right, negative values count from the left.
Create a string of hexadecimal numbers from a bytes object.
static PyObject *
bytes_hex_impl(PyBytesObject *self, PyObject *sep, Py_ssize_t bytes_per_sep)
-/*[clinic end generated code: output=588821f02cb9d8f5 input=bd8eceb755d8230f]*/
+/*[clinic end generated code: output=588821f02cb9d8f5 input=b8d40cf203d172dc]*/
{
const char *argbuf = PyBytes_AS_STRING(self);
Py_ssize_t arglen = PyBytes_GET_SIZE(self);
" table\n"
" Translation table, which must be a bytes object of length 256.\n"
"\n"
-"All characters occurring in the optional argument delete are removed.\n"
-"The remaining characters are mapped through the given translation table.");
+"All characters occurring in the optional argument delete are\n"
+"removed. The remaining characters are mapped through the given\n"
+"translation table.");
#define BYTEARRAY_TRANSLATE_METHODDEF \
{"translate", _PyCFunction_CAST(bytearray_translate), METH_FASTCALL|METH_KEYWORDS, bytearray_translate__doc__},
"\n"
"Return a translation table usable for the bytes or bytearray translate method.\n"
"\n"
-"The returned table will be one where each byte in frm is mapped to the byte at\n"
-"the same position in to.\n"
+"The returned table will be one where each byte in frm is mapped to\n"
+"the byte at the same position in to.\n"
"\n"
"The bytes objects frm and to must be of the same length.");
"\n"
" sep\n"
" The delimiter according which to split the bytearray.\n"
-" None (the default value) means split on ASCII whitespace characters\n"
-" (space, tab, return, newline, formfeed, vertical tab).\n"
+" None (the default value) means split on ASCII whitespace\n"
+" characters (space, tab, return, newline, formfeed, vertical tab).\n"
" maxsplit\n"
" Maximum number of splits to do.\n"
" -1 (the default value) means no limit.");
"\n"
"Partition the bytearray into three parts using the given separator.\n"
"\n"
-"This will search for the separator sep in the bytearray. If the separator is\n"
-"found, returns a 3-tuple containing the part before the separator, the\n"
-"separator itself, and the part after it as new bytearray objects.\n"
+"This will search for the separator sep in the bytearray. If the\n"
+"separator is found, returns a 3-tuple containing the part before the\n"
+"separator, the separator itself, and the part after it as new\n"
+"bytearray objects.\n"
"\n"
-"If the separator is not found, returns a 3-tuple containing the copy of the\n"
-"original bytearray object and two empty bytearray objects.");
+"If the separator is not found, returns a 3-tuple containing the copy\n"
+"of the original bytearray object and two empty bytearray objects.");
#define BYTEARRAY_PARTITION_METHODDEF \
{"partition", (PyCFunction)bytearray_partition, METH_O, bytearray_partition__doc__},
"\n"
"Partition the bytearray into three parts using the given separator.\n"
"\n"
-"This will search for the separator sep in the bytearray, starting at the end.\n"
-"If the separator is found, returns a 3-tuple containing the part before the\n"
-"separator, the separator itself, and the part after it as new bytearray\n"
-"objects.\n"
+"This will search for the separator sep in the bytearray, starting at\n"
+"the end. If the separator is found, returns a 3-tuple containing\n"
+"the part before the separator, the separator itself, and the part\n"
+"after it as new bytearray objects.\n"
"\n"
-"If the separator is not found, returns a 3-tuple containing two empty bytearray\n"
-"objects and the copy of the original bytearray object.");
+"If the separator is not found, returns a 3-tuple containing two\n"
+"empty bytearray objects and the copy of the original bytearray\n"
+"object.");
#define BYTEARRAY_RPARTITION_METHODDEF \
{"rpartition", (PyCFunction)bytearray_rpartition, METH_O, bytearray_rpartition__doc__},
"\n"
" sep\n"
" The delimiter according which to split the bytearray.\n"
-" None (the default value) means split on ASCII whitespace characters\n"
-" (space, tab, return, newline, formfeed, vertical tab).\n"
+" None (the default value) means split on ASCII whitespace\n"
+" characters (space, tab, return, newline, formfeed, vertical tab).\n"
" maxsplit\n"
" Maximum number of splits to do.\n"
" -1 (the default value) means no limit.\n"
"\n"
-"Splitting is done starting at the end of the bytearray and working to the front.");
+"Splitting is done starting at the end of the bytearray and working\n"
+"to the front.");
#define BYTEARRAY_RSPLIT_METHODDEF \
{"rsplit", _PyCFunction_CAST(bytearray_rsplit), METH_FASTCALL|METH_KEYWORDS, bytearray_rsplit__doc__},
"\n"
"Strip leading and trailing bytes contained in the argument.\n"
"\n"
-"If the argument is omitted or None, strip leading and trailing ASCII whitespace.");
+"If the argument is omitted or None, strip leading and trailing ASCII\n"
+"whitespace.");
#define BYTEARRAY_STRIP_METHODDEF \
{"strip", _PyCFunction_CAST(bytearray_strip), METH_FASTCALL, bytearray_strip__doc__},
" encoding\n"
" The encoding with which to decode the bytearray.\n"
" errors\n"
-" The error handling scheme to use for the handling of decoding errors.\n"
-" The default is \'strict\' meaning that decoding errors raise a\n"
-" UnicodeDecodeError. Other possible values are \'ignore\' and \'replace\'\n"
-" as well as any other name registered with codecs.register_error that\n"
-" can handle UnicodeDecodeErrors.");
+" The error handling scheme to use for the handling of decoding\n"
+" errors. The default is \'strict\' meaning that decoding errors\n"
+" raise a UnicodeDecodeError. Other possible values are \'ignore\'\n"
+" and \'replace\' as well as any other name registered with\n"
+" codecs.register_error that can handle UnicodeDecodeErrors.");
#define BYTEARRAY_DECODE_METHODDEF \
{"decode", _PyCFunction_CAST(bytearray_decode), METH_FASTCALL|METH_KEYWORDS, bytearray_decode__doc__},
"\n"
"Concatenate any number of bytes/bytearray objects.\n"
"\n"
-"The bytearray whose method is called is inserted in between each pair.\n"
+"The bytearray whose method is called is inserted in between each\n"
+"pair.\n"
"\n"
"The result is returned as a new bytearray object.");
"\n"
"Return a list of the lines in the bytearray, breaking at line boundaries.\n"
"\n"
-"Line breaks are not included in the resulting list unless keepends is given and\n"
-"true.");
+"Line breaks are not included in the resulting list unless keepends\n"
+"is given and true.");
#define BYTEARRAY_SPLITLINES_METHODDEF \
{"splitlines", _PyCFunction_CAST(bytearray_splitlines), METH_FASTCALL|METH_KEYWORDS, bytearray_splitlines__doc__},
"Create a bytearray object from a string of hexadecimal numbers.\n"
"\n"
"Spaces between two numbers are accepted.\n"
-"Example: bytearray.fromhex(\'B9 01EF\') -> bytearray(b\'\\\\xb9\\\\x01\\\\xef\')");
+"Example:\n"
+" bytearray.fromhex(\'B9 01EF\') -> bytearray(b\'\\\\xb9\\\\x01\\\\xef\')");
#define BYTEARRAY_FROMHEX_METHODDEF \
{"fromhex", (PyCFunction)bytearray_fromhex, METH_O|METH_CLASS, bytearray_fromhex__doc__},
" sep\n"
" An optional single character or byte to separate hex bytes.\n"
" bytes_per_sep\n"
-" How many bytes between separators. Positive values count from the\n"
-" right, negative values count from the left.\n"
+" How many bytes between separators. Positive values count from\n"
+" the right, negative values count from the left.\n"
"\n"
"Example:\n"
">>> value = bytearray([0xb9, 0x01, 0xef])\n"
{
return bytearray_sizeof_impl((PyByteArrayObject *)self);
}
-/*[clinic end generated code: output=2cacb323147202b9 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=6dc315d35de3e670 input=a9049054013a1b77]*/
"\n"
" sep\n"
" The delimiter according which to split the bytes.\n"
-" None (the default value) means split on ASCII whitespace characters\n"
-" (space, tab, return, newline, formfeed, vertical tab).\n"
+" None (the default value) means split on ASCII whitespace\n"
+" characters (space, tab, return, newline, formfeed, vertical tab).\n"
" maxsplit\n"
" Maximum number of splits to do.\n"
" -1 (the default value) means no limit.");
"\n"
"Partition the bytes into three parts using the given separator.\n"
"\n"
-"This will search for the separator sep in the bytes. If the separator is found,\n"
-"returns a 3-tuple containing the part before the separator, the separator\n"
-"itself, and the part after it.\n"
+"This will search for the separator sep in the bytes. If the\n"
+"separator is found, returns a 3-tuple containing the part before the\n"
+"separator, the separator itself, and the part after it.\n"
"\n"
-"If the separator is not found, returns a 3-tuple containing the original bytes\n"
-"object and two empty bytes objects.");
+"If the separator is not found, returns a 3-tuple containing the\n"
+"original bytes object and two empty bytes objects.");
#define BYTES_PARTITION_METHODDEF \
{"partition", (PyCFunction)bytes_partition, METH_O, bytes_partition__doc__},
"\n"
"Partition the bytes into three parts using the given separator.\n"
"\n"
-"This will search for the separator sep in the bytes, starting at the end. If\n"
-"the separator is found, returns a 3-tuple containing the part before the\n"
-"separator, the separator itself, and the part after it.\n"
+"This will search for the separator sep in the bytes, starting at the\n"
+"end. If the separator is found, returns a 3-tuple containing the\n"
+"part before the separator, the separator itself, and the part after\n"
+"it.\n"
"\n"
-"If the separator is not found, returns a 3-tuple containing two empty bytes\n"
-"objects and the original bytes object.");
+"If the separator is not found, returns a 3-tuple containing two\n"
+"empty bytes objects and the original bytes object.");
#define BYTES_RPARTITION_METHODDEF \
{"rpartition", (PyCFunction)bytes_rpartition, METH_O, bytes_rpartition__doc__},
"\n"
" sep\n"
" The delimiter according which to split the bytes.\n"
-" None (the default value) means split on ASCII whitespace characters\n"
-" (space, tab, return, newline, formfeed, vertical tab).\n"
+" None (the default value) means split on ASCII whitespace\n"
+" characters (space, tab, return, newline, formfeed, vertical tab).\n"
" maxsplit\n"
" Maximum number of splits to do.\n"
" -1 (the default value) means no limit.\n"
"\n"
-"Splitting is done starting at the end of the bytes and working to the front.");
+"Splitting is done starting at the end of the bytes and working to\n"
+"the front.");
#define BYTES_RSPLIT_METHODDEF \
{"rsplit", _PyCFunction_CAST(bytes_rsplit), METH_FASTCALL|METH_KEYWORDS, bytes_rsplit__doc__},
"\n"
"Strip leading and trailing bytes contained in the argument.\n"
"\n"
-"If the argument is omitted or None, strip leading and trailing ASCII whitespace.");
+"If the argument is omitted or None, strip leading and trailing ASCII\n"
+"whitespace.");
#define BYTES_STRIP_METHODDEF \
{"strip", _PyCFunction_CAST(bytes_strip), METH_FASTCALL, bytes_strip__doc__},
" table\n"
" Translation table, which must be a bytes object of length 256.\n"
"\n"
-"All characters occurring in the optional argument delete are removed.\n"
-"The remaining characters are mapped through the given translation table.");
+"All characters occurring in the optional argument delete are\n"
+"removed. The remaining characters are mapped through the given\n"
+"translation table.");
#define BYTES_TRANSLATE_METHODDEF \
{"translate", _PyCFunction_CAST(bytes_translate), METH_FASTCALL|METH_KEYWORDS, bytes_translate__doc__},
"\n"
"Return a translation table usable for the bytes or bytearray translate method.\n"
"\n"
-"The returned table will be one where each byte in frm is mapped to the byte at\n"
-"the same position in to.\n"
+"The returned table will be one where each byte in frm is mapped to\n"
+"the byte at the same position in to.\n"
"\n"
"The bytes objects frm and to must be of the same length.");
"\n"
"Return a bytes object with the given prefix string removed if present.\n"
"\n"
-"If the bytes starts with the prefix string, return bytes[len(prefix):].\n"
-"Otherwise, return a copy of the original bytes.");
+"If the bytes starts with the prefix string, return\n"
+"bytes[len(prefix):]. Otherwise, return a copy of the original\n"
+"bytes.");
#define BYTES_REMOVEPREFIX_METHODDEF \
{"removeprefix", (PyCFunction)bytes_removeprefix, METH_O, bytes_removeprefix__doc__},
"\n"
"Return a bytes object with the given suffix string removed if present.\n"
"\n"
-"If the bytes ends with the suffix string and that suffix is not empty,\n"
-"return bytes[:-len(prefix)]. Otherwise, return a copy of the original\n"
-"bytes.");
+"If the bytes ends with the suffix string and that suffix is not\n"
+"empty, return bytes[:-len(prefix)]. Otherwise, return a copy of the\n"
+"original bytes.");
#define BYTES_REMOVESUFFIX_METHODDEF \
{"removesuffix", (PyCFunction)bytes_removesuffix, METH_O, bytes_removesuffix__doc__},
" encoding\n"
" The encoding with which to decode the bytes.\n"
" errors\n"
-" The error handling scheme to use for the handling of decoding errors.\n"
-" The default is \'strict\' meaning that decoding errors raise a\n"
-" UnicodeDecodeError. Other possible values are \'ignore\' and \'replace\'\n"
-" as well as any other name registered with codecs.register_error that\n"
-" can handle UnicodeDecodeErrors.");
+" The error handling scheme to use for the handling of decoding\n"
+" errors. The default is \'strict\' meaning that decoding errors\n"
+" raise a UnicodeDecodeError. Other possible values are \'ignore\'\n"
+" and \'replace\' as well as any other name registered with\n"
+" codecs.register_error that can handle UnicodeDecodeErrors.");
#define BYTES_DECODE_METHODDEF \
{"decode", _PyCFunction_CAST(bytes_decode), METH_FASTCALL|METH_KEYWORDS, bytes_decode__doc__},
"\n"
"Return a list of the lines in the bytes, breaking at line boundaries.\n"
"\n"
-"Line breaks are not included in the resulting list unless keepends is given and\n"
-"true.");
+"Line breaks are not included in the resulting list unless keepends\n"
+"is given and true.");
#define BYTES_SPLITLINES_METHODDEF \
{"splitlines", _PyCFunction_CAST(bytes_splitlines), METH_FASTCALL|METH_KEYWORDS, bytes_splitlines__doc__},
" sep\n"
" An optional single character or byte to separate hex bytes.\n"
" bytes_per_sep\n"
-" How many bytes between separators. Positive values count from the\n"
-" right, negative values count from the left.\n"
+" How many bytes between separators. Positive values count from\n"
+" the right, negative values count from the left.\n"
"\n"
"Example:\n"
">>> value = b\'\\xb9\\x01\\xef\'\n"
exit:
return return_value;
}
-/*[clinic end generated code: output=b252801ff04a89b3 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=c20458db7a2123db input=a9049054013a1b77]*/
"\n"
"(internal-only) Return the local variable name for the given oparg.\n"
"\n"
-"WARNING: this method is for internal use only and may change or go away.");
+"WARNING: this method is for internal use only and may change or go\n"
+"away.");
#define CODE__VARNAME_FROM_OPARG_METHODDEF \
{"_varname_from_oparg", _PyCFunction_CAST(code__varname_from_oparg), METH_FASTCALL|METH_KEYWORDS, code__varname_from_oparg__doc__},
exit:
return return_value;
}
-/*[clinic end generated code: output=c5c6e40fc357defe input=a9049054013a1b77]*/
+/*[clinic end generated code: output=5c22e29e430401b4 input=a9049054013a1b77]*/
"It exists mainly to be used in Python\'s test suite.\n"
"\n"
"This function returns whichever of \'IEEE, big-endian\' or \'IEEE,\n"
-"little-endian\' best describes the format of floating-point numbers used by the\n"
-"C type named by typestr.");
+"little-endian\' best describes the format of floating-point numbers\n"
+"used by the C type named by typestr.");
#define FLOAT___GETFORMAT___METHODDEF \
{"__getformat__", (PyCFunction)float___getformat__, METH_O|METH_CLASS, float___getformat____doc__},
exit:
return return_value;
}
-/*[clinic end generated code: output=f0b2af257213c8b0 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=5d7b0bf9e47ff997 input=a9049054013a1b77]*/
"\n"
"Sort the list in ascending order and return None.\n"
"\n"
-"The sort is in-place (i.e. the list itself is modified) and stable (i.e. the\n"
-"order of two equal elements is maintained).\n"
+"The sort is in-place (i.e. the list itself is modified) and stable\n"
+"(i.e. the order of two equal elements is maintained).\n"
"\n"
-"If a key function is given, apply it once to each list item and sort them,\n"
-"ascending or descending, according to their function values.\n"
+"If a key function is given, apply it once to each list item and sort\n"
+"them, ascending or descending, according to their function values.\n"
"\n"
"The reverse flag can be set to sort in descending order.");
{
return list___reversed___impl((PyListObject *)self);
}
-/*[clinic end generated code: output=ae13fc2b56dc27c2 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=06c21b0bffbe8d84 input=a9049054013a1b77]*/
"Return an array of bytes representing an integer.\n"
"\n"
" length\n"
-" Length of bytes object to use. An OverflowError is raised if the\n"
-" integer is not representable with the given number of bytes. Default\n"
-" is length 1.\n"
+" Length of bytes object to use. An OverflowError is raised if\n"
+" the integer is not representable with the given number of bytes.\n"
+" Default is length 1.\n"
" byteorder\n"
-" The byte order used to represent the integer. If byteorder is \'big\',\n"
-" the most significant byte is at the beginning of the byte array. If\n"
-" byteorder is \'little\', the most significant byte is at the end of the\n"
-" byte array. To request the native byte order of the host system, use\n"
-" sys.byteorder as the byte order value. Default is to use \'big\'.\n"
+" The byte order used to represent the integer. If byteorder is\n"
+" \'big\', the most significant byte is at the beginning of the byte\n"
+" array. If byteorder is \'little\', the most significant byte is at\n"
+" the end of the byte array. To request the native byte order of\n"
+" the host system, use sys.byteorder as the byte order value.\n"
+" Default is to use \'big\'.\n"
" signed\n"
-" Determines whether two\'s complement is used to represent the integer.\n"
-" If signed is False and a negative integer is given, an OverflowError\n"
-" is raised.");
+" Determines whether two\'s complement is used to represent the\n"
+" integer. If signed is False and a negative integer is given,\n"
+" an OverflowError is raised.");
#define INT_TO_BYTES_METHODDEF \
{"to_bytes", _PyCFunction_CAST(int_to_bytes), METH_FASTCALL|METH_KEYWORDS, int_to_bytes__doc__},
"\n"
" bytes\n"
" Holds the array of bytes to convert. The argument must either\n"
-" support the buffer protocol or be an iterable object producing bytes.\n"
-" Bytes and bytearray are examples of built-in objects that support the\n"
-" buffer protocol.\n"
+" support the buffer protocol or be an iterable object producing\n"
+" bytes. Bytes and bytearray are examples of built-in objects that\n"
+" support the buffer protocol.\n"
" byteorder\n"
-" The byte order used to represent the integer. If byteorder is \'big\',\n"
-" the most significant byte is at the beginning of the byte array. If\n"
-" byteorder is \'little\', the most significant byte is at the end of the\n"
-" byte array. To request the native byte order of the host system, use\n"
-" sys.byteorder as the byte order value. Default is to use \'big\'.\n"
+" The byte order used to represent the integer. If byteorder is\n"
+" \'big\', the most significant byte is at the beginning of the byte\n"
+" array. If byteorder is \'little\', the most significant byte is at\n"
+" the end of the byte array. To request the native byte order of\n"
+" the host system, use sys.byteorder as the byte order value.\n"
+" Default is to use \'big\'.\n"
" signed\n"
-" Indicates whether two\'s complement is used to represent the integer.");
+" Indicates whether two\'s complement is used to represent the\n"
+" integer.");
#define INT_FROM_BYTES_METHODDEF \
{"from_bytes", _PyCFunction_CAST(int_from_bytes), METH_FASTCALL|METH_KEYWORDS|METH_CLASS, int_from_bytes__doc__},
{
return int_is_integer_impl(self);
}
-/*[clinic end generated code: output=e68f4e23ead3f649 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=d95766fb7ff46963 input=a9049054013a1b77]*/
"\n"
"Return the data in the buffer as a byte string.\n"
"\n"
-"Order can be {\'C\', \'F\', \'A\'}. When order is \'C\' or \'F\', the data of the\n"
-"original array is converted to C or Fortran order. For contiguous views,\n"
-"\'A\' returns an exact copy of the physical memory. In particular, in-memory\n"
-"Fortran order is preserved. For non-contiguous views, the data is converted\n"
-"to C first. order=None is the same as order=\'C\'.");
+"Order can be {\'C\', \'F\', \'A\'}. When order is \'C\' or \'F\', the data of\n"
+"the original array is converted to C or Fortran order. For\n"
+"contiguous views, \'A\' returns an exact copy of the physical memory.\n"
+"In particular, in-memory Fortran order is preserved. For\n"
+"non-contiguous views, the data is converted to C first. order=None\n"
+"is the same as order=\'C\'.");
#define MEMORYVIEW_TOBYTES_METHODDEF \
{"tobytes", _PyCFunction_CAST(memoryview_tobytes), METH_FASTCALL|METH_KEYWORDS, memoryview_tobytes__doc__},
" sep\n"
" An optional single character or byte to separate hex bytes.\n"
" bytes_per_sep\n"
-" How many bytes between separators. Positive values count from the\n"
-" right, negative values count from the left.\n"
+" How many bytes between separators. Positive values count from\n"
+" the right, negative values count from the left.\n"
"\n"
"Example:\n"
">>> value = memoryview(b\'\\xb9\\x01\\xef\')\n"
exit:
return return_value;
}
-/*[clinic end generated code: output=348b6ddb98a1f412 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=3abf9c80cd49229a input=a9049054013a1b77]*/
"\n"
"Remove and return a (key, value) pair from the dictionary.\n"
"\n"
-"Pairs are returned in LIFO order if last is true or FIFO order if false.");
+"Pairs are returned in LIFO order if last is true or FIFO order if\n"
+"false.");
#define ORDEREDDICT_POPITEM_METHODDEF \
{"popitem", _PyCFunction_CAST(OrderedDict_popitem), METH_FASTCALL|METH_KEYWORDS, OrderedDict_popitem__doc__},
exit:
return return_value;
}
-/*[clinic end generated code: output=7bc997ca7900f06f input=a9049054013a1b77]*/
+/*[clinic end generated code: output=89f7e92de998f9a4 input=a9049054013a1b77]*/
"\n"
"Return a version of the string where each word is titlecased.\n"
"\n"
-"More specifically, words start with uppercased characters and all remaining\n"
-"cased characters have lower case.");
+"More specifically, words start with uppercased characters and all\n"
+"remaining cased characters have lower case.");
#define UNICODE_TITLE_METHODDEF \
{"title", (PyCFunction)unicode_title, METH_NOARGS, unicode_title__doc__},
"\n"
"Return a capitalized version of the string.\n"
"\n"
-"More specifically, make the first character have upper case and the rest lower\n"
-"case.");
+"More specifically, make the first character have upper case and the\n"
+"rest lower case.");
#define UNICODE_CAPITALIZE_METHODDEF \
{"capitalize", (PyCFunction)unicode_capitalize, METH_NOARGS, unicode_capitalize__doc__},
"\n"
"Return a centered string of length width.\n"
"\n"
-"Padding is done using the specified fill character (default is a space).");
+"Padding is done using the specified fill character (default is\n"
+"a space).");
#define UNICODE_CENTER_METHODDEF \
{"center", _PyCFunction_CAST(unicode_center), METH_FASTCALL, unicode_center__doc__},
"\n"
"Return the number of non-overlapping occurrences of substring sub in string S[start:end].\n"
"\n"
-"Optional arguments start and end are interpreted as in slice notation.");
+"Optional arguments start and end are interpreted as in slice\n"
+"notation.");
#define UNICODE_COUNT_METHODDEF \
{"count", _PyCFunction_CAST(unicode_count), METH_FASTCALL, unicode_count__doc__},
" errors\n"
" The error handling scheme to use for encoding errors.\n"
" The default is \'strict\' meaning that encoding errors raise a\n"
-" UnicodeEncodeError. Other possible values are \'ignore\', \'replace\' and\n"
-" \'xmlcharrefreplace\' as well as any other name registered with\n"
+" UnicodeEncodeError. Other possible values are \'ignore\', \'replace\'\n"
+" and \'xmlcharrefreplace\' as well as any other name registered with\n"
" codecs.register_error that can handle UnicodeEncodeErrors.");
#define UNICODE_ENCODE_METHODDEF \
"\n"
"Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end].\n"
"\n"
-"Optional arguments start and end are interpreted as in slice notation.\n"
-"Return -1 on failure.");
+"Optional arguments start and end are interpreted as in slice\n"
+"notation. Return -1 on failure.");
#define UNICODE_FIND_METHODDEF \
{"find", _PyCFunction_CAST(unicode_find), METH_FASTCALL, unicode_find__doc__},
"\n"
"Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end].\n"
"\n"
-"Optional arguments start and end are interpreted as in slice notation.\n"
-"Raises ValueError when the substring is not found.");
+"Optional arguments start and end are interpreted as in slice\n"
+"notation. Raises ValueError when the substring is not found.");
#define UNICODE_INDEX_METHODDEF \
{"index", _PyCFunction_CAST(unicode_index), METH_FASTCALL, unicode_index__doc__},
"\n"
"Return True if the string is a lowercase string, False otherwise.\n"
"\n"
-"A string is lowercase if all cased characters in the string are lowercase and\n"
-"there is at least one cased character in the string.");
+"A string is lowercase if all cased characters in the string are\n"
+"lowercase and there is at least one cased character in the string.");
#define UNICODE_ISLOWER_METHODDEF \
{"islower", (PyCFunction)unicode_islower, METH_NOARGS, unicode_islower__doc__},
"\n"
"Return True if the string is an uppercase string, False otherwise.\n"
"\n"
-"A string is uppercase if all cased characters in the string are uppercase and\n"
-"there is at least one cased character in the string.");
+"A string is uppercase if all cased characters in the string are\n"
+"uppercase and there is at least one cased character in the string.");
#define UNICODE_ISUPPER_METHODDEF \
{"isupper", (PyCFunction)unicode_isupper, METH_NOARGS, unicode_isupper__doc__},
"\n"
"Return True if the string is a whitespace string, False otherwise.\n"
"\n"
-"A string is whitespace if all characters in the string are whitespace and there\n"
-"is at least one character in the string.");
+"A string is whitespace if all characters in the string are\n"
+"whitespace and there is at least one character in the string.");
#define UNICODE_ISSPACE_METHODDEF \
{"isspace", (PyCFunction)unicode_isspace, METH_NOARGS, unicode_isspace__doc__},
"\n"
"Return True if the string is an alphabetic string, False otherwise.\n"
"\n"
-"A string is alphabetic if all characters in the string are alphabetic and there\n"
-"is at least one character in the string.");
+"A string is alphabetic if all characters in the string are\n"
+"alphabetic and there is at least one character in the string.");
#define UNICODE_ISALPHA_METHODDEF \
{"isalpha", (PyCFunction)unicode_isalpha, METH_NOARGS, unicode_isalpha__doc__},
"\n"
"Return True if the string is an alpha-numeric string, False otherwise.\n"
"\n"
-"A string is alpha-numeric if all characters in the string are alpha-numeric and\n"
-"there is at least one character in the string.");
+"A string is alpha-numeric if all characters in the string are\n"
+"alpha-numeric and there is at least one character in the string.");
#define UNICODE_ISALNUM_METHODDEF \
{"isalnum", (PyCFunction)unicode_isalnum, METH_NOARGS, unicode_isalnum__doc__},
"\n"
"Return True if the string is a decimal string, False otherwise.\n"
"\n"
-"A string is a decimal string if all characters in the string are decimal and\n"
-"there is at least one character in the string.");
+"A string is a decimal string if all characters in the string are\n"
+"decimal and there is at least one character in the string.");
#define UNICODE_ISDECIMAL_METHODDEF \
{"isdecimal", (PyCFunction)unicode_isdecimal, METH_NOARGS, unicode_isdecimal__doc__},
"\n"
"Return True if the string is a digit string, False otherwise.\n"
"\n"
-"A string is a digit string if all characters in the string are digits and there\n"
-"is at least one character in the string.");
+"A string is a digit string if all characters in the string are\n"
+"digits and there is at least one character in the string.");
#define UNICODE_ISDIGIT_METHODDEF \
{"isdigit", (PyCFunction)unicode_isdigit, METH_NOARGS, unicode_isdigit__doc__},
"\n"
"Return True if the string is a numeric string, False otherwise.\n"
"\n"
-"A string is numeric if all characters in the string are numeric and there is at\n"
-"least one character in the string.");
+"A string is numeric if all characters in the string are numeric and\n"
+"there is at least one character in the string.");
#define UNICODE_ISNUMERIC_METHODDEF \
{"isnumeric", (PyCFunction)unicode_isnumeric, METH_NOARGS, unicode_isnumeric__doc__},
"\n"
"Return True if the string is a valid Python identifier, False otherwise.\n"
"\n"
-"Call keyword.iskeyword(s) to test whether string s is a reserved identifier,\n"
-"such as \"def\" or \"class\".");
+"Call keyword.iskeyword(s) to test whether string s is a reserved\n"
+"identifier, such as \"def\" or \"class\".");
#define UNICODE_ISIDENTIFIER_METHODDEF \
{"isidentifier", (PyCFunction)unicode_isidentifier, METH_NOARGS, unicode_isidentifier__doc__},
"\n"
"Concatenate any number of strings.\n"
"\n"
-"The string whose method is called is inserted in between each given string.\n"
-"The result is returned as a new string.\n"
+"The string whose method is called is inserted in between each given\n"
+"string. The result is returned as a new string.\n"
"\n"
"Example: \'.\'.join([\'ab\', \'pq\', \'rs\']) -> \'ab.pq.rs\'");
"\n"
"Return a left-justified string of length width.\n"
"\n"
-"Padding is done using the specified fill character (default is a space).");
+"Padding is done using the specified fill character (default is\n"
+"a space).");
#define UNICODE_LJUST_METHODDEF \
{"ljust", _PyCFunction_CAST(unicode_ljust), METH_FASTCALL, unicode_ljust__doc__},
"\n"
"Return a str with the given prefix string removed if present.\n"
"\n"
-"If the string starts with the prefix string, return string[len(prefix):].\n"
-"Otherwise, return a copy of the original string.");
+"If the string starts with the prefix string, return\n"
+"string[len(prefix):]. Otherwise, return a copy of the original\n"
+"string.");
#define UNICODE_REMOVEPREFIX_METHODDEF \
{"removeprefix", (PyCFunction)unicode_removeprefix, METH_O, unicode_removeprefix__doc__},
"\n"
"Return a str with the given suffix string removed if present.\n"
"\n"
-"If the string ends with the suffix string and that suffix is not empty,\n"
-"return string[:-len(suffix)]. Otherwise, return a copy of the original\n"
-"string.");
+"If the string ends with the suffix string and that suffix is not\n"
+"empty, return string[:-len(suffix)]. Otherwise, return a copy of\n"
+"the original string.");
#define UNICODE_REMOVESUFFIX_METHODDEF \
{"removesuffix", (PyCFunction)unicode_removesuffix, METH_O, unicode_removesuffix__doc__},
"\n"
"Return the highest index in S where substring sub is found, such that sub is contained within S[start:end].\n"
"\n"
-"Optional arguments start and end are interpreted as in slice notation.\n"
-"Return -1 on failure.");
+"Optional arguments start and end are interpreted as in slice\n"
+"notation. Return -1 on failure.");
#define UNICODE_RFIND_METHODDEF \
{"rfind", _PyCFunction_CAST(unicode_rfind), METH_FASTCALL, unicode_rfind__doc__},
"\n"
"Return the highest index in S where substring sub is found, such that sub is contained within S[start:end].\n"
"\n"
-"Optional arguments start and end are interpreted as in slice notation.\n"
-"Raises ValueError when the substring is not found.");
+"Optional arguments start and end are interpreted as in slice\n"
+"notation. Raises ValueError when the substring is not found.");
#define UNICODE_RINDEX_METHODDEF \
{"rindex", _PyCFunction_CAST(unicode_rindex), METH_FASTCALL, unicode_rindex__doc__},
"\n"
"Return a right-justified string of length width.\n"
"\n"
-"Padding is done using the specified fill character (default is a space).");
+"Padding is done using the specified fill character (default is\n"
+"a space).");
#define UNICODE_RJUST_METHODDEF \
{"rjust", _PyCFunction_CAST(unicode_rjust), METH_FASTCALL, unicode_rjust__doc__},
" sep\n"
" The separator used to split the string.\n"
"\n"
-" When set to None (the default value), will split on any whitespace\n"
-" character (including \\n \\r \\t \\f and spaces) and will discard\n"
-" empty strings from the result.\n"
+" When set to None (the default value), will split on any\n"
+" whitespace character (including \\n \\r \\t \\f and spaces) and\n"
+" will discard empty strings from the result.\n"
" maxsplit\n"
" Maximum number of splits.\n"
" -1 (the default value) means no limit.\n"
"\n"
"Splitting starts at the front of the string and works to the end.\n"
"\n"
-"Note, str.split() is mainly useful for data that has been intentionally\n"
-"delimited. With natural text that includes punctuation, consider using\n"
-"the regular expression module.");
+"Note, str.split() is mainly useful for data that has been\n"
+"intentionally delimited. With natural text that includes\n"
+"punctuation, consider using the regular expression module.");
#define UNICODE_SPLIT_METHODDEF \
{"split", _PyCFunction_CAST(unicode_split), METH_FASTCALL|METH_KEYWORDS, unicode_split__doc__},
"\n"
"Partition the string into three parts using the given separator.\n"
"\n"
-"This will search for the separator in the string. If the separator is found,\n"
-"returns a 3-tuple containing the part before the separator, the separator\n"
-"itself, and the part after it.\n"
+"This will search for the separator in the string. If the separator\n"
+"is found, returns a 3-tuple containing the part before the\n"
+"separator, the separator itself, and the part after it.\n"
"\n"
-"If the separator is not found, returns a 3-tuple containing the original string\n"
-"and two empty strings.");
+"If the separator is not found, returns a 3-tuple containing\n"
+"the original string and two empty strings.");
#define UNICODE_PARTITION_METHODDEF \
{"partition", (PyCFunction)unicode_partition, METH_O, unicode_partition__doc__},
"\n"
"Partition the string into three parts using the given separator.\n"
"\n"
-"This will search for the separator in the string, starting at the end. If\n"
-"the separator is found, returns a 3-tuple containing the part before the\n"
-"separator, the separator itself, and the part after it.\n"
+"This will search for the separator in the string, starting at the\n"
+"end. If the separator is found, returns a 3-tuple containing the\n"
+"part before the separator, the separator itself, and the part after\n"
+"it.\n"
"\n"
-"If the separator is not found, returns a 3-tuple containing two empty strings\n"
-"and the original string.");
+"If the separator is not found, returns a 3-tuple containing two\n"
+"empty strings and the original string.");
#define UNICODE_RPARTITION_METHODDEF \
{"rpartition", (PyCFunction)unicode_rpartition, METH_O, unicode_rpartition__doc__},
" sep\n"
" The separator used to split the string.\n"
"\n"
-" When set to None (the default value), will split on any whitespace\n"
-" character (including \\n \\r \\t \\f and spaces) and will discard\n"
-" empty strings from the result.\n"
+" When set to None (the default value), will split on any\n"
+" whitespace character (including \\n \\r \\t \\f and spaces) and\n"
+" will discard empty strings from the result.\n"
" maxsplit\n"
" Maximum number of splits.\n"
" -1 (the default value) means no limit.\n"
"\n"
"Return a list of the lines in the string, breaking at line boundaries.\n"
"\n"
-"Line breaks are not included in the resulting list unless keepends is given and\n"
-"true.");
+"Line breaks are not included in the resulting list unless keepends\n"
+"is given and true.");
#define UNICODE_SPLITLINES_METHODDEF \
{"splitlines", _PyCFunction_CAST(unicode_splitlines), METH_FASTCALL|METH_KEYWORDS, unicode_splitlines__doc__},
"\n"
"Return a translation table usable for str.translate().\n"
"\n"
-"If there is only one argument, it must be a dictionary mapping Unicode\n"
-"ordinals (integers) or characters to Unicode ordinals, strings or None.\n"
-"Character keys will be then converted to ordinals.\n"
-"If there are two arguments, they must be strings of equal length, and\n"
-"in the resulting dictionary, each character in x will be mapped to the\n"
-"character at the same position in y. If there is a third argument, it\n"
-"must be a string, whose characters will be mapped to None in the result.");
+"If there is only one argument, it must be a dictionary mapping\n"
+"Unicode ordinals (integers) or characters to Unicode ordinals,\n"
+"strings or None. Character keys will be then converted to ordinals.\n"
+"If there are two arguments, they must be strings of equal length,\n"
+"and in the resulting dictionary, each character in x will be mapped\n"
+"to the character at the same position in y. If there is a third\n"
+"argument, it must be a string, whose characters will be mapped to\n"
+"None in the result.");
#define UNICODE_MAKETRANS_METHODDEF \
{"maketrans", _PyCFunction_CAST(unicode_maketrans), METH_FASTCALL|METH_STATIC, unicode_maketrans__doc__},
"Replace each character in the string using the given translation table.\n"
"\n"
" table\n"
-" Translation table, which must be a mapping of Unicode ordinals to\n"
-" Unicode ordinals, strings, or None.\n"
+" Translation table, which must be a mapping of Unicode ordinals\n"
+" to Unicode ordinals, strings, or None.\n"
"\n"
-"The table must implement lookup/indexing via __getitem__, for instance a\n"
-"dictionary or list. If this operation raises LookupError, the character is\n"
-"left untouched. Characters mapped to None are deleted.");
+"The table must implement lookup/indexing via __getitem__, for\n"
+"instance a dictionary or list. If this operation raises\n"
+"LookupError, the character is left untouched. Characters mapped to\n"
+"None are deleted.");
#define UNICODE_TRANSLATE_METHODDEF \
{"translate", (PyCFunction)unicode_translate, METH_O, unicode_translate__doc__},
exit:
return return_value;
}
-/*[clinic end generated code: output=13eaf65699ea9fc9 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=9d243c63e951e31d input=a9049054013a1b77]*/
(internal-only) Return the local variable name for the given oparg.
-WARNING: this method is for internal use only and may change or go away.
+WARNING: this method is for internal use only and may change or go
+away.
[clinic start generated code]*/
static PyObject *
code__varname_from_oparg_impl(PyCodeObject *self, int oparg)
-/*[clinic end generated code: output=1fd1130413184206 input=c5fa3ee9bac7d4ca]*/
+/*[clinic end generated code: output=1fd1130413184206 input=6ba7d6df0d566463]*/
{
PyObject *name = PyTuple_GetItem(self->co_localsplusnames, oparg);
if (name == NULL) {
}
/*[clinic input]
+@permit_long_summary
@classmethod
dict.fromkeys
iterable: object
static PyObject *
dict_fromkeys_impl(PyTypeObject *type, PyObject *iterable, PyObject *value)
-/*[clinic end generated code: output=8fb98e4b10384999 input=382ba4855d0f74c3]*/
+/*[clinic end generated code: output=8fb98e4b10384999 input=3903715eb48b287e]*/
{
return _PyDict_FromKeys((PyObject *)type, iterable, value);
}
/*[clinic input]
-@permit_long_docstring_body
@classmethod
float.__getformat__
It exists mainly to be used in Python's test suite.
This function returns whichever of 'IEEE, big-endian' or 'IEEE,
-little-endian' best describes the format of floating-point numbers used by the
-C type named by typestr.
+little-endian' best describes the format of floating-point numbers
+used by the C type named by typestr.
[clinic start generated code]*/
static PyObject *
float___getformat___impl(PyTypeObject *type, const char *typestr)
-/*[clinic end generated code: output=2bfb987228cc9628 input=0ae1ba35d192f704]*/
+/*[clinic end generated code: output=2bfb987228cc9628 input=eb1cf45e9bddab72]*/
{
if (strcmp(typestr, "double") != 0 && strcmp(typestr, "float") != 0) {
PyErr_SetString(PyExc_ValueError,
}
/*[clinic input]
+@permit_long_summary
@critical_section
@getter
frame.f_generator as frame_generator
static PyObject *
frame_generator_get_impl(PyFrameObject *self)
-/*[clinic end generated code: output=97aeb2392562e55b input=00a2bd008b239ab0]*/
+/*[clinic end generated code: output=97aeb2392562e55b input=3ffba57ba10f84be]*/
{
if (self->f_frame->owner == FRAME_OWNED_BY_GENERATOR) {
PyObject *gen = (PyObject *)_PyGen_GetGeneratorFromFrame(self->f_frame);
* duplicated).
*/
/*[clinic input]
-@permit_long_docstring_body
@critical_section
list.sort
Sort the list in ascending order and return None.
-The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
-order of two equal elements is maintained).
+The sort is in-place (i.e. the list itself is modified) and stable
+(i.e. the order of two equal elements is maintained).
-If a key function is given, apply it once to each list item and sort them,
-ascending or descending, according to their function values.
+If a key function is given, apply it once to each list item and sort
+them, ascending or descending, according to their function values.
The reverse flag can be set to sort in descending order.
[clinic start generated code]*/
static PyObject *
list_sort_impl(PyListObject *self, PyObject *keyfunc, int reverse)
-/*[clinic end generated code: output=57b9f9c5e23fbe42 input=e4f6b6069181ad7d]*/
+/*[clinic end generated code: output=57b9f9c5e23fbe42 input=c145526281e1fb9f]*/
{
MergeState ms;
Py_ssize_t nremaining;
int.to_bytes
length: Py_ssize_t(allow_negative=False) = 1
- Length of bytes object to use. An OverflowError is raised if the
- integer is not representable with the given number of bytes. Default
- is length 1.
+ Length of bytes object to use. An OverflowError is raised if
+ the integer is not representable with the given number of bytes.
+ Default is length 1.
byteorder: unicode(c_default="NULL") = "big"
- The byte order used to represent the integer. If byteorder is 'big',
- the most significant byte is at the beginning of the byte array. If
- byteorder is 'little', the most significant byte is at the end of the
- byte array. To request the native byte order of the host system, use
- sys.byteorder as the byte order value. Default is to use 'big'.
+ The byte order used to represent the integer. If byteorder is
+ 'big', the most significant byte is at the beginning of the byte
+ array. If byteorder is 'little', the most significant byte is at
+ the end of the byte array. To request the native byte order of
+ the host system, use sys.byteorder as the byte order value.
+ Default is to use 'big'.
*
signed as is_signed: bool = False
- Determines whether two's complement is used to represent the integer.
- If signed is False and a negative integer is given, an OverflowError
- is raised.
+ Determines whether two's complement is used to represent the
+ integer. If signed is False and a negative integer is given,
+ an OverflowError is raised.
Return an array of bytes representing an integer.
[clinic start generated code]*/
static PyObject *
int_to_bytes_impl(PyObject *self, Py_ssize_t length, PyObject *byteorder,
int is_signed)
-/*[clinic end generated code: output=89c801df114050a3 input=66f9d0c20529b44f]*/
+/*[clinic end generated code: output=89c801df114050a3 input=c74a93c07b2f6526]*/
{
int little_endian;
if (byteorder == NULL)
bytes as bytes_obj: object
Holds the array of bytes to convert. The argument must either
- support the buffer protocol or be an iterable object producing bytes.
- Bytes and bytearray are examples of built-in objects that support the
- buffer protocol.
+ support the buffer protocol or be an iterable object producing
+ bytes. Bytes and bytearray are examples of built-in objects that
+ support the buffer protocol.
byteorder: unicode(c_default="NULL") = "big"
- The byte order used to represent the integer. If byteorder is 'big',
- the most significant byte is at the beginning of the byte array. If
- byteorder is 'little', the most significant byte is at the end of the
- byte array. To request the native byte order of the host system, use
- sys.byteorder as the byte order value. Default is to use 'big'.
+ The byte order used to represent the integer. If byteorder is
+ 'big', the most significant byte is at the beginning of the byte
+ array. If byteorder is 'little', the most significant byte is at
+ the end of the byte array. To request the native byte order of
+ the host system, use sys.byteorder as the byte order value.
+ Default is to use 'big'.
*
signed as is_signed: bool = False
- Indicates whether two's complement is used to represent the integer.
+ Indicates whether two's complement is used to represent the
+ integer.
Return the integer represented by the given array of bytes.
[clinic start generated code]*/
static PyObject *
int_from_bytes_impl(PyTypeObject *type, PyObject *bytes_obj,
PyObject *byteorder, int is_signed)
-/*[clinic end generated code: output=efc5d68e31f9314f input=2ff527997fe7b0c5]*/
+/*[clinic end generated code: output=efc5d68e31f9314f input=95801e50b942e164]*/
{
int little_endian;
PyObject *long_obj, *bytes;
}
/*[clinic input]
+@permit_long_summary
int.is_integer
Returns True. Exists for duck type compatibility with float.is_integer.
static PyObject *
int_is_integer_impl(PyObject *self)
-/*[clinic end generated code: output=90f8e794ce5430ef input=7e41c4d4416e05f2]*/
+/*[clinic end generated code: output=90f8e794ce5430ef input=aacf01a2c81c0244]*/
{
Py_RETURN_TRUE;
}
bytes, or bytearray instance representing an integer literal in the\n\
given base. The literal can be preceded by '+' or '-' and be surrounded\n\
by whitespace. The base defaults to 10. Valid bases are 0 and 2-36.\n\
-Base 0 means to interpret the base from the string as an integer literal.\n\
+Base 0 means to interpret the base from the string as an integer\n\
+iteral.\n\
>>> int('0b100', base=0)\n\
4");
}
/*[clinic input]
-@permit_long_docstring_body
memoryview.tobytes
order: str(accept={str, NoneType}, c_default="NULL") = 'C'
Return the data in the buffer as a byte string.
-Order can be {'C', 'F', 'A'}. When order is 'C' or 'F', the data of the
-original array is converted to C or Fortran order. For contiguous views,
-'A' returns an exact copy of the physical memory. In particular, in-memory
-Fortran order is preserved. For non-contiguous views, the data is converted
-to C first. order=None is the same as order='C'.
+Order can be {'C', 'F', 'A'}. When order is 'C' or 'F', the data of
+the original array is converted to C or Fortran order. For
+contiguous views, 'A' returns an exact copy of the physical memory.
+In particular, in-memory Fortran order is preserved. For
+non-contiguous views, the data is converted to C first. order=None
+is the same as order='C'.
[clinic start generated code]*/
static PyObject *
memoryview_tobytes_impl(PyMemoryViewObject *self, const char *order)
-/*[clinic end generated code: output=1288b62560a32a23 input=23c9faf372cfdbcc]*/
+/*[clinic end generated code: output=1288b62560a32a23 input=119c70aa91791dc8]*/
{
Py_buffer *src = VIEW_ADDR(self);
char ord = 'C';
sep: object = NULL
An optional single character or byte to separate hex bytes.
bytes_per_sep: Py_ssize_t = 1
- How many bytes between separators. Positive values count from the
- right, negative values count from the left.
+ How many bytes between separators. Positive values count from
+ the right, negative values count from the left.
Return the data in the buffer as a str of hexadecimal numbers.
static PyObject *
memoryview_hex_impl(PyMemoryViewObject *self, PyObject *sep,
Py_ssize_t bytes_per_sep)
-/*[clinic end generated code: output=c9bb00c7a8e86056 input=dc48a56ed3b058ae]*/
+/*[clinic end generated code: output=c9bb00c7a8e86056 input=3f1c5d08906e3b70]*/
{
Py_buffer *src = VIEW_ADDR(self);
Remove and return a (key, value) pair from the dictionary.
-Pairs are returned in LIFO order if last is true or FIFO order if false.
+Pairs are returned in LIFO order if last is true or FIFO order if
+false.
[clinic start generated code]*/
static PyObject *
OrderedDict_popitem_impl(PyODictObject *self, int last)
-/*[clinic end generated code: output=98e7d986690d49eb input=8aafc7433e0a40e7]*/
+/*[clinic end generated code: output=98e7d986690d49eb input=ebf1cc91579c9e54]*/
{
PyObject *key, *value;
_ODictNode *node;
}
/*[clinic input]
+@permit_long_summary
set.difference as set_difference_multi
so: setobject
*others: array
static PyObject *
set_difference_multi_impl(PySetObject *so, PyObject * const *others,
Py_ssize_t others_length)
-/*[clinic end generated code: output=b0d33fb05d5477a7 input=c1eb448d483416ad]*/
+/*[clinic end generated code: output=b0d33fb05d5477a7 input=e0fbedbf79d91d4e]*/
{
Py_ssize_t i;
PyObject *result, *other;
}
/*[clinic input]
+@permit_long_summary
@critical_section so other
set.symmetric_difference
so: setobject
static PyObject *
set_symmetric_difference_impl(PySetObject *so, PyObject *other)
-/*[clinic end generated code: output=270ee0b5d42b0797 input=624f6e7bbdf70db1]*/
+/*[clinic end generated code: output=270ee0b5d42b0797 input=8c29b0be90d47feb]*/
{
PySetObject *result = (PySetObject *)make_new_set_basetype(Py_TYPE(so), NULL);
if (result == NULL) {
"slice(stop)\n\
slice(start, stop[, step])\n\
\n\
-Create a slice object. This is used for extended slicing (e.g. a[0:10:2]).");
+Create a slice object.\n\
+\n\
+This is used for extended slicing (e.g. a[0:10:2]).");
static void
slice_dealloc(PyObject *op)
"super() -> same as super(__class__, <first argument>)\n"
"super(type) -> unbound super object\n"
"super(type, obj) -> bound super object; requires isinstance(obj, type)\n"
-"super(type, type2) -> bound super object; requires issubclass(type2, type)\n"
+"super(type, type2) -> bound super object; requires\n"
+" issubclass(type2, type)\n"
"Typical use to call a cooperative superclass method:\n"
"class C(B):\n"
" def meth(self, arg):\n"
/* --- Unicode Object Methods --------------------------------------------- */
/*[clinic input]
-@permit_long_docstring_body
str.title as unicode_title
Return a version of the string where each word is titlecased.
-More specifically, words start with uppercased characters and all remaining
-cased characters have lower case.
+More specifically, words start with uppercased characters and all
+remaining cased characters have lower case.
[clinic start generated code]*/
static PyObject *
unicode_title_impl(PyObject *self)
-/*[clinic end generated code: output=c75ae03809574902 input=533ce0eb6a7f5d1b]*/
+/*[clinic end generated code: output=c75ae03809574902 input=2a07e2c7df94627a]*/
{
return case_operation(self, do_title);
}
/*[clinic input]
-@permit_long_docstring_body
str.capitalize as unicode_capitalize
Return a capitalized version of the string.
-More specifically, make the first character have upper case and the rest lower
-case.
+More specifically, make the first character have upper case and the
+rest lower case.
[clinic start generated code]*/
static PyObject *
unicode_capitalize_impl(PyObject *self)
-/*[clinic end generated code: output=e49a4c333cdb7667 input=a4a15ade41f6f9e9]*/
+/*[clinic end generated code: output=e49a4c333cdb7667 input=e50e50ed45a654cf]*/
{
if (PyUnicode_GET_LENGTH(self) == 0)
return unicode_result_unchanged(self);
Return a centered string of length width.
-Padding is done using the specified fill character (default is a space).
+Padding is done using the specified fill character (default is
+a space).
[clinic start generated code]*/
static PyObject *
unicode_center_impl(PyObject *self, Py_ssize_t width, Py_UCS4 fillchar)
-/*[clinic end generated code: output=420c8859effc7c0c input=b42b247eb26e6519]*/
+/*[clinic end generated code: output=420c8859effc7c0c input=df91017dfd186a78]*/
{
Py_ssize_t marg, left;
Return the number of non-overlapping occurrences of substring sub in string S[start:end].
-Optional arguments start and end are interpreted as in slice notation.
+Optional arguments start and end are interpreted as in slice
+notation.
[clinic start generated code]*/
static Py_ssize_t
unicode_count_impl(PyObject *str, PyObject *substr, Py_ssize_t start,
Py_ssize_t end)
-/*[clinic end generated code: output=8fcc3aef0b18edbf input=8590716ee228b935]*/
+/*[clinic end generated code: output=8fcc3aef0b18edbf input=c9209e05438cc352]*/
{
assert(PyUnicode_Check(str));
assert(PyUnicode_Check(substr));
errors: str(c_default="NULL") = 'strict'
The error handling scheme to use for encoding errors.
The default is 'strict' meaning that encoding errors raise a
- UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
- 'xmlcharrefreplace' as well as any other name registered with
+ UnicodeEncodeError. Other possible values are 'ignore', 'replace'
+ and 'xmlcharrefreplace' as well as any other name registered with
codecs.register_error that can handle UnicodeEncodeErrors.
Encode the string using the codec registered for encoding.
static PyObject *
unicode_encode_impl(PyObject *self, const char *encoding, const char *errors)
-/*[clinic end generated code: output=bf78b6e2a9470e3c input=f0a9eb293d08fe02]*/
+/*[clinic end generated code: output=bf78b6e2a9470e3c input=b85a9645cb33b729]*/
{
return PyUnicode_AsEncodedString(self, encoding, errors);
}
Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end].
-Optional arguments start and end are interpreted as in slice notation.
-Return -1 on failure.
+Optional arguments start and end are interpreted as in slice
+notation. Return -1 on failure.
[clinic start generated code]*/
static Py_ssize_t
unicode_find_impl(PyObject *str, PyObject *substr, Py_ssize_t start,
Py_ssize_t end)
-/*[clinic end generated code: output=51dbe6255712e278 input=3a9d650fe4c24695]*/
+/*[clinic end generated code: output=51dbe6255712e278 input=f57e93c59d1ee927]*/
{
Py_ssize_t result = any_find_slice(str, substr, start, end, 1);
if (result < 0) {
Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end].
-Optional arguments start and end are interpreted as in slice notation.
-Raises ValueError when the substring is not found.
+Optional arguments start and end are interpreted as in slice
+notation. Raises ValueError when the substring is not found.
[clinic start generated code]*/
static Py_ssize_t
unicode_index_impl(PyObject *str, PyObject *substr, Py_ssize_t start,
Py_ssize_t end)
-/*[clinic end generated code: output=77558288837cdf40 input=ae5e48f69ed75b06]*/
+/*[clinic end generated code: output=77558288837cdf40 input=5900ab84de55e628]*/
{
Py_ssize_t result = any_find_slice(str, substr, start, end, 1);
if (result == -1) {
}
/*[clinic input]
+@permit_long_summary
str.isascii as unicode_isascii
Return True if all characters in the string are ASCII, False otherwise.
static PyObject *
unicode_isascii_impl(PyObject *self)
-/*[clinic end generated code: output=c5910d64b5a8003f input=5a43cbc6399621d5]*/
+/*[clinic end generated code: output=c5910d64b5a8003f input=dc74e1ced821159f]*/
{
return PyBool_FromLong(PyUnicode_IS_ASCII(self));
}
/*[clinic input]
-@permit_long_docstring_body
str.islower as unicode_islower
Return True if the string is a lowercase string, False otherwise.
-A string is lowercase if all cased characters in the string are lowercase and
-there is at least one cased character in the string.
+A string is lowercase if all cased characters in the string are
+lowercase and there is at least one cased character in the string.
[clinic start generated code]*/
static PyObject *
unicode_islower_impl(PyObject *self)
-/*[clinic end generated code: output=dbd41995bd005b81 input=c6fc0295241a1aaa]*/
+/*[clinic end generated code: output=dbd41995bd005b81 input=1879b48dfc628366]*/
{
Py_ssize_t i, length;
int kind;
}
/*[clinic input]
-@permit_long_docstring_body
str.isupper as unicode_isupper
Return True if the string is an uppercase string, False otherwise.
-A string is uppercase if all cased characters in the string are uppercase and
-there is at least one cased character in the string.
+A string is uppercase if all cased characters in the string are
+uppercase and there is at least one cased character in the string.
[clinic start generated code]*/
static PyObject *
unicode_isupper_impl(PyObject *self)
-/*[clinic end generated code: output=049209c8e7f15f59 input=8d5cb33e67efde72]*/
+/*[clinic end generated code: output=049209c8e7f15f59 input=77d29904aef0e3a0]*/
{
Py_ssize_t i, length;
int kind;
}
/*[clinic input]
-@permit_long_docstring_body
str.isspace as unicode_isspace
Return True if the string is a whitespace string, False otherwise.
-A string is whitespace if all characters in the string are whitespace and there
-is at least one character in the string.
+A string is whitespace if all characters in the string are
+whitespace and there is at least one character in the string.
[clinic start generated code]*/
static PyObject *
unicode_isspace_impl(PyObject *self)
-/*[clinic end generated code: output=163a63bfa08ac2b9 input=44fe05e248c6e159]*/
+/*[clinic end generated code: output=163a63bfa08ac2b9 input=29e09560fc23fbeb]*/
{
Py_ssize_t i, length;
int kind;
}
/*[clinic input]
-@permit_long_docstring_body
str.isalpha as unicode_isalpha
Return True if the string is an alphabetic string, False otherwise.
-A string is alphabetic if all characters in the string are alphabetic and there
-is at least one character in the string.
+A string is alphabetic if all characters in the string are
+alphabetic and there is at least one character in the string.
[clinic start generated code]*/
static PyObject *
unicode_isalpha_impl(PyObject *self)
-/*[clinic end generated code: output=cc81b9ac3883ec4f input=c233000624a56e0d]*/
+/*[clinic end generated code: output=cc81b9ac3883ec4f input=9906a07f3e04892e]*/
{
Py_ssize_t i, length;
int kind;
}
/*[clinic input]
-@permit_long_docstring_body
+@permit_long_summary
str.isalnum as unicode_isalnum
Return True if the string is an alpha-numeric string, False otherwise.
-A string is alpha-numeric if all characters in the string are alpha-numeric and
-there is at least one character in the string.
+A string is alpha-numeric if all characters in the string are
+alpha-numeric and there is at least one character in the string.
[clinic start generated code]*/
static PyObject *
unicode_isalnum_impl(PyObject *self)
-/*[clinic end generated code: output=a5a23490ffc3660c input=5d63ba9c9bafdb6b]*/
+/*[clinic end generated code: output=a5a23490ffc3660c input=892f64ebc171fd4f]*/
{
int kind;
const void *data;
}
/*[clinic input]
-@permit_long_docstring_body
str.isdecimal as unicode_isdecimal
Return True if the string is a decimal string, False otherwise.
-A string is a decimal string if all characters in the string are decimal and
-there is at least one character in the string.
+A string is a decimal string if all characters in the string are
+decimal and there is at least one character in the string.
[clinic start generated code]*/
static PyObject *
unicode_isdecimal_impl(PyObject *self)
-/*[clinic end generated code: output=fb2dcdb62d3fc548 input=8e84a58b414935a3]*/
+/*[clinic end generated code: output=fb2dcdb62d3fc548 input=63b0453c48cad0af]*/
{
Py_ssize_t i, length;
int kind;
}
/*[clinic input]
-@permit_long_docstring_body
str.isdigit as unicode_isdigit
Return True if the string is a digit string, False otherwise.
-A string is a digit string if all characters in the string are digits and there
-is at least one character in the string.
+A string is a digit string if all characters in the string are
+digits and there is at least one character in the string.
[clinic start generated code]*/
static PyObject *
unicode_isdigit_impl(PyObject *self)
-/*[clinic end generated code: output=10a6985311da6858 input=99e284affb54d4a0]*/
+/*[clinic end generated code: output=10a6985311da6858 input=353b03747b062e4b]*/
{
Py_ssize_t i, length;
int kind;
}
/*[clinic input]
-@permit_long_docstring_body
str.isnumeric as unicode_isnumeric
Return True if the string is a numeric string, False otherwise.
-A string is numeric if all characters in the string are numeric and there is at
-least one character in the string.
+A string is numeric if all characters in the string are numeric and
+there is at least one character in the string.
[clinic start generated code]*/
static PyObject *
unicode_isnumeric_impl(PyObject *self)
-/*[clinic end generated code: output=9172a32d9013051a input=e9f5b6b8b29b0ee6]*/
+/*[clinic end generated code: output=9172a32d9013051a input=83b2a072ed7aff48]*/
{
Py_ssize_t i, length;
int kind;
}
/*[clinic input]
-@permit_long_docstring_body
+@permit_long_summary
str.isidentifier as unicode_isidentifier
Return True if the string is a valid Python identifier, False otherwise.
-Call keyword.iskeyword(s) to test whether string s is a reserved identifier,
-such as "def" or "class".
+Call keyword.iskeyword(s) to test whether string s is a reserved
+identifier, such as "def" or "class".
[clinic start generated code]*/
static PyObject *
unicode_isidentifier_impl(PyObject *self)
-/*[clinic end generated code: output=fe585a9666572905 input=86315dd889d7bd04]*/
+/*[clinic end generated code: output=fe585a9666572905 input=cabde62c20a3be6b]*/
{
return PyBool_FromLong(PyUnicode_IsIdentifier(self));
}
}
/*[clinic input]
-@permit_long_docstring_body
str.join as unicode_join
iterable: object
Concatenate any number of strings.
-The string whose method is called is inserted in between each given string.
-The result is returned as a new string.
+The string whose method is called is inserted in between each given
+string. The result is returned as a new string.
Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
[clinic start generated code]*/
static PyObject *
unicode_join(PyObject *self, PyObject *iterable)
-/*[clinic end generated code: output=6857e7cecfe7bf98 input=bac724ed412ef3f8]*/
+/*[clinic end generated code: output=6857e7cecfe7bf98 input=fd330a11ee845fb2]*/
{
return PyUnicode_Join(self, iterable);
}
Return a left-justified string of length width.
-Padding is done using the specified fill character (default is a space).
+Padding is done using the specified fill character (default is
+a space).
[clinic start generated code]*/
static PyObject *
unicode_ljust_impl(PyObject *self, Py_ssize_t width, Py_UCS4 fillchar)
-/*[clinic end generated code: output=1cce0e0e0a0b84b3 input=3ab599e335e60a32]*/
+/*[clinic end generated code: output=1cce0e0e0a0b84b3 input=8a55f06694c20ed6]*/
{
if (PyUnicode_GET_LENGTH(self) >= width)
return unicode_result_unchanged(self);
}
/*[clinic input]
-@permit_long_docstring_body
str.removeprefix as unicode_removeprefix
prefix: unicode
Return a str with the given prefix string removed if present.
-If the string starts with the prefix string, return string[len(prefix):].
-Otherwise, return a copy of the original string.
+If the string starts with the prefix string, return
+string[len(prefix):]. Otherwise, return a copy of the original
+string.
[clinic start generated code]*/
static PyObject *
unicode_removeprefix_impl(PyObject *self, PyObject *prefix)
-/*[clinic end generated code: output=f1e5945e9763bcb9 input=1989a856dbb813f1]*/
+/*[clinic end generated code: output=f1e5945e9763bcb9 input=90d162724944bfa7]*/
{
int match = tailmatch(self, prefix, 0, PY_SSIZE_T_MAX, -1);
if (match == -1) {
Return a str with the given suffix string removed if present.
-If the string ends with the suffix string and that suffix is not empty,
-return string[:-len(suffix)]. Otherwise, return a copy of the original
-string.
+If the string ends with the suffix string and that suffix is not
+empty, return string[:-len(suffix)]. Otherwise, return a copy of
+the original string.
[clinic start generated code]*/
static PyObject *
unicode_removesuffix_impl(PyObject *self, PyObject *suffix)
-/*[clinic end generated code: output=d36629e227636822 input=12cc32561e769be4]*/
+/*[clinic end generated code: output=d36629e227636822 input=6efc96152d4bfcd5]*/
{
int match = tailmatch(self, suffix, 0, PY_SSIZE_T_MAX, +1);
if (match == -1) {
Return the highest index in S where substring sub is found, such that sub is contained within S[start:end].
-Optional arguments start and end are interpreted as in slice notation.
-Return -1 on failure.
+Optional arguments start and end are interpreted as in slice
+notation. Return -1 on failure.
[clinic start generated code]*/
static Py_ssize_t
unicode_rfind_impl(PyObject *str, PyObject *substr, Py_ssize_t start,
Py_ssize_t end)
-/*[clinic end generated code: output=880b29f01dd014c8 input=7f7e97d5cd3299a2]*/
+/*[clinic end generated code: output=880b29f01dd014c8 input=2e67789533baf2f5]*/
{
Py_ssize_t result = any_find_slice(str, substr, start, end, -1);
if (result < 0) {
Return the highest index in S where substring sub is found, such that sub is contained within S[start:end].
-Optional arguments start and end are interpreted as in slice notation.
-Raises ValueError when the substring is not found.
+Optional arguments start and end are interpreted as in slice
+notation. Raises ValueError when the substring is not found.
[clinic start generated code]*/
static Py_ssize_t
unicode_rindex_impl(PyObject *str, PyObject *substr, Py_ssize_t start,
Py_ssize_t end)
-/*[clinic end generated code: output=5f3aef124c867fe1 input=0363a324740b3e62]*/
+/*[clinic end generated code: output=5f3aef124c867fe1 input=e29d446c8234c9d9]*/
{
Py_ssize_t result = any_find_slice(str, substr, start, end, -1);
if (result == -1) {
Return a right-justified string of length width.
-Padding is done using the specified fill character (default is a space).
+Padding is done using the specified fill character (default is
+a space).
[clinic start generated code]*/
static PyObject *
unicode_rjust_impl(PyObject *self, Py_ssize_t width, Py_UCS4 fillchar)
-/*[clinic end generated code: output=804a1a57fbe8d5cf input=d05f550b5beb1f72]*/
+/*[clinic end generated code: output=804a1a57fbe8d5cf input=1256a8d659589907]*/
{
if (PyUnicode_GET_LENGTH(self) >= width)
return unicode_result_unchanged(self);
sep: object = None
The separator used to split the string.
- When set to None (the default value), will split on any whitespace
- character (including \n \r \t \f and spaces) and will discard
- empty strings from the result.
+ When set to None (the default value), will split on any
+ whitespace character (including \n \r \t \f and spaces) and
+ will discard empty strings from the result.
maxsplit: Py_ssize_t = -1
Maximum number of splits.
-1 (the default value) means no limit.
Splitting starts at the front of the string and works to the end.
-Note, str.split() is mainly useful for data that has been intentionally
-delimited. With natural text that includes punctuation, consider using
-the regular expression module.
+Note, str.split() is mainly useful for data that has been
+intentionally delimited. With natural text that includes
+punctuation, consider using the regular expression module.
[clinic start generated code]*/
static PyObject *
unicode_split_impl(PyObject *self, PyObject *sep, Py_ssize_t maxsplit)
-/*[clinic end generated code: output=3a65b1db356948dc input=2c1fd08a78e038b8]*/
+/*[clinic end generated code: output=3a65b1db356948dc input=288cfd6bc8828f5a]*/
{
if (sep == Py_None)
return split(self, NULL, maxsplit);
}
/*[clinic input]
-@permit_long_docstring_body
str.partition as unicode_partition
sep: object
Partition the string into three parts using the given separator.
-This will search for the separator in the string. If the separator is found,
-returns a 3-tuple containing the part before the separator, the separator
-itself, and the part after it.
+This will search for the separator in the string. If the separator
+is found, returns a 3-tuple containing the part before the
+separator, the separator itself, and the part after it.
-If the separator is not found, returns a 3-tuple containing the original string
-and two empty strings.
+If the separator is not found, returns a 3-tuple containing
+the original string and two empty strings.
[clinic start generated code]*/
static PyObject *
unicode_partition(PyObject *self, PyObject *sep)
-/*[clinic end generated code: output=e4ced7bd253ca3c4 input=4d854b520d7b0e97]*/
+/*[clinic end generated code: output=e4ced7bd253ca3c4 input=e45faa8c26270cb1]*/
{
return PyUnicode_Partition(self, sep);
}
/*[clinic input]
-@permit_long_docstring_body
str.rpartition as unicode_rpartition = str.partition
Partition the string into three parts using the given separator.
-This will search for the separator in the string, starting at the end. If
-the separator is found, returns a 3-tuple containing the part before the
-separator, the separator itself, and the part after it.
+This will search for the separator in the string, starting at the
+end. If the separator is found, returns a 3-tuple containing the
+part before the separator, the separator itself, and the part after
+it.
-If the separator is not found, returns a 3-tuple containing two empty strings
-and the original string.
+If the separator is not found, returns a 3-tuple containing two
+empty strings and the original string.
[clinic start generated code]*/
static PyObject *
unicode_rpartition(PyObject *self, PyObject *sep)
-/*[clinic end generated code: output=1aa13cf1156572aa input=a6adabe91e75b486]*/
+/*[clinic end generated code: output=1aa13cf1156572aa input=53a7f8cb19975b7c]*/
{
return PyUnicode_RPartition(self, sep);
}
}
/*[clinic input]
-@permit_long_docstring_body
+@permit_long_summary
str.splitlines as unicode_splitlines
keepends: bool = False
Return a list of the lines in the string, breaking at line boundaries.
-Line breaks are not included in the resulting list unless keepends is given and
-true.
+Line breaks are not included in the resulting list unless keepends
+is given and true.
[clinic start generated code]*/
static PyObject *
unicode_splitlines_impl(PyObject *self, int keepends)
-/*[clinic end generated code: output=f664dcdad153ec40 input=39eeafbfef61c827]*/
+/*[clinic end generated code: output=f664dcdad153ec40 input=b45ea0f87645a06d]*/
{
return PyUnicode_Splitlines(self, keepends);
}
Return a translation table usable for str.translate().
-If there is only one argument, it must be a dictionary mapping Unicode
-ordinals (integers) or characters to Unicode ordinals, strings or None.
-Character keys will be then converted to ordinals.
-If there are two arguments, they must be strings of equal length, and
-in the resulting dictionary, each character in x will be mapped to the
-character at the same position in y. If there is a third argument, it
-must be a string, whose characters will be mapped to None in the result.
+If there is only one argument, it must be a dictionary mapping
+Unicode ordinals (integers) or characters to Unicode ordinals,
+strings or None. Character keys will be then converted to ordinals.
+If there are two arguments, they must be strings of equal length,
+and in the resulting dictionary, each character in x will be mapped
+to the character at the same position in y. If there is a third
+argument, it must be a string, whose characters will be mapped to
+None in the result.
[clinic start generated code]*/
static PyObject *
unicode_maketrans_impl(PyObject *x, PyObject *y, PyObject *z)
-/*[clinic end generated code: output=a925c89452bd5881 input=7bfbf529a293c6c5]*/
+/*[clinic end generated code: output=a925c89452bd5881 input=66bc00a1b4258a6e]*/
{
PyObject *new = NULL, *key, *value;
Py_ssize_t i = 0;
}
/*[clinic input]
-@permit_long_docstring_body
+@permit_long_summary
str.translate as unicode_translate
table: object
- Translation table, which must be a mapping of Unicode ordinals to
- Unicode ordinals, strings, or None.
+ Translation table, which must be a mapping of Unicode ordinals
+ to Unicode ordinals, strings, or None.
/
Replace each character in the string using the given translation table.
-The table must implement lookup/indexing via __getitem__, for instance a
-dictionary or list. If this operation raises LookupError, the character is
-left untouched. Characters mapped to None are deleted.
+The table must implement lookup/indexing via __getitem__, for
+instance a dictionary or list. If this operation raises
+LookupError, the character is left untouched. Characters mapped to
+None are deleted.
[clinic start generated code]*/
static PyObject *
unicode_translate(PyObject *self, PyObject *table)
-/*[clinic end generated code: output=3cb448ff2fd96bf3 input=699e5fa0ebf9f5e9]*/
+/*[clinic end generated code: output=3cb448ff2fd96bf3 input=48cf0efe06bc1b75]*/
{
return _PyUnicode_TranslateCharmap(self, table, "ignore");
}
The substitutions are identified by braces ('{' and '}').");
/*[clinic input]
+@permit_long_summary
str.__format__ as unicode___format__
format_spec: unicode
static PyObject *
unicode___format___impl(PyObject *self, PyObject *format_spec)
-/*[clinic end generated code: output=45fceaca6d2ba4c8 input=5e135645d167a214]*/
+/*[clinic end generated code: output=45fceaca6d2ba4c8 input=77a2a19f3f7969f2]*/
{
_PyUnicodeWriter writer;
int ret;
Internal helper function used by the class statement.");
/*[clinic input]
-@permit_long_docstring_body
__import__ as builtin___import__
name: object
empty list to emulate ``import name``.
When importing a module from a package, note that __import__('A.B', ...)
returns package A when fromlist is empty, but its submodule B when
-fromlist is not empty. The level argument is used to determine whether to
-perform absolute or relative imports: 0 is absolute, while a positive number
-is the number of parent directories to search relative to the current module.
+fromlist is not empty. The level argument is used to determine whether
+to perform absolute or relative imports: 0 is absolute, while a positive
+number is the number of parent directories to search relative to the
+current module.
[clinic start generated code]*/
static PyObject *
builtin___import___impl(PyObject *module, PyObject *name, PyObject *globals,
PyObject *locals, PyObject *fromlist, int level)
-/*[clinic end generated code: output=4febeda88a0cd245 input=01a3283590eae93a]*/
+/*[clinic end generated code: output=4febeda88a0cd245 input=e3096a230383f72d]*/
{
return PyImport_ImportModuleLevelObject(name, globals, locals,
fromlist, level);
Lazily imports a module.
-Returns either the module to be imported or a imp.lazy_module object which
-indicates the module to be lazily imported.
+Returns either the module to be imported or a imp.lazy_module object
+which indicates the module to be lazily imported.
[clinic start generated code]*/
static PyObject *
builtin___lazy_import___impl(PyObject *module, PyObject *name,
PyObject *globals, PyObject *locals,
PyObject *fromlist, int level)
-/*[clinic end generated code: output=300f1771094b9e8c input=9394874f340b2948]*/
+/*[clinic end generated code: output=300f1771094b9e8c input=9c85cccd6a885b9b]*/
{
PyObject *builtins;
PyThreadState *tstate = PyThreadState_GET();
"filter(function, iterable, /)\n\
--\n\
\n\
-Return an iterator yielding those items of iterable for which function(item)\n\
-is true. If function is None, return the items that are true.");
+Return an iterator yielding those items of iterable for which\n\
+function(item) is true. If function is None, return the items that\n\
+are true.");
PyTypeObject PyFilter_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
}
/*[clinic input]
+@permit_long_summary
chr as builtin_chr
i: object
static PyObject *
builtin_chr(PyObject *module, PyObject *i)
-/*[clinic end generated code: output=d34f25b8035a9b10 input=f919867f0ba2f496]*/
+/*[clinic end generated code: output=d34f25b8035a9b10 input=a9b255f2d2e503f0]*/
{
int overflow;
long v = PyLong_AsLongAndOverflow(i, &overflow);
/*[clinic input]
+@permit_long_summary
compile as builtin_compile
source: object
Compile source into a code object that can be executed by exec() or eval().
-The source code may represent a Python module, statement or expression.
+The source code may represent a Python module, statement or
+expression.
The filename will be used for run-time error messages.
The mode must be 'exec' to compile a module, 'single' to compile a
single (interactive) statement, or 'eval' to compile an expression.
-The flags argument, if present, controls which future statements influence
-the compilation of the code.
+The flags argument, if present, controls which future statements
+influence the compilation of the code.
The dont_inherit argument, if true, stops the compilation inheriting
the effects of any future statements in effect in the code calling
-compile; if absent or false these statements do influence the compilation,
-in addition to any features explicitly specified.
+compile; if absent or false these statements do influence the
+compilation, in addition to any features explicitly specified.
[clinic start generated code]*/
static PyObject *
builtin_compile_impl(PyObject *module, PyObject *source, PyObject *filename,
const char *mode, int flags, int dont_inherit,
int optimize, PyObject *modname, int feature_version)
-/*[clinic end generated code: output=9a0dce1945917a86 input=ddeae1e0253459dc]*/
+/*[clinic end generated code: output=9a0dce1945917a86 input=444c4fe466a97279]*/
{
PyObject *source_copy;
const char *str;
"dir([object]) -> list of strings\n"
"\n"
"If called without an argument, return the names in the current scope.\n"
-"Else, return an alphabetized list of names comprising (some of) the attributes\n"
-"of the given object, and of attributes reachable from it.\n"
-"If the object supplies a method named __dir__, it will be used; otherwise\n"
-"the default dir() logic is used and returns:\n"
+"Else, return an alphabetized list of names comprising (some of) the\n"
+"attributes of the given object, and of attributes reachable from it.\n"
+"If the object supplies a method named __dir__, it will be used;\n"
+"otherwise the default dir() logic is used and returns:\n"
" for a module object: the module's attributes.\n"
" for a class object: its attributes, and recursively the attributes\n"
" of its bases.\n"
PyDoc_STRVAR(getattr_doc,
"getattr(object, name[, default]) -> value\n\
\n\
-Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.\n\
-When a default argument is given, it is returned when the attribute doesn't\n\
-exist; without it, an exception is raised in that case.");
+Get a named attribute from an object.\n\
+\n\
+getattr(x, 'y') is equivalent to x.y.\n\
+When a default argument is given, it is returned when the attribute\n\
+doesn't exist; without it, an exception is raised in that case.");
/*[clinic input]
Return the dictionary containing the current scope's global variables.
-NOTE: Updates to this dictionary *will* affect name lookups in the current
-global scope and vice-versa.
+NOTE: Updates to this dictionary *will* affect name lookups in the
+current global scope and vice-versa.
[clinic start generated code]*/
static PyObject *
builtin_globals_impl(PyObject *module)
-/*[clinic end generated code: output=e5dd1527067b94d2 input=9327576f92bb48ba]*/
+/*[clinic end generated code: output=e5dd1527067b94d2 input=6d725a9b48d1eaeb]*/
{
PyObject *globals;
if (_PyEval_GetFrame() != NULL) {
Make an iterator that computes the function using arguments from\n\
each of the iterables. Stops when the shortest iterable is exhausted.\n\
\n\
-If strict is true and one of the arguments is exhausted before the others,\n\
-raise a ValueError.");
+If strict is true and one of the arguments is exhausted before the\n\
+others, raise a ValueError.");
PyTypeObject PyMap_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
PyDoc_STRVAR(next_doc,
"next(iterator[, default])\n\
\n\
-Return the next item from the iterator. If default is given and the iterator\n\
-is exhausted, it is returned instead of raising StopIteration.");
+Return the next item from the iterator. If default is given and the\n\
+iterator is exhausted, it is returned instead of raising StopIteration.");
/*[clinic input]
\n\
Get an iterator from an object. In the first form, the argument must\n\
supply its own iterator, or be a sequence.\n\
-In the second form, the callable is called until it returns the sentinel.");
+In the second form, the callable is called until it returns the\n\
+sentinel.");
/*[clinic input]
Return a dictionary containing the current scope's local variables.
-NOTE: Whether or not updates to this dictionary will affect name lookups in
-the local scope and vice-versa is *implementation dependent* and not
-covered by any backwards compatibility guarantees.
+NOTE: Whether or not updates to this dictionary will affect name
+lookups in the local scope and vice-versa is *implementation
+dependent* and not covered by any backwards compatibility
+guarantees.
[clinic start generated code]*/
static PyObject *
builtin_locals_impl(PyObject *module)
-/*[clinic end generated code: output=b46c94015ce11448 input=7874018d478d5c4b]*/
+/*[clinic end generated code: output=b46c94015ce11448 input=989cc75c22167c42]*/
{
PyObject *locals;
if (_PyEval_GetFrame() != NULL) {
/*[clinic input]
+@permit_long_summary
pow as builtin_pow
base: object
Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments
-Some types, such as ints, are able to use a more efficient algorithm when
-invoked using the three argument form.
+Some types, such as ints, are able to use a more efficient algorithm
+when invoked using the three argument form.
[clinic start generated code]*/
static PyObject *
builtin_pow_impl(PyObject *module, PyObject *base, PyObject *exp,
PyObject *mod)
-/*[clinic end generated code: output=3ca1538221bbf15f input=435dbd48a12efb23]*/
+/*[clinic end generated code: output=3ca1538221bbf15f input=0cd5c3ecc8003aec]*/
{
return PyNumber_Power(base, exp, mod);
}
The prompt string, if given, is printed to standard output without a
trailing newline before reading input.
-If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise
+EOFError.
On *nix systems, readline is used if available.
[clinic start generated code]*/
static PyObject *
builtin_input_impl(PyObject *module, PyObject *prompt)
-/*[clinic end generated code: output=83db5a191e7a0d60 input=159c46d4ae40977e]*/
+/*[clinic end generated code: output=83db5a191e7a0d60 input=ebb939c954639427]*/
{
PyObject *fin = NULL;
PyObject *fout = NULL;
Round a number to a given precision in decimal digits.
-The return value is an integer if ndigits is omitted or None. Otherwise
-the return value has the same type as the number. ndigits may be negative.
+The return value is an integer if ndigits is omitted or None.
+Otherwise the return value has the same type as the number. ndigits
+may be negative.
[clinic start generated code]*/
static PyObject *
builtin_round_impl(PyObject *module, PyObject *number, PyObject *ndigits)
-/*[clinic end generated code: output=ff0d9dd176c02ede input=275678471d7aca15]*/
+/*[clinic end generated code: output=ff0d9dd176c02ede input=bdcb7c67bf4a4320]*/
{
PyObject *result;
if (ndigits == Py_None) {
Return a new list containing all items from the iterable in ascending order.
-A custom key function can be supplied to customize the sort order, and the
-reverse flag can be set to request the result in descending order.
+A custom key function can be supplied to customize the sort order, and
+the reverse flag can be set to request the result in descending order.
[end disabled clinic input]*/
PyDoc_STRVAR(builtin_sorted__doc__,
}
/*[clinic input]
+@permit_long_summary
sum as builtin_sum
iterable: object
Return the sum of a 'start' value (default: 0) plus an iterable of numbers
When the iterable is empty, return the start value.
-This function is intended specifically for use with numeric values and may
-reject non-numeric types.
+This function is intended specifically for use with numeric values and
+may reject non-numeric types.
[clinic start generated code]*/
static PyObject *
builtin_sum_impl(PyObject *module, PyObject *iterable, PyObject *start)
-/*[clinic end generated code: output=df758cec7d1d302f input=162b50765250d222]*/
+/*[clinic end generated code: output=df758cec7d1d302f input=d464d57815196b73]*/
{
PyObject *result = start;
PyObject *temp, *item, *iter;
/*[clinic input]
+@permit_long_summary
isinstance as builtin_isinstance
obj: object
Return whether an object is an instance of a class or of a subclass thereof.
-A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to
-check against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)
-or ...`` etc.
+A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the
+target to check against. This is equivalent to ``isinstance(x, A) or
+isinstance(x, B) or ...`` etc.
[clinic start generated code]*/
static PyObject *
builtin_isinstance_impl(PyObject *module, PyObject *obj,
PyObject *class_or_tuple)
-/*[clinic end generated code: output=6faf01472c13b003 input=ffa743db1daf7549]*/
+/*[clinic end generated code: output=6faf01472c13b003 input=5d74d547df498f38]*/
{
int retval;
Return whether 'cls' is derived from another class or is the same class.
-A tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the target to
-check against. This is equivalent to ``issubclass(x, A) or issubclass(x, B)
-or ...``.
+A tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the
+target to check against. This is equivalent to ``issubclass(x, A) or
+issubclass(x, B) or ...``.
[clinic start generated code]*/
static PyObject *
builtin_issubclass_impl(PyObject *module, PyObject *cls,
PyObject *class_or_tuple)
-/*[clinic end generated code: output=358412410cd7a250 input=a24b9f3d58c370d6]*/
+/*[clinic end generated code: output=358412410cd7a250 input=a91ce96345a6705d]*/
{
int retval;
"zip(*iterables, strict=False)\n\
--\n\
\n\
-The zip object yields n-length tuples, where n is the number of iterables\n\
-passed as positional arguments to zip(). The i-th element in every tuple\n\
-comes from the i-th iterable argument to zip(). This continues until the\n\
-shortest argument is exhausted.\n\
+The zip object yields n-length tuples, where n is the number of\n\
+iterables passed as positional arguments to zip(). The i-th element\n\
+in every tuple comes from the i-th iterable argument to zip(). This\n\
+continues until the shortest argument is exhausted.\n\
\n\
-If strict is true and one of the arguments is exhausted before the others,\n\
-raise a ValueError.\n\
+If strict is true and one of the arguments is exhausted before the\n\
+others, raise a ValueError.\n\
\n\
>>> list(zip('abcdefg', range(3), range(4)))\n\
[('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]");
"empty list to emulate ``import name``.\n"
"When importing a module from a package, note that __import__(\'A.B\', ...)\n"
"returns package A when fromlist is empty, but its submodule B when\n"
-"fromlist is not empty. The level argument is used to determine whether to\n"
-"perform absolute or relative imports: 0 is absolute, while a positive number\n"
-"is the number of parent directories to search relative to the current module.");
+"fromlist is not empty. The level argument is used to determine whether\n"
+"to perform absolute or relative imports: 0 is absolute, while a positive\n"
+"number is the number of parent directories to search relative to the\n"
+"current module.");
#define BUILTIN___IMPORT___METHODDEF \
{"__import__", _PyCFunction_CAST(builtin___import__), METH_FASTCALL|METH_KEYWORDS, builtin___import____doc__},
"\n"
"Lazily imports a module.\n"
"\n"
-"Returns either the module to be imported or a imp.lazy_module object which\n"
-"indicates the module to be lazily imported.");
+"Returns either the module to be imported or a imp.lazy_module object\n"
+"which indicates the module to be lazily imported.");
#define BUILTIN___LAZY_IMPORT___METHODDEF \
{"__lazy_import__", _PyCFunction_CAST(builtin___lazy_import__), METH_FASTCALL|METH_KEYWORDS, builtin___lazy_import____doc__},
"\n"
"Compile source into a code object that can be executed by exec() or eval().\n"
"\n"
-"The source code may represent a Python module, statement or expression.\n"
+"The source code may represent a Python module, statement or\n"
+"expression.\n"
"The filename will be used for run-time error messages.\n"
"The mode must be \'exec\' to compile a module, \'single\' to compile a\n"
"single (interactive) statement, or \'eval\' to compile an expression.\n"
-"The flags argument, if present, controls which future statements influence\n"
-"the compilation of the code.\n"
+"The flags argument, if present, controls which future statements\n"
+"influence the compilation of the code.\n"
"The dont_inherit argument, if true, stops the compilation inheriting\n"
"the effects of any future statements in effect in the code calling\n"
-"compile; if absent or false these statements do influence the compilation,\n"
-"in addition to any features explicitly specified.");
+"compile; if absent or false these statements do influence the\n"
+"compilation, in addition to any features explicitly specified.");
#define BUILTIN_COMPILE_METHODDEF \
{"compile", _PyCFunction_CAST(builtin_compile), METH_FASTCALL|METH_KEYWORDS, builtin_compile__doc__},
"\n"
"Return the dictionary containing the current scope\'s global variables.\n"
"\n"
-"NOTE: Updates to this dictionary *will* affect name lookups in the current\n"
-"global scope and vice-versa.");
+"NOTE: Updates to this dictionary *will* affect name lookups in the\n"
+"current global scope and vice-versa.");
#define BUILTIN_GLOBALS_METHODDEF \
{"globals", (PyCFunction)builtin_globals, METH_NOARGS, builtin_globals__doc__},
"\n"
"Return a dictionary containing the current scope\'s local variables.\n"
"\n"
-"NOTE: Whether or not updates to this dictionary will affect name lookups in\n"
-"the local scope and vice-versa is *implementation dependent* and not\n"
-"covered by any backwards compatibility guarantees.");
+"NOTE: Whether or not updates to this dictionary will affect name\n"
+"lookups in the local scope and vice-versa is *implementation\n"
+"dependent* and not covered by any backwards compatibility\n"
+"guarantees.");
#define BUILTIN_LOCALS_METHODDEF \
{"locals", (PyCFunction)builtin_locals, METH_NOARGS, builtin_locals__doc__},
"\n"
"Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments\n"
"\n"
-"Some types, such as ints, are able to use a more efficient algorithm when\n"
-"invoked using the three argument form.");
+"Some types, such as ints, are able to use a more efficient algorithm\n"
+"when invoked using the three argument form.");
#define BUILTIN_POW_METHODDEF \
{"pow", _PyCFunction_CAST(builtin_pow), METH_FASTCALL|METH_KEYWORDS, builtin_pow__doc__},
"The prompt string, if given, is printed to standard output without a\n"
"trailing newline before reading input.\n"
"\n"
-"If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.\n"
+"If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise\n"
+"EOFError.\n"
"On *nix systems, readline is used if available.");
#define BUILTIN_INPUT_METHODDEF \
"\n"
"Round a number to a given precision in decimal digits.\n"
"\n"
-"The return value is an integer if ndigits is omitted or None. Otherwise\n"
-"the return value has the same type as the number. ndigits may be negative.");
+"The return value is an integer if ndigits is omitted or None.\n"
+"Otherwise the return value has the same type as the number. ndigits\n"
+"may be negative.");
#define BUILTIN_ROUND_METHODDEF \
{"round", _PyCFunction_CAST(builtin_round), METH_FASTCALL|METH_KEYWORDS, builtin_round__doc__},
"Return the sum of a \'start\' value (default: 0) plus an iterable of numbers\n"
"\n"
"When the iterable is empty, return the start value.\n"
-"This function is intended specifically for use with numeric values and may\n"
-"reject non-numeric types.");
+"This function is intended specifically for use with numeric values and\n"
+"may reject non-numeric types.");
#define BUILTIN_SUM_METHODDEF \
{"sum", _PyCFunction_CAST(builtin_sum), METH_FASTCALL|METH_KEYWORDS, builtin_sum__doc__},
"\n"
"Return whether an object is an instance of a class or of a subclass thereof.\n"
"\n"
-"A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to\n"
-"check against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)\n"
-"or ...`` etc.");
+"A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the\n"
+"target to check against. This is equivalent to ``isinstance(x, A) or\n"
+"isinstance(x, B) or ...`` etc.");
#define BUILTIN_ISINSTANCE_METHODDEF \
{"isinstance", _PyCFunction_CAST(builtin_isinstance), METH_FASTCALL, builtin_isinstance__doc__},
"\n"
"Return whether \'cls\' is derived from another class or is the same class.\n"
"\n"
-"A tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the target to\n"
-"check against. This is equivalent to ``issubclass(x, A) or issubclass(x, B)\n"
-"or ...``.");
+"A tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the\n"
+"target to check against. This is equivalent to ``issubclass(x, A) or\n"
+"issubclass(x, B) or ...``.");
#define BUILTIN_ISSUBCLASS_METHODDEF \
{"issubclass", _PyCFunction_CAST(builtin_issubclass), METH_FASTCALL, builtin_issubclass__doc__},
exit:
return return_value;
}
-/*[clinic end generated code: output=f1fc836a63d89826 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=84efa9c5cc737ce5 input=a9049054013a1b77]*/
projects / thirdparty / Python / cpython.git / commitdiff
