/src/cpython/Modules/_io/clinic/bytesio.c.h

Source
/*[clinic input]
preserve
[clinic start generated code]*/

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
#  include "pycore_gc.h"          // PyGC_Head
#  include "pycore_runtime.h"     // _Py_ID()
#endif
#include "pycore_abstract.h"      // _Py_convert_optional_to_ssize_t()
#include "pycore_critical_section.h"// Py_BEGIN_CRITICAL_SECTION()
#include "pycore_modsupport.h"    // _PyArg_CheckPositional()

PyDoc_STRVAR(_io_BytesIO_readable__doc__,
"readable($self, /)\n"
"--\n"
"\n"
"Returns True if the IO object can be read.");

#define _IO_BYTESIO_READABLE_METHODDEF    \
    {"readable", (PyCFunction)_io_BytesIO_readable, METH_NOARGS, _io_BytesIO_readable__doc__},

static PyObject *
_io_BytesIO_readable_impl(bytesio *self);

static PyObject *
_io_BytesIO_readable(PyObject *self, PyObject *Py_UNUSED(ignored))
{
    PyObject *return_value = NULL;

    Py_BEGIN_CRITICAL_SECTION(self);
    return_value = _io_BytesIO_readable_impl((bytesio *)self);
    Py_END_CRITICAL_SECTION();

    return return_value;
}

PyDoc_STRVAR(_io_BytesIO_writable__doc__,
"writable($self, /)\n"
"--\n"
"\n"
"Returns True if the IO object can be written.");

#define _IO_BYTESIO_WRITABLE_METHODDEF    \
    {"writable", (PyCFunction)_io_BytesIO_writable, METH_NOARGS, _io_BytesIO_writable__doc__},

static PyObject *
_io_BytesIO_writable_impl(bytesio *self);

static PyObject *
_io_BytesIO_writable(PyObject *self, PyObject *Py_UNUSED(ignored))
{
    PyObject *return_value = NULL;

    Py_BEGIN_CRITICAL_SECTION(self);
    return_value = _io_BytesIO_writable_impl((bytesio *)self);
    Py_END_CRITICAL_SECTION();

    return return_value;
}

PyDoc_STRVAR(_io_BytesIO_seekable__doc__,
"seekable($self, /)\n"
"--\n"
"\n"
"Returns True if the IO object can be seeked.");

#define _IO_BYTESIO_SEEKABLE_METHODDEF    \
    {"seekable", (PyCFunction)_io_BytesIO_seekable, METH_NOARGS, _io_BytesIO_seekable__doc__},

static PyObject *
_io_BytesIO_seekable_impl(bytesio *self);

static PyObject *
_io_BytesIO_seekable(PyObject *self, PyObject *Py_UNUSED(ignored))
{
    PyObject *return_value = NULL;

    Py_BEGIN_CRITICAL_SECTION(self);
    return_value = _io_BytesIO_seekable_impl((bytesio *)self);
    Py_END_CRITICAL_SECTION();

    return return_value;
}

PyDoc_STRVAR(_io_BytesIO_flush__doc__,
"flush($self, /)\n"
"--\n"
"\n"
"Does nothing.");

#define _IO_BYTESIO_FLUSH_METHODDEF    \
    {"flush", (PyCFunction)_io_BytesIO_flush, METH_NOARGS, _io_BytesIO_flush__doc__},

static PyObject *
_io_BytesIO_flush_impl(bytesio *self);

static PyObject *
_io_BytesIO_flush(PyObject *self, PyObject *Py_UNUSED(ignored))
{
    PyObject *return_value = NULL;

    Py_BEGIN_CRITICAL_SECTION(self);
    return_value = _io_BytesIO_flush_impl((bytesio *)self);
    Py_END_CRITICAL_SECTION();

    return return_value;
}

PyDoc_STRVAR(_io_BytesIO_getbuffer__doc__,
"getbuffer($self, /)\n"
"--\n"
"\n"
"Get a read-write view over the contents of the BytesIO object.");

#define _IO_BYTESIO_GETBUFFER_METHODDEF    \
    {"getbuffer", _PyCFunction_CAST(_io_BytesIO_getbuffer), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _io_BytesIO_getbuffer__doc__},

static PyObject *
_io_BytesIO_getbuffer_impl(bytesio *self, PyTypeObject *cls);

static PyObject *
_io_BytesIO_getbuffer(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
    PyObject *return_value = NULL;

    if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {
        PyErr_SetString(PyExc_TypeError, "getbuffer() takes no arguments");
        goto exit;
    }
    Py_BEGIN_CRITICAL_SECTION(self);
    return_value = _io_BytesIO_getbuffer_impl((bytesio *)self, cls);
    Py_END_CRITICAL_SECTION();

exit:
    return return_value;
}

PyDoc_STRVAR(_io_BytesIO_getvalue__doc__,
"getvalue($self, /)\n"
"--\n"
"\n"
"Retrieve the entire contents of the BytesIO object.");

#define _IO_BYTESIO_GETVALUE_METHODDEF    \
    {"getvalue", (PyCFunction)_io_BytesIO_getvalue, METH_NOARGS, _io_BytesIO_getvalue__doc__},

static PyObject *
_io_BytesIO_getvalue_impl(bytesio *self);

static PyObject *
_io_BytesIO_getvalue(PyObject *self, PyObject *Py_UNUSED(ignored))
{
    PyObject *return_value = NULL;

    Py_BEGIN_CRITICAL_SECTION(self);
    return_value = _io_BytesIO_getvalue_impl((bytesio *)self);
    Py_END_CRITICAL_SECTION();

    return return_value;
}

PyDoc_STRVAR(_io_BytesIO_isatty__doc__,
"isatty($self, /)\n"
"--\n"
"\n"
"Always returns False.\n"
"\n"
"BytesIO objects are not connected to a TTY-like device.");

#define _IO_BYTESIO_ISATTY_METHODDEF    \
    {"isatty", (PyCFunction)_io_BytesIO_isatty, METH_NOARGS, _io_BytesIO_isatty__doc__},

static PyObject *
_io_BytesIO_isatty_impl(bytesio *self);

static PyObject *
_io_BytesIO_isatty(PyObject *self, PyObject *Py_UNUSED(ignored))
{
    PyObject *return_value = NULL;

    Py_BEGIN_CRITICAL_SECTION(self);
    return_value = _io_BytesIO_isatty_impl((bytesio *)self);
    Py_END_CRITICAL_SECTION();

    return return_value;
}

PyDoc_STRVAR(_io_BytesIO_tell__doc__,
"tell($self, /)\n"
"--\n"
"\n"
"Current file position, an integer.");

#define _IO_BYTESIO_TELL_METHODDEF    \
    {"tell", (PyCFunction)_io_BytesIO_tell, METH_NOARGS, _io_BytesIO_tell__doc__},

static PyObject *
_io_BytesIO_tell_impl(bytesio *self);

static PyObject *
_io_BytesIO_tell(PyObject *self, PyObject *Py_UNUSED(ignored))
{
    PyObject *return_value = NULL;

    Py_BEGIN_CRITICAL_SECTION(self);
    return_value = _io_BytesIO_tell_impl((bytesio *)self);
    Py_END_CRITICAL_SECTION();

    return return_value;
}

PyDoc_STRVAR(_io_BytesIO_read__doc__,
"read($self, size=-1, /)\n"
"--\n"
"\n"
"Read at most size bytes, returned as a bytes object.\n"
"\n"
"If the size argument is negative, read until EOF is reached.\n"
"Return an empty bytes object at EOF.");

#define _IO_BYTESIO_READ_METHODDEF    \
    {"read", _PyCFunction_CAST(_io_BytesIO_read), METH_FASTCALL, _io_BytesIO_read__doc__},

static PyObject *
_io_BytesIO_read_impl(bytesio *self, Py_ssize_t size);

static PyObject *
_io_BytesIO_read(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    Py_ssize_t size = -1;

    if (!_PyArg_CheckPositional("read", nargs, 0, 1)) {
        goto exit;
    }
    if (nargs < 1) {
        goto skip_optional;
    }
    if (!_Py_convert_optional_to_ssize_t(args[0], &size)) {
        goto exit;
    }
skip_optional:
    Py_BEGIN_CRITICAL_SECTION(self);
    return_value = _io_BytesIO_read_impl((bytesio *)self, size);
    Py_END_CRITICAL_SECTION();

exit:
    return return_value;
}

PyDoc_STRVAR(_io_BytesIO_read1__doc__,
"read1($self, size=-1, /)\n"
"--\n"
"\n"
"Read at most size bytes, returned as a bytes object.\n"
"\n"
"If the size argument is negative or omitted, read until EOF is reached.\n"
"Return an empty bytes object at EOF.");

#define _IO_BYTESIO_READ1_METHODDEF    \
    {"read1", _PyCFunction_CAST(_io_BytesIO_read1), METH_FASTCALL, _io_BytesIO_read1__doc__},

static PyObject *
_io_BytesIO_read1_impl(bytesio *self, Py_ssize_t size);

static PyObject *
_io_BytesIO_read1(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    Py_ssize_t size = -1;

    if (!_PyArg_CheckPositional("read1", nargs, 0, 1)) {
        goto exit;
    }
    if (nargs < 1) {
        goto skip_optional;
    }
    if (!_Py_convert_optional_to_ssize_t(args[0], &size)) {
        goto exit;
    }
skip_optional:
    Py_BEGIN_CRITICAL_SECTION(self);
    return_value = _io_BytesIO_read1_impl((bytesio *)self, size);
    Py_END_CRITICAL_SECTION();

exit:
    return return_value;
}

PyDoc_STRVAR(_io_BytesIO_readline__doc__,
"readline($self, size=-1, /)\n"
"--\n"
"\n"
"Next line from the file, as a bytes object.\n"
"\n"
"Retain newline.  A non-negative size argument limits the maximum\n"
"number of bytes to return (an incomplete line may be returned then).\n"
"Return an empty bytes object at EOF.");

#define _IO_BYTESIO_READLINE_METHODDEF    \
    {"readline", _PyCFunction_CAST(_io_BytesIO_readline), METH_FASTCALL, _io_BytesIO_readline__doc__},

static PyObject *
_io_BytesIO_readline_impl(bytesio *self, Py_ssize_t size);

static PyObject *
_io_BytesIO_readline(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    Py_ssize_t size = -1;

    if (!_PyArg_CheckPositional("readline", nargs, 0, 1)) {
        goto exit;
    }
    if (nargs < 1) {
        goto skip_optional;
    }
    if (!_Py_convert_optional_to_ssize_t(args[0], &size)) {
        goto exit;
    }
skip_optional:
    Py_BEGIN_CRITICAL_SECTION(self);
    return_value = _io_BytesIO_readline_impl((bytesio *)self, size);
    Py_END_CRITICAL_SECTION();

exit:
    return return_value;
}

PyDoc_STRVAR(_io_BytesIO_readlines__doc__,
"readlines($self, size=None, /)\n"
"--\n"
"\n"
"List of bytes objects, each a line from the file.\n"
"\n"
"Call readline() repeatedly and return a list of the lines so read.\n"
"The optional size argument, if given, is an approximate bound on the\n"
"total number of bytes in the lines returned.");

#define _IO_BYTESIO_READLINES_METHODDEF    \
    {"readlines", _PyCFunction_CAST(_io_BytesIO_readlines), METH_FASTCALL, _io_BytesIO_readlines__doc__},

static PyObject *
_io_BytesIO_readlines_impl(bytesio *self, PyObject *arg);

static PyObject *
_io_BytesIO_readlines(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    PyObject *arg = Py_None;

    if (!_PyArg_CheckPositional("readlines", nargs, 0, 1)) {
        goto exit;
    }
    if (nargs < 1) {
        goto skip_optional;
    }
    arg = args[0];
skip_optional:
    Py_BEGIN_CRITICAL_SECTION(self);
    return_value = _io_BytesIO_readlines_impl((bytesio *)self, arg);
    Py_END_CRITICAL_SECTION();

exit:
    return return_value;
}

PyDoc_STRVAR(_io_BytesIO_readinto__doc__,
"readinto($self, buffer, /)\n"
"--\n"
"\n"
"Read bytes into buffer.\n"
"\n"
"Returns number of bytes read (0 for EOF), or None if the object\n"
"is set not to block and has no data to read.");

#define _IO_BYTESIO_READINTO_METHODDEF    \
    {"readinto", (PyCFunction)_io_BytesIO_readinto, METH_O, _io_BytesIO_readinto__doc__},

static PyObject *
_io_BytesIO_readinto_impl(bytesio *self, Py_buffer *buffer);

static PyObject *
_io_BytesIO_readinto(PyObject *self, PyObject *arg)
{
    PyObject *return_value = NULL;
    Py_buffer buffer = {NULL, NULL};

    if (PyObject_GetBuffer(arg, &buffer, PyBUF_WRITABLE) < 0) {
        _PyArg_BadArgument("readinto", "argument", "read-write bytes-like object", arg);
        goto exit;
    }
    Py_BEGIN_CRITICAL_SECTION(self);
    return_value = _io_BytesIO_readinto_impl((bytesio *)self, &buffer);
    Py_END_CRITICAL_SECTION();

exit:
    /* Cleanup for buffer */
    if (buffer.obj) {
       PyBuffer_Release(&buffer);
    }

    return return_value;
}

PyDoc_STRVAR(_io_BytesIO_truncate__doc__,
"truncate($self, size=None, /)\n"
"--\n"
"\n"
"Truncate the file to at most size bytes.\n"
"\n"
"Size defaults to the current file position, as returned by tell().\n"
"The current file position is unchanged.  Returns the new size.");

#define _IO_BYTESIO_TRUNCATE_METHODDEF    \
    {"truncate", _PyCFunction_CAST(_io_BytesIO_truncate), METH_FASTCALL, _io_BytesIO_truncate__doc__},

static PyObject *
_io_BytesIO_truncate_impl(bytesio *self, PyObject *size);

static PyObject *
_io_BytesIO_truncate(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    PyObject *size = Py_None;

    if (!_PyArg_CheckPositional("truncate", nargs, 0, 1)) {
        goto exit;
    }
    if (nargs < 1) {
        goto skip_optional;
    }
    size = args[0];
skip_optional:
    Py_BEGIN_CRITICAL_SECTION(self);
    return_value = _io_BytesIO_truncate_impl((bytesio *)self, size);
    Py_END_CRITICAL_SECTION();

exit:
    return return_value;
}

PyDoc_STRVAR(_io_BytesIO_seek__doc__,
"seek($self, pos, whence=0, /)\n"
"--\n"
"\n"
"Change stream position.\n"
"\n"
"Seek to byte offset pos relative to position indicated by whence:\n"
"     0  Start of stream (the default).  pos should be >= 0;\n"
"     1  Current position - pos may be negative;\n"
"     2  End of stream - pos usually negative.\n"
"Returns the new absolute position.");

#define _IO_BYTESIO_SEEK_METHODDEF    \
    {"seek", _PyCFunction_CAST(_io_BytesIO_seek), METH_FASTCALL, _io_BytesIO_seek__doc__},

static PyObject *
_io_BytesIO_seek_impl(bytesio *self, Py_ssize_t pos, int whence);

static PyObject *
_io_BytesIO_seek(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    Py_ssize_t pos;
    int whence = 0;

    if (!_PyArg_CheckPositional("seek", nargs, 1, 2)) {
        goto exit;
    }
    {
        Py_ssize_t ival = -1;
        PyObject *iobj = _PyNumber_Index(args[0]);
        if (iobj != NULL) {
            ival = PyLong_AsSsize_t(iobj);
            Py_DECREF(iobj);
        }
        if (ival == -1 && PyErr_Occurred()) {
            goto exit;
        }
        pos = ival;
    }
    if (nargs < 2) {
        goto skip_optional;
    }
    whence = PyLong_AsInt(args[1]);
    if (whence == -1 && PyErr_Occurred()) {
        goto exit;
    }
skip_optional:
    Py_BEGIN_CRITICAL_SECTION(self);
    return_value = _io_BytesIO_seek_impl((bytesio *)self, pos, whence);
    Py_END_CRITICAL_SECTION();

exit:
    return return_value;
}

PyDoc_STRVAR(_io_BytesIO_write__doc__,
"write($self, b, /)\n"
"--\n"
"\n"
"Write bytes to file.\n"
"\n"
"Return the number of bytes written.");

#define _IO_BYTESIO_WRITE_METHODDEF    \
    {"write", (PyCFunction)_io_BytesIO_write, METH_O, _io_BytesIO_write__doc__},

static PyObject *
_io_BytesIO_write_impl(bytesio *self, PyObject *b);

static PyObject *
_io_BytesIO_write(PyObject *self, PyObject *b)
{
    PyObject *return_value = NULL;

    Py_BEGIN_CRITICAL_SECTION(self);
    return_value = _io_BytesIO_write_impl((bytesio *)self, b);
    Py_END_CRITICAL_SECTION();

    return return_value;
}

PyDoc_STRVAR(_io_BytesIO_writelines__doc__,
"writelines($self, lines, /)\n"
"--\n"
"\n"
"Write lines to the file.\n"
"\n"
"Note that newlines are not added.  lines can be any iterable object\n"
"producing bytes-like objects. This is equivalent to calling write() for\n"
"each element.");

#define _IO_BYTESIO_WRITELINES_METHODDEF    \
    {"writelines", (PyCFunction)_io_BytesIO_writelines, METH_O, _io_BytesIO_writelines__doc__},

static PyObject *
_io_BytesIO_writelines_impl(bytesio *self, PyObject *lines);

static PyObject *
_io_BytesIO_writelines(PyObject *self, PyObject *lines)
{
    PyObject *return_value = NULL;

    Py_BEGIN_CRITICAL_SECTION(self);
    return_value = _io_BytesIO_writelines_impl((bytesio *)self, lines);
    Py_END_CRITICAL_SECTION();

    return return_value;
}

PyDoc_STRVAR(_io_BytesIO_close__doc__,
"close($self, /)\n"
"--\n"
"\n"
"Disable all I/O operations.");

#define _IO_BYTESIO_CLOSE_METHODDEF    \
    {"close", (PyCFunction)_io_BytesIO_close, METH_NOARGS, _io_BytesIO_close__doc__},

static PyObject *
_io_BytesIO_close_impl(bytesio *self);

static PyObject *
_io_BytesIO_close(PyObject *self, PyObject *Py_UNUSED(ignored))
{
    PyObject *return_value = NULL;

    Py_BEGIN_CRITICAL_SECTION(self);
    return_value = _io_BytesIO_close_impl((bytesio *)self);
    Py_END_CRITICAL_SECTION();

    return return_value;
}

PyDoc_STRVAR(_io_BytesIO___init____doc__,
"BytesIO(initial_bytes=b\'\')\n"
"--\n"
"\n"
"Buffered I/O implementation using an in-memory bytes buffer.");

static int
_io_BytesIO___init___impl(bytesio *self, PyObject *initvalue);

static int
_io_BytesIO___init__(PyObject *self, PyObject *args, PyObject *kwargs)
{
    int return_value = -1;
    #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

    #define NUM_KEYWORDS 1
    static struct {
        PyGC_Head _this_is_not_used;
        PyObject_VAR_HEAD
        Py_hash_t ob_hash;
        PyObject *ob_item[NUM_KEYWORDS];
    } _kwtuple = {
        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
        .ob_hash = -1,
        .ob_item = { &_Py_ID(initial_bytes), },
    };
    #undef NUM_KEYWORDS
    #define KWTUPLE (&_kwtuple.ob_base.ob_base)

    #else  // !Py_BUILD_CORE
    #  define KWTUPLE NULL
    #endif  // !Py_BUILD_CORE

    static const char * const _keywords[] = {"initial_bytes", NULL};
    static _PyArg_Parser _parser = {
        .keywords = _keywords,
        .fname = "BytesIO",
        .kwtuple = KWTUPLE,
    };
    #undef KWTUPLE
    PyObject *argsbuf[1];
    PyObject * const *fastargs;
    Py_ssize_t nargs = PyTuple_GET_SIZE(args);
    Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
    PyObject *initvalue = NULL;

    fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser,
            /*minpos*/ 0, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
    if (!fastargs) {
        goto exit;
    }
    if (!noptargs) {
        goto skip_optional_pos;
    }
    initvalue = fastargs[0];
skip_optional_pos:
    Py_BEGIN_CRITICAL_SECTION(self);
    return_value = _io_BytesIO___init___impl((bytesio *)self, initvalue);
    Py_END_CRITICAL_SECTION();

exit:
    return return_value;
}
/*[clinic end generated code: output=daa81dfdae5ccc57 input=a9049054013a1b77]*/

Coverage Report

Created: 2026-03-23 06:45

Line	Count	Source
1		/*[clinic input]
2		preserve
3		[clinic start generated code]*/
4
5		#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
6		# include "pycore_gc.h" // PyGC_Head
7		# include "pycore_runtime.h" // _Py_ID()
8		#endif
9		#include "pycore_abstract.h" // _Py_convert_optional_to_ssize_t()
10		#include "pycore_critical_section.h"// Py_BEGIN_CRITICAL_SECTION()
11		#include "pycore_modsupport.h" // _PyArg_CheckPositional()
12
13		PyDoc_STRVAR(_io_BytesIO_readable__doc__,
14		"readable($self, /)\n"
15		"--\n"
16		"\n"
17		"Returns True if the IO object can be read.");
18
19		#define _IO_BYTESIO_READABLE_METHODDEF \
20		{"readable", (PyCFunction)_io_BytesIO_readable, METH_NOARGS, _io_BytesIO_readable__doc__},
21
22		static PyObject *
23		_io_BytesIO_readable_impl(bytesio *self);
24
25		static PyObject *
26		_io_BytesIO_readable(PyObject self, PyObject Py_UNUSED(ignored))
27	0	{
28	0	PyObject *return_value = NULL;
29
30	0	Py_BEGIN_CRITICAL_SECTION(self);
31	0	return_value = _io_BytesIO_readable_impl((bytesio *)self);
32	0	Py_END_CRITICAL_SECTION();
33
34	0	return return_value;
35	0	}
36
37		PyDoc_STRVAR(_io_BytesIO_writable__doc__,
38		"writable($self, /)\n"
39		"--\n"
40		"\n"
41		"Returns True if the IO object can be written.");
42
43		#define _IO_BYTESIO_WRITABLE_METHODDEF \
44		{"writable", (PyCFunction)_io_BytesIO_writable, METH_NOARGS, _io_BytesIO_writable__doc__},
45
46		static PyObject *
47		_io_BytesIO_writable_impl(bytesio *self);
48
49		static PyObject *
50		_io_BytesIO_writable(PyObject self, PyObject Py_UNUSED(ignored))
51	0	{
52	0	PyObject *return_value = NULL;
53
54	0	Py_BEGIN_CRITICAL_SECTION(self);
55	0	return_value = _io_BytesIO_writable_impl((bytesio *)self);
56	0	Py_END_CRITICAL_SECTION();
57
58	0	return return_value;
59	0	}
60
61		PyDoc_STRVAR(_io_BytesIO_seekable__doc__,
62		"seekable($self, /)\n"
63		"--\n"
64		"\n"
65		"Returns True if the IO object can be seeked.");
66
67		#define _IO_BYTESIO_SEEKABLE_METHODDEF \
68		{"seekable", (PyCFunction)_io_BytesIO_seekable, METH_NOARGS, _io_BytesIO_seekable__doc__},
69
70		static PyObject *
71		_io_BytesIO_seekable_impl(bytesio *self);
72
73		static PyObject *
74		_io_BytesIO_seekable(PyObject self, PyObject Py_UNUSED(ignored))
75	23.2k	{
76	23.2k	PyObject *return_value = NULL;
77
78	23.2k	Py_BEGIN_CRITICAL_SECTION(self);
79	23.2k	return_value = _io_BytesIO_seekable_impl((bytesio *)self);
80	23.2k	Py_END_CRITICAL_SECTION();
81
82	23.2k	return return_value;
83	23.2k	}
84
85		PyDoc_STRVAR(_io_BytesIO_flush__doc__,
86		"flush($self, /)\n"
87		"--\n"
88		"\n"
89		"Does nothing.");
90
91		#define _IO_BYTESIO_FLUSH_METHODDEF \
92		{"flush", (PyCFunction)_io_BytesIO_flush, METH_NOARGS, _io_BytesIO_flush__doc__},
93
94		static PyObject *
95		_io_BytesIO_flush_impl(bytesio *self);
96
97		static PyObject *
98		_io_BytesIO_flush(PyObject self, PyObject Py_UNUSED(ignored))
99	12.6k	{
100	12.6k	PyObject *return_value = NULL;
101
102	12.6k	Py_BEGIN_CRITICAL_SECTION(self);
103	12.6k	return_value = _io_BytesIO_flush_impl((bytesio *)self);
104	12.6k	Py_END_CRITICAL_SECTION();
105
106	12.6k	return return_value;
107	12.6k	}
108
109		PyDoc_STRVAR(_io_BytesIO_getbuffer__doc__,
110		"getbuffer($self, /)\n"
111		"--\n"
112		"\n"
113		"Get a read-write view over the contents of the BytesIO object.");
114
115		#define _IO_BYTESIO_GETBUFFER_METHODDEF \
116		{"getbuffer", _PyCFunction_CAST(_io_BytesIO_getbuffer), METH_METHOD\|METH_FASTCALL\|METH_KEYWORDS, _io_BytesIO_getbuffer__doc__},
117
118		static PyObject *
119		_io_BytesIO_getbuffer_impl(bytesio self, PyTypeObject cls);
120
121		static PyObject *
122		_io_BytesIO_getbuffer(PyObject self, PyTypeObject cls, PyObject const args, Py_ssize_t nargs, PyObject *kwnames)
123	0	{
124	0	PyObject *return_value = NULL;
125
126	0	if (nargs \|\| (kwnames && PyTuple_GET_SIZE(kwnames))) {
127	0	PyErr_SetString(PyExc_TypeError, "getbuffer() takes no arguments");
128	0	goto exit;
129	0	}
130	0	Py_BEGIN_CRITICAL_SECTION(self);
131	0	return_value = _io_BytesIO_getbuffer_impl((bytesio *)self, cls);
132	0	Py_END_CRITICAL_SECTION();
133
134	0	exit:
135	0	return return_value;
136	0	}
137
138		PyDoc_STRVAR(_io_BytesIO_getvalue__doc__,
139		"getvalue($self, /)\n"
140		"--\n"
141		"\n"
142		"Retrieve the entire contents of the BytesIO object.");
143
144		#define _IO_BYTESIO_GETVALUE_METHODDEF \
145		{"getvalue", (PyCFunction)_io_BytesIO_getvalue, METH_NOARGS, _io_BytesIO_getvalue__doc__},
146
147		static PyObject *
148		_io_BytesIO_getvalue_impl(bytesio *self);
149
150		static PyObject *
151		_io_BytesIO_getvalue(PyObject self, PyObject Py_UNUSED(ignored))
152	298	{
153	298	PyObject *return_value = NULL;
154
155	298	Py_BEGIN_CRITICAL_SECTION(self);
156	298	return_value = _io_BytesIO_getvalue_impl((bytesio *)self);
157	298	Py_END_CRITICAL_SECTION();
158
159	298	return return_value;
160	298	}
161
162		PyDoc_STRVAR(_io_BytesIO_isatty__doc__,
163		"isatty($self, /)\n"
164		"--\n"
165		"\n"
166		"Always returns False.\n"
167		"\n"
168		"BytesIO objects are not connected to a TTY-like device.");
169
170		#define _IO_BYTESIO_ISATTY_METHODDEF \
171		{"isatty", (PyCFunction)_io_BytesIO_isatty, METH_NOARGS, _io_BytesIO_isatty__doc__},
172
173		static PyObject *
174		_io_BytesIO_isatty_impl(bytesio *self);
175
176		static PyObject *
177		_io_BytesIO_isatty(PyObject self, PyObject Py_UNUSED(ignored))
178	0	{
179	0	PyObject *return_value = NULL;
180
181	0	Py_BEGIN_CRITICAL_SECTION(self);
182	0	return_value = _io_BytesIO_isatty_impl((bytesio *)self);
183	0	Py_END_CRITICAL_SECTION();
184
185	0	return return_value;
186	0	}
187
188		PyDoc_STRVAR(_io_BytesIO_tell__doc__,
189		"tell($self, /)\n"
190		"--\n"
191		"\n"
192		"Current file position, an integer.");
193
194		#define _IO_BYTESIO_TELL_METHODDEF \
195		{"tell", (PyCFunction)_io_BytesIO_tell, METH_NOARGS, _io_BytesIO_tell__doc__},
196
197		static PyObject *
198		_io_BytesIO_tell_impl(bytesio *self);
199
200		static PyObject *
201		_io_BytesIO_tell(PyObject self, PyObject Py_UNUSED(ignored))
202	140k	{
203	140k	PyObject *return_value = NULL;
204
205	140k	Py_BEGIN_CRITICAL_SECTION(self);
206	140k	return_value = _io_BytesIO_tell_impl((bytesio *)self);
207	140k	Py_END_CRITICAL_SECTION();
208
209	140k	return return_value;
210	140k	}
211
212		PyDoc_STRVAR(_io_BytesIO_read__doc__,
213		"read($self, size=-1, /)\n"
214		"--\n"
215		"\n"
216		"Read at most size bytes, returned as a bytes object.\n"
217		"\n"
218		"If the size argument is negative, read until EOF is reached.\n"
219		"Return an empty bytes object at EOF.");
220
221		#define _IO_BYTESIO_READ_METHODDEF \
222		{"read", _PyCFunction_CAST(_io_BytesIO_read), METH_FASTCALL, _io_BytesIO_read__doc__},
223
224		static PyObject *
225		_io_BytesIO_read_impl(bytesio *self, Py_ssize_t size);
226
227		static PyObject *
228		_io_BytesIO_read(PyObject self, PyObject const *args, Py_ssize_t nargs)
229	5.17M	{
230	5.17M	PyObject *return_value = NULL;
231	5.17M	Py_ssize_t size = -1;
232
233	5.17M	if (!_PyArg_CheckPositional("read", nargs, 0, 1)) {
234	0	goto exit;
235	0	}
236	5.17M	if (nargs < 1) {
237	0	goto skip_optional;
238	0	}
239	5.17M	if (!_Py_convert_optional_to_ssize_t(args[0], &size)) {
240	0	goto exit;
241	0	}
242	5.17M	skip_optional:
243	5.17M	Py_BEGIN_CRITICAL_SECTION(self);
244	5.17M	return_value = _io_BytesIO_read_impl((bytesio *)self, size);
245	5.17M	Py_END_CRITICAL_SECTION();
246
247	5.17M	exit:
248	5.17M	return return_value;
249	5.17M	}
250
251		PyDoc_STRVAR(_io_BytesIO_read1__doc__,
252		"read1($self, size=-1, /)\n"
253		"--\n"
254		"\n"
255		"Read at most size bytes, returned as a bytes object.\n"
256		"\n"
257		"If the size argument is negative or omitted, read until EOF is reached.\n"
258		"Return an empty bytes object at EOF.");
259
260		#define _IO_BYTESIO_READ1_METHODDEF \
261		{"read1", _PyCFunction_CAST(_io_BytesIO_read1), METH_FASTCALL, _io_BytesIO_read1__doc__},
262
263		static PyObject *
264		_io_BytesIO_read1_impl(bytesio *self, Py_ssize_t size);
265
266		static PyObject *
267		_io_BytesIO_read1(PyObject self, PyObject const *args, Py_ssize_t nargs)
268	0	{
269	0	PyObject *return_value = NULL;
270	0	Py_ssize_t size = -1;
271
272	0	if (!_PyArg_CheckPositional("read1", nargs, 0, 1)) {
273	0	goto exit;
274	0	}
275	0	if (nargs < 1) {
276	0	goto skip_optional;
277	0	}
278	0	if (!_Py_convert_optional_to_ssize_t(args[0], &size)) {
279	0	goto exit;
280	0	}
281	0	skip_optional:
282	0	Py_BEGIN_CRITICAL_SECTION(self);
283	0	return_value = _io_BytesIO_read1_impl((bytesio *)self, size);
284	0	Py_END_CRITICAL_SECTION();
285
286	0	exit:
287	0	return return_value;
288	0	}
289
290		PyDoc_STRVAR(_io_BytesIO_readline__doc__,
291		"readline($self, size=-1, /)\n"
292		"--\n"
293		"\n"
294		"Next line from the file, as a bytes object.\n"
295		"\n"
296		"Retain newline. A non-negative size argument limits the maximum\n"
297		"number of bytes to return (an incomplete line may be returned then).\n"
298		"Return an empty bytes object at EOF.");
299
300		#define _IO_BYTESIO_READLINE_METHODDEF \
301		{"readline", _PyCFunction_CAST(_io_BytesIO_readline), METH_FASTCALL, _io_BytesIO_readline__doc__},
302
303		static PyObject *
304		_io_BytesIO_readline_impl(bytesio *self, Py_ssize_t size);
305
306		static PyObject *
307		_io_BytesIO_readline(PyObject self, PyObject const *args, Py_ssize_t nargs)
308	129k	{
309	129k	PyObject *return_value = NULL;
310	129k	Py_ssize_t size = -1;
311
312	129k	if (!_PyArg_CheckPositional("readline", nargs, 0, 1)) {
313	0	goto exit;
314	0	}
315	129k	if (nargs < 1) {
316	272	goto skip_optional;
317	272	}
318	129k	if (!_Py_convert_optional_to_ssize_t(args[0], &size)) {
319	0	goto exit;
320	0	}
321	129k	skip_optional:
322	129k	Py_BEGIN_CRITICAL_SECTION(self);
323	129k	return_value = _io_BytesIO_readline_impl((bytesio *)self, size);
324	129k	Py_END_CRITICAL_SECTION();
325
326	129k	exit:
327	129k	return return_value;
328	129k	}
329
330		PyDoc_STRVAR(_io_BytesIO_readlines__doc__,
331		"readlines($self, size=None, /)\n"
332		"--\n"
333		"\n"
334		"List of bytes objects, each a line from the file.\n"
335		"\n"
336		"Call readline() repeatedly and return a list of the lines so read.\n"
337		"The optional size argument, if given, is an approximate bound on the\n"
338		"total number of bytes in the lines returned.");
339
340		#define _IO_BYTESIO_READLINES_METHODDEF \
341		{"readlines", _PyCFunction_CAST(_io_BytesIO_readlines), METH_FASTCALL, _io_BytesIO_readlines__doc__},
342
343		static PyObject *
344		_io_BytesIO_readlines_impl(bytesio self, PyObject arg);
345
346		static PyObject *
347		_io_BytesIO_readlines(PyObject self, PyObject const *args, Py_ssize_t nargs)
348	0	{
349	0	PyObject *return_value = NULL;
350	0	PyObject *arg = Py_None;
351
352	0	if (!_PyArg_CheckPositional("readlines", nargs, 0, 1)) {
353	0	goto exit;
354	0	}
355	0	if (nargs < 1) {
356	0	goto skip_optional;
357	0	}
358	0	arg = args[0];
359	0	skip_optional:
360	0	Py_BEGIN_CRITICAL_SECTION(self);
361	0	return_value = _io_BytesIO_readlines_impl((bytesio *)self, arg);
362	0	Py_END_CRITICAL_SECTION();
363
364	0	exit:
365	0	return return_value;
366	0	}
367
368		PyDoc_STRVAR(_io_BytesIO_readinto__doc__,
369		"readinto($self, buffer, /)\n"
370		"--\n"
371		"\n"
372		"Read bytes into buffer.\n"
373		"\n"
374		"Returns number of bytes read (0 for EOF), or None if the object\n"
375		"is set not to block and has no data to read.");
376
377		#define _IO_BYTESIO_READINTO_METHODDEF \
378		{"readinto", (PyCFunction)_io_BytesIO_readinto, METH_O, _io_BytesIO_readinto__doc__},
379
380		static PyObject *
381		_io_BytesIO_readinto_impl(bytesio self, Py_buffer buffer);
382
383		static PyObject *
384		_io_BytesIO_readinto(PyObject self, PyObject arg)
385	0	{
386	0	PyObject *return_value = NULL;
387	0	Py_buffer buffer = {NULL, NULL};
388
389	0	if (PyObject_GetBuffer(arg, &buffer, PyBUF_WRITABLE) < 0) {
390	0	_PyArg_BadArgument("readinto", "argument", "read-write bytes-like object", arg);
391	0	goto exit;
392	0	}
393	0	Py_BEGIN_CRITICAL_SECTION(self);
394	0	return_value = _io_BytesIO_readinto_impl((bytesio *)self, &buffer);
395	0	Py_END_CRITICAL_SECTION();
396
397	0	exit:
398		/* Cleanup for buffer */
399	0	if (buffer.obj) {
400	0	PyBuffer_Release(&buffer);
401	0	}
402
403	0	return return_value;
404	0	}
405
406		PyDoc_STRVAR(_io_BytesIO_truncate__doc__,
407		"truncate($self, size=None, /)\n"
408		"--\n"
409		"\n"
410		"Truncate the file to at most size bytes.\n"
411		"\n"
412		"Size defaults to the current file position, as returned by tell().\n"
413		"The current file position is unchanged. Returns the new size.");
414
415		#define _IO_BYTESIO_TRUNCATE_METHODDEF \
416		{"truncate", _PyCFunction_CAST(_io_BytesIO_truncate), METH_FASTCALL, _io_BytesIO_truncate__doc__},
417
418		static PyObject *
419		_io_BytesIO_truncate_impl(bytesio self, PyObject size);
420
421		static PyObject *
422		_io_BytesIO_truncate(PyObject self, PyObject const *args, Py_ssize_t nargs)
423	0	{
424	0	PyObject *return_value = NULL;
425	0	PyObject *size = Py_None;
426
427	0	if (!_PyArg_CheckPositional("truncate", nargs, 0, 1)) {
428	0	goto exit;
429	0	}
430	0	if (nargs < 1) {
431	0	goto skip_optional;
432	0	}
433	0	size = args[0];
434	0	skip_optional:
435	0	Py_BEGIN_CRITICAL_SECTION(self);
436	0	return_value = _io_BytesIO_truncate_impl((bytesio *)self, size);
437	0	Py_END_CRITICAL_SECTION();
438
439	0	exit:
440	0	return return_value;
441	0	}
442
443		PyDoc_STRVAR(_io_BytesIO_seek__doc__,
444		"seek($self, pos, whence=0, /)\n"
445		"--\n"
446		"\n"
447		"Change stream position.\n"
448		"\n"
449		"Seek to byte offset pos relative to position indicated by whence:\n"
450		" 0 Start of stream (the default). pos should be >= 0;\n"
451		" 1 Current position - pos may be negative;\n"
452		" 2 End of stream - pos usually negative.\n"
453		"Returns the new absolute position.");
454
455		#define _IO_BYTESIO_SEEK_METHODDEF \
456		{"seek", _PyCFunction_CAST(_io_BytesIO_seek), METH_FASTCALL, _io_BytesIO_seek__doc__},
457
458		static PyObject *
459		_io_BytesIO_seek_impl(bytesio *self, Py_ssize_t pos, int whence);
460
461		static PyObject *
462		_io_BytesIO_seek(PyObject self, PyObject const *args, Py_ssize_t nargs)
463	189k	{
464	189k	PyObject *return_value = NULL;
465	189k	Py_ssize_t pos;
466	189k	int whence = 0;
467
468	189k	if (!_PyArg_CheckPositional("seek", nargs, 1, 2)) {
469	0	goto exit;
470	0	}
471	189k	{
472	189k	Py_ssize_t ival = -1;
473	189k	PyObject *iobj = _PyNumber_Index(args[0]);
474	189k	if (iobj != NULL) {
475	189k	ival = PyLong_AsSsize_t(iobj);
476	189k	Py_DECREF(iobj);
477	189k	}
478	189k	if (ival == -1 && PyErr_Occurred()) {
479	121	goto exit;
480	121	}
481	189k	pos = ival;
482	189k	}
483	189k	if (nargs < 2) {
484	153k	goto skip_optional;
485	153k	}
486	35.7k	whence = PyLong_AsInt(args[1]);
487	35.7k	if (whence == -1 && PyErr_Occurred()) {
488	0	goto exit;
489	0	}
490	189k	skip_optional:
491	189k	Py_BEGIN_CRITICAL_SECTION(self);
492	189k	return_value = _io_BytesIO_seek_impl((bytesio *)self, pos, whence);
493	189k	Py_END_CRITICAL_SECTION();
494
495	189k	exit:
496	189k	return return_value;
497	189k	}
498
499		PyDoc_STRVAR(_io_BytesIO_write__doc__,
500		"write($self, b, /)\n"
501		"--\n"
502		"\n"
503		"Write bytes to file.\n"
504		"\n"
505		"Return the number of bytes written.");
506
507		#define _IO_BYTESIO_WRITE_METHODDEF \
508		{"write", (PyCFunction)_io_BytesIO_write, METH_O, _io_BytesIO_write__doc__},
509
510		static PyObject *
511		_io_BytesIO_write_impl(bytesio self, PyObject b);
512
513		static PyObject *
514		_io_BytesIO_write(PyObject self, PyObject b)
515	91.8k	{
516	91.8k	PyObject *return_value = NULL;
517
518	91.8k	Py_BEGIN_CRITICAL_SECTION(self);
519	91.8k	return_value = _io_BytesIO_write_impl((bytesio *)self, b);
520	91.8k	Py_END_CRITICAL_SECTION();
521
522	91.8k	return return_value;
523	91.8k	}
524
525		PyDoc_STRVAR(_io_BytesIO_writelines__doc__,
526		"writelines($self, lines, /)\n"
527		"--\n"
528		"\n"
529		"Write lines to the file.\n"
530		"\n"
531		"Note that newlines are not added. lines can be any iterable object\n"
532		"producing bytes-like objects. This is equivalent to calling write() for\n"
533		"each element.");
534
535		#define _IO_BYTESIO_WRITELINES_METHODDEF \
536		{"writelines", (PyCFunction)_io_BytesIO_writelines, METH_O, _io_BytesIO_writelines__doc__},
537
538		static PyObject *
539		_io_BytesIO_writelines_impl(bytesio self, PyObject lines);
540
541		static PyObject *
542		_io_BytesIO_writelines(PyObject self, PyObject lines)
543	0	{
544	0	PyObject *return_value = NULL;
545
546	0	Py_BEGIN_CRITICAL_SECTION(self);
547	0	return_value = _io_BytesIO_writelines_impl((bytesio *)self, lines);
548	0	Py_END_CRITICAL_SECTION();
549
550	0	return return_value;
551	0	}
552
553		PyDoc_STRVAR(_io_BytesIO_close__doc__,
554		"close($self, /)\n"
555		"--\n"
556		"\n"
557		"Disable all I/O operations.");
558
559		#define _IO_BYTESIO_CLOSE_METHODDEF \
560		{"close", (PyCFunction)_io_BytesIO_close, METH_NOARGS, _io_BytesIO_close__doc__},
561
562		static PyObject *
563		_io_BytesIO_close_impl(bytesio *self);
564
565		static PyObject *
566		_io_BytesIO_close(PyObject self, PyObject Py_UNUSED(ignored))
567	9.68k	{
568	9.68k	PyObject *return_value = NULL;
569
570	9.68k	Py_BEGIN_CRITICAL_SECTION(self);
571	9.68k	return_value = _io_BytesIO_close_impl((bytesio *)self);
572	9.68k	Py_END_CRITICAL_SECTION();
573
574	9.68k	return return_value;
575	9.68k	}
576
577		PyDoc_STRVAR(_io_BytesIO___init____doc__,
578		"BytesIO(initial_bytes=b\'\')\n"
579		"--\n"
580		"\n"
581		"Buffered I/O implementation using an in-memory bytes buffer.");
582
583		static int
584		_io_BytesIO___init___impl(bytesio self, PyObject initvalue);
585
586		static int
587		_io_BytesIO___init__(PyObject self, PyObject args, PyObject *kwargs)
588	50.2k	{
589	50.2k	int return_value = -1;
590	50.2k	#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
591
592	50.2k	#define NUM_KEYWORDS 1
593	50.2k	static struct {
594	50.2k	PyGC_Head _this_is_not_used;
595	50.2k	PyObject_VAR_HEAD
596	50.2k	Py_hash_t ob_hash;
597	50.2k	PyObject *ob_item[NUM_KEYWORDS];
598	50.2k	} _kwtuple = {
599	50.2k	.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
600	50.2k	.ob_hash = -1,
601	50.2k	.ob_item = { &_Py_ID(initial_bytes), },
602	50.2k	};
603	50.2k	#undef NUM_KEYWORDS
604	50.2k	#define KWTUPLE (&_kwtuple.ob_base.ob_base)
605
606		#else // !Py_BUILD_CORE
607		# define KWTUPLE NULL
608		#endif // !Py_BUILD_CORE
609
610	50.2k	static const char * const _keywords[] = {"initial_bytes", NULL};
611	50.2k	static _PyArg_Parser _parser = {
612	50.2k	.keywords = _keywords,
613	50.2k	.fname = "BytesIO",
614	50.2k	.kwtuple = KWTUPLE,
615	50.2k	};
616	50.2k	#undef KWTUPLE
617	50.2k	PyObject *argsbuf[1];
618	50.2k	PyObject * const *fastargs;
619	50.2k	Py_ssize_t nargs = PyTuple_GET_SIZE(args);
620	50.2k	Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
621	50.2k	PyObject *initvalue = NULL;
622
623	50.2k	fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser,
624	50.2k	/minpos/ 0, /maxpos/ 1, /minkw/ 0, /varpos/ 0, argsbuf);
625	50.2k	if (!fastargs) {
626	0	goto exit;
627	0	}
628	50.2k	if (!noptargs) {
629	7.31k	goto skip_optional_pos;
630	7.31k	}
631	42.9k	initvalue = fastargs[0];
632	50.2k	skip_optional_pos:
633	50.2k	Py_BEGIN_CRITICAL_SECTION(self);
634	50.2k	return_value = _io_BytesIO___init___impl((bytesio *)self, initvalue);
635	50.2k	Py_END_CRITICAL_SECTION();
636
637	50.2k	exit:
638	50.2k	return return_value;
639	50.2k	}
640		/[clinic end generated code: output=daa81dfdae5ccc57 input=a9049054013a1b77]/