/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-01-17 06:16

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	27.3k	{
76	27.3k	PyObject *return_value = NULL;
77
78	27.3k	Py_BEGIN_CRITICAL_SECTION(self);
79	27.3k	return_value = _io_BytesIO_seekable_impl((bytesio *)self);
80	27.3k	Py_END_CRITICAL_SECTION();
81
82	27.3k	return return_value;
83	27.3k	}
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	9.33k	{
100	9.33k	PyObject *return_value = NULL;
101
102	9.33k	Py_BEGIN_CRITICAL_SECTION(self);
103	9.33k	return_value = _io_BytesIO_flush_impl((bytesio *)self);
104	9.33k	Py_END_CRITICAL_SECTION();
105
106	9.33k	return return_value;
107	9.33k	}
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	272	{
153	272	PyObject *return_value = NULL;
154
155	272	Py_BEGIN_CRITICAL_SECTION(self);
156	272	return_value = _io_BytesIO_getvalue_impl((bytesio *)self);
157	272	Py_END_CRITICAL_SECTION();
158
159	272	return return_value;
160	272	}
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	139k	{
203	139k	PyObject *return_value = NULL;
204
205	139k	Py_BEGIN_CRITICAL_SECTION(self);
206	139k	return_value = _io_BytesIO_tell_impl((bytesio *)self);
207	139k	Py_END_CRITICAL_SECTION();
208
209	139k	return return_value;
210	139k	}
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	4.38M	{
230	4.38M	PyObject *return_value = NULL;
231	4.38M	Py_ssize_t size = -1;
232
233	4.38M	if (!_PyArg_CheckPositional("read", nargs, 0, 1)) {
234	0	goto exit;
235	0	}
236	4.38M	if (nargs < 1) {
237	0	goto skip_optional;
238	0	}
239	4.38M	if (!_Py_convert_optional_to_ssize_t(args[0], &size)) {
240	0	goto exit;
241	0	}
242	4.38M	skip_optional:
243	4.38M	Py_BEGIN_CRITICAL_SECTION(self);
244	4.38M	return_value = _io_BytesIO_read_impl((bytesio *)self, size);
245	4.38M	Py_END_CRITICAL_SECTION();
246
247	4.38M	exit:
248	4.38M	return return_value;
249	4.38M	}
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	138k	{
309	138k	PyObject *return_value = NULL;
310	138k	Py_ssize_t size = -1;
311
312	138k	if (!_PyArg_CheckPositional("readline", nargs, 0, 1)) {
313	0	goto exit;
314	0	}
315	138k	if (nargs < 1) {
316	0	goto skip_optional;
317	0	}
318	138k	if (!_Py_convert_optional_to_ssize_t(args[0], &size)) {
319	0	goto exit;
320	0	}
321	138k	skip_optional:
322	138k	Py_BEGIN_CRITICAL_SECTION(self);
323	138k	return_value = _io_BytesIO_readline_impl((bytesio *)self, size);
324	138k	Py_END_CRITICAL_SECTION();
325
326	138k	exit:
327	138k	return return_value;
328	138k	}
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	174k	{
464	174k	PyObject *return_value = NULL;
465	174k	Py_ssize_t pos;
466	174k	int whence = 0;
467
468	174k	if (!_PyArg_CheckPositional("seek", nargs, 1, 2)) {
469	0	goto exit;
470	0	}
471	174k	{
472	174k	Py_ssize_t ival = -1;
473	174k	PyObject *iobj = _PyNumber_Index(args[0]);
474	174k	if (iobj != NULL) {
475	174k	ival = PyLong_AsSsize_t(iobj);
476	174k	Py_DECREF(iobj);
477	174k	}
478	174k	if (ival == -1 && PyErr_Occurred()) {
479	119	goto exit;
480	119	}
481	174k	pos = ival;
482	174k	}
483	174k	if (nargs < 2) {
484	139k	goto skip_optional;
485	139k	}
486	34.1k	whence = PyLong_AsInt(args[1]);
487	34.1k	if (whence == -1 && PyErr_Occurred()) {
488	0	goto exit;
489	0	}
490	174k	skip_optional:
491	174k	Py_BEGIN_CRITICAL_SECTION(self);
492	174k	return_value = _io_BytesIO_seek_impl((bytesio *)self, pos, whence);
493	174k	Py_END_CRITICAL_SECTION();
494
495	174k	exit:
496	174k	return return_value;
497	174k	}
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	2.44k	{
516	2.44k	PyObject *return_value = NULL;
517
518	2.44k	Py_BEGIN_CRITICAL_SECTION(self);
519	2.44k	return_value = _io_BytesIO_write_impl((bytesio *)self, b);
520	2.44k	Py_END_CRITICAL_SECTION();
521
522	2.44k	return return_value;
523	2.44k	}
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.63k	{
568	9.63k	PyObject *return_value = NULL;
569
570	9.63k	Py_BEGIN_CRITICAL_SECTION(self);
571	9.63k	return_value = _io_BytesIO_close_impl((bytesio *)self);
572	9.63k	Py_END_CRITICAL_SECTION();
573
574	9.63k	return return_value;
575	9.63k	}
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	39.6k	{
589	39.6k	int return_value = -1;
590	39.6k	#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
591
592	39.6k	#define NUM_KEYWORDS 1
593	39.6k	static struct {
594	39.6k	PyGC_Head _this_is_not_used;
595	39.6k	PyObject_VAR_HEAD
596	39.6k	Py_hash_t ob_hash;
597	39.6k	PyObject *ob_item[NUM_KEYWORDS];
598	39.6k	} _kwtuple = {
599	39.6k	.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
600	39.6k	.ob_hash = -1,
601	39.6k	.ob_item = { &_Py_ID(initial_bytes), },
602	39.6k	};
603	39.6k	#undef NUM_KEYWORDS
604	39.6k	#define KWTUPLE (&_kwtuple.ob_base.ob_base)
605
606		#else // !Py_BUILD_CORE
607		# define KWTUPLE NULL
608		#endif // !Py_BUILD_CORE
609
610	39.6k	static const char * const _keywords[] = {"initial_bytes", NULL};
611	39.6k	static _PyArg_Parser _parser = {
612	39.6k	.keywords = _keywords,
613	39.6k	.fname = "BytesIO",
614	39.6k	.kwtuple = KWTUPLE,
615	39.6k	};
616	39.6k	#undef KWTUPLE
617	39.6k	PyObject *argsbuf[1];
618	39.6k	PyObject * const *fastargs;
619	39.6k	Py_ssize_t nargs = PyTuple_GET_SIZE(args);
620	39.6k	Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
621	39.6k	PyObject *initvalue = NULL;
622
623	39.6k	fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser,
624	39.6k	/minpos/ 0, /maxpos/ 1, /minkw/ 0, /varpos/ 0, argsbuf);
625	39.6k	if (!fastargs) {
626	0	goto exit;
627	0	}
628	39.6k	if (!noptargs) {
629	376	goto skip_optional_pos;
630	376	}
631	39.2k	initvalue = fastargs[0];
632	39.6k	skip_optional_pos:
633	39.6k	Py_BEGIN_CRITICAL_SECTION(self);
634	39.6k	return_value = _io_BytesIO___init___impl((bytesio *)self, initvalue);
635	39.6k	Py_END_CRITICAL_SECTION();
636
637	39.6k	exit:
638	39.6k	return return_value;
639	39.6k	}
640		/[clinic end generated code: output=daa81dfdae5ccc57 input=a9049054013a1b77]/