1 /*[clinic input]
2 preserve
3 [clinic start generated code]*/
4
5 PyDoc_STRVAR(_io_IncrementalNewlineDecoder___init____doc__,
6 "IncrementalNewlineDecoder(decoder, translate, errors=\'strict\')\n"
7 "--\n"
8 "\n"
9 "Codec used when reading a file in universal newlines mode.\n"
10 "\n"
11 "It wraps another incremental decoder, translating \\r\\n and \\r into \\n.\n"
12 "It also records the types of newlines encountered. When used with\n"
13 "translate=False, it ensures that the newline sequence is returned in\n"
14 "one piece. When used with decoder=None, it expects unicode strings as\n"
15 "decode input and translates newlines without first invoking an external\n"
16 "decoder.");
17
18 static int
19 _io_IncrementalNewlineDecoder___init___impl(nldecoder_object *self,
20 PyObject *decoder, int translate,
21 PyObject *errors);
22
23 static int
_io_IncrementalNewlineDecoder___init__(PyObject * self,PyObject * args,PyObject * kwargs)24 _io_IncrementalNewlineDecoder___init__(PyObject *self, PyObject *args, PyObject *kwargs)
25 {
26 int return_value = -1;
27 static const char * const _keywords[] = {"decoder", "translate", "errors", NULL};
28 static _PyArg_Parser _parser = {"Oi|O:IncrementalNewlineDecoder", _keywords, 0};
29 PyObject *decoder;
30 int translate;
31 PyObject *errors = NULL;
32
33 if (!_PyArg_ParseTupleAndKeywordsFast(args, kwargs, &_parser,
34 &decoder, &translate, &errors)) {
35 goto exit;
36 }
37 return_value = _io_IncrementalNewlineDecoder___init___impl((nldecoder_object *)self, decoder, translate, errors);
38
39 exit:
40 return return_value;
41 }
42
43 PyDoc_STRVAR(_io_IncrementalNewlineDecoder_decode__doc__,
44 "decode($self, /, input, final=False)\n"
45 "--\n"
46 "\n");
47
48 #define _IO_INCREMENTALNEWLINEDECODER_DECODE_METHODDEF \
49 {"decode", (PyCFunction)_io_IncrementalNewlineDecoder_decode, METH_FASTCALL|METH_KEYWORDS, _io_IncrementalNewlineDecoder_decode__doc__},
50
51 static PyObject *
52 _io_IncrementalNewlineDecoder_decode_impl(nldecoder_object *self,
53 PyObject *input, int final);
54
55 static PyObject *
_io_IncrementalNewlineDecoder_decode(nldecoder_object * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)56 _io_IncrementalNewlineDecoder_decode(nldecoder_object *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
57 {
58 PyObject *return_value = NULL;
59 static const char * const _keywords[] = {"input", "final", NULL};
60 static _PyArg_Parser _parser = {"O|i:decode", _keywords, 0};
61 PyObject *input;
62 int final = 0;
63
64 if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
65 &input, &final)) {
66 goto exit;
67 }
68 return_value = _io_IncrementalNewlineDecoder_decode_impl(self, input, final);
69
70 exit:
71 return return_value;
72 }
73
74 PyDoc_STRVAR(_io_IncrementalNewlineDecoder_getstate__doc__,
75 "getstate($self, /)\n"
76 "--\n"
77 "\n");
78
79 #define _IO_INCREMENTALNEWLINEDECODER_GETSTATE_METHODDEF \
80 {"getstate", (PyCFunction)_io_IncrementalNewlineDecoder_getstate, METH_NOARGS, _io_IncrementalNewlineDecoder_getstate__doc__},
81
82 static PyObject *
83 _io_IncrementalNewlineDecoder_getstate_impl(nldecoder_object *self);
84
85 static PyObject *
_io_IncrementalNewlineDecoder_getstate(nldecoder_object * self,PyObject * Py_UNUSED (ignored))86 _io_IncrementalNewlineDecoder_getstate(nldecoder_object *self, PyObject *Py_UNUSED(ignored))
87 {
88 return _io_IncrementalNewlineDecoder_getstate_impl(self);
89 }
90
91 PyDoc_STRVAR(_io_IncrementalNewlineDecoder_setstate__doc__,
92 "setstate($self, state, /)\n"
93 "--\n"
94 "\n");
95
96 #define _IO_INCREMENTALNEWLINEDECODER_SETSTATE_METHODDEF \
97 {"setstate", (PyCFunction)_io_IncrementalNewlineDecoder_setstate, METH_O, _io_IncrementalNewlineDecoder_setstate__doc__},
98
99 PyDoc_STRVAR(_io_IncrementalNewlineDecoder_reset__doc__,
100 "reset($self, /)\n"
101 "--\n"
102 "\n");
103
104 #define _IO_INCREMENTALNEWLINEDECODER_RESET_METHODDEF \
105 {"reset", (PyCFunction)_io_IncrementalNewlineDecoder_reset, METH_NOARGS, _io_IncrementalNewlineDecoder_reset__doc__},
106
107 static PyObject *
108 _io_IncrementalNewlineDecoder_reset_impl(nldecoder_object *self);
109
110 static PyObject *
_io_IncrementalNewlineDecoder_reset(nldecoder_object * self,PyObject * Py_UNUSED (ignored))111 _io_IncrementalNewlineDecoder_reset(nldecoder_object *self, PyObject *Py_UNUSED(ignored))
112 {
113 return _io_IncrementalNewlineDecoder_reset_impl(self);
114 }
115
116 PyDoc_STRVAR(_io_TextIOWrapper___init____doc__,
117 "TextIOWrapper(buffer, encoding=None, errors=None, newline=None,\n"
118 " line_buffering=False, write_through=False)\n"
119 "--\n"
120 "\n"
121 "Character and line based layer over a BufferedIOBase object, buffer.\n"
122 "\n"
123 "encoding gives the name of the encoding that the stream will be\n"
124 "decoded or encoded with. It defaults to locale.getpreferredencoding(False).\n"
125 "\n"
126 "errors determines the strictness of encoding and decoding (see\n"
127 "help(codecs.Codec) or the documentation for codecs.register) and\n"
128 "defaults to \"strict\".\n"
129 "\n"
130 "newline controls how line endings are handled. It can be None, \'\',\n"
131 "\'\\n\', \'\\r\', and \'\\r\\n\'. It works as follows:\n"
132 "\n"
133 "* On input, if newline is None, universal newlines mode is\n"
134 " enabled. Lines in the input can end in \'\\n\', \'\\r\', or \'\\r\\n\', and\n"
135 " these are translated into \'\\n\' before being returned to the\n"
136 " caller. If it is \'\', universal newline mode is enabled, but line\n"
137 " endings are returned to the caller untranslated. If it has any of\n"
138 " the other legal values, input lines are only terminated by the given\n"
139 " string, and the line ending is returned to the caller untranslated.\n"
140 "\n"
141 "* On output, if newline is None, any \'\\n\' characters written are\n"
142 " translated to the system default line separator, os.linesep. If\n"
143 " newline is \'\' or \'\\n\', no translation takes place. If newline is any\n"
144 " of the other legal values, any \'\\n\' characters written are translated\n"
145 " to the given string.\n"
146 "\n"
147 "If line_buffering is True, a call to flush is implied when a call to\n"
148 "write contains a newline character.");
149
150 static int
151 _io_TextIOWrapper___init___impl(textio *self, PyObject *buffer,
152 const char *encoding, PyObject *errors,
153 const char *newline, int line_buffering,
154 int write_through);
155
156 static int
_io_TextIOWrapper___init__(PyObject * self,PyObject * args,PyObject * kwargs)157 _io_TextIOWrapper___init__(PyObject *self, PyObject *args, PyObject *kwargs)
158 {
159 int return_value = -1;
160 static const char * const _keywords[] = {"buffer", "encoding", "errors", "newline", "line_buffering", "write_through", NULL};
161 static _PyArg_Parser _parser = {"O|zOzii:TextIOWrapper", _keywords, 0};
162 PyObject *buffer;
163 const char *encoding = NULL;
164 PyObject *errors = Py_None;
165 const char *newline = NULL;
166 int line_buffering = 0;
167 int write_through = 0;
168
169 if (!_PyArg_ParseTupleAndKeywordsFast(args, kwargs, &_parser,
170 &buffer, &encoding, &errors, &newline, &line_buffering, &write_through)) {
171 goto exit;
172 }
173 return_value = _io_TextIOWrapper___init___impl((textio *)self, buffer, encoding, errors, newline, line_buffering, write_through);
174
175 exit:
176 return return_value;
177 }
178
179 PyDoc_STRVAR(_io_TextIOWrapper_reconfigure__doc__,
180 "reconfigure($self, /, *, encoding=None, errors=None, newline=None,\n"
181 " line_buffering=None, write_through=None)\n"
182 "--\n"
183 "\n"
184 "Reconfigure the text stream with new parameters.\n"
185 "\n"
186 "This also does an implicit stream flush.");
187
188 #define _IO_TEXTIOWRAPPER_RECONFIGURE_METHODDEF \
189 {"reconfigure", (PyCFunction)_io_TextIOWrapper_reconfigure, METH_FASTCALL|METH_KEYWORDS, _io_TextIOWrapper_reconfigure__doc__},
190
191 static PyObject *
192 _io_TextIOWrapper_reconfigure_impl(textio *self, PyObject *encoding,
193 PyObject *errors, PyObject *newline_obj,
194 PyObject *line_buffering_obj,
195 PyObject *write_through_obj);
196
197 static PyObject *
_io_TextIOWrapper_reconfigure(textio * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)198 _io_TextIOWrapper_reconfigure(textio *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
199 {
200 PyObject *return_value = NULL;
201 static const char * const _keywords[] = {"encoding", "errors", "newline", "line_buffering", "write_through", NULL};
202 static _PyArg_Parser _parser = {"|$OOOOO:reconfigure", _keywords, 0};
203 PyObject *encoding = Py_None;
204 PyObject *errors = Py_None;
205 PyObject *newline_obj = NULL;
206 PyObject *line_buffering_obj = Py_None;
207 PyObject *write_through_obj = Py_None;
208
209 if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
210 &encoding, &errors, &newline_obj, &line_buffering_obj, &write_through_obj)) {
211 goto exit;
212 }
213 return_value = _io_TextIOWrapper_reconfigure_impl(self, encoding, errors, newline_obj, line_buffering_obj, write_through_obj);
214
215 exit:
216 return return_value;
217 }
218
219 PyDoc_STRVAR(_io_TextIOWrapper_detach__doc__,
220 "detach($self, /)\n"
221 "--\n"
222 "\n");
223
224 #define _IO_TEXTIOWRAPPER_DETACH_METHODDEF \
225 {"detach", (PyCFunction)_io_TextIOWrapper_detach, METH_NOARGS, _io_TextIOWrapper_detach__doc__},
226
227 static PyObject *
228 _io_TextIOWrapper_detach_impl(textio *self);
229
230 static PyObject *
_io_TextIOWrapper_detach(textio * self,PyObject * Py_UNUSED (ignored))231 _io_TextIOWrapper_detach(textio *self, PyObject *Py_UNUSED(ignored))
232 {
233 return _io_TextIOWrapper_detach_impl(self);
234 }
235
236 PyDoc_STRVAR(_io_TextIOWrapper_write__doc__,
237 "write($self, text, /)\n"
238 "--\n"
239 "\n");
240
241 #define _IO_TEXTIOWRAPPER_WRITE_METHODDEF \
242 {"write", (PyCFunction)_io_TextIOWrapper_write, METH_O, _io_TextIOWrapper_write__doc__},
243
244 static PyObject *
245 _io_TextIOWrapper_write_impl(textio *self, PyObject *text);
246
247 static PyObject *
_io_TextIOWrapper_write(textio * self,PyObject * arg)248 _io_TextIOWrapper_write(textio *self, PyObject *arg)
249 {
250 PyObject *return_value = NULL;
251 PyObject *text;
252
253 if (!PyArg_Parse(arg, "U:write", &text)) {
254 goto exit;
255 }
256 return_value = _io_TextIOWrapper_write_impl(self, text);
257
258 exit:
259 return return_value;
260 }
261
262 PyDoc_STRVAR(_io_TextIOWrapper_read__doc__,
263 "read($self, size=-1, /)\n"
264 "--\n"
265 "\n");
266
267 #define _IO_TEXTIOWRAPPER_READ_METHODDEF \
268 {"read", (PyCFunction)_io_TextIOWrapper_read, METH_FASTCALL, _io_TextIOWrapper_read__doc__},
269
270 static PyObject *
271 _io_TextIOWrapper_read_impl(textio *self, Py_ssize_t n);
272
273 static PyObject *
_io_TextIOWrapper_read(textio * self,PyObject * const * args,Py_ssize_t nargs)274 _io_TextIOWrapper_read(textio *self, PyObject *const *args, Py_ssize_t nargs)
275 {
276 PyObject *return_value = NULL;
277 Py_ssize_t n = -1;
278
279 if (!_PyArg_ParseStack(args, nargs, "|O&:read",
280 _Py_convert_optional_to_ssize_t, &n)) {
281 goto exit;
282 }
283 return_value = _io_TextIOWrapper_read_impl(self, n);
284
285 exit:
286 return return_value;
287 }
288
289 PyDoc_STRVAR(_io_TextIOWrapper_readline__doc__,
290 "readline($self, size=-1, /)\n"
291 "--\n"
292 "\n");
293
294 #define _IO_TEXTIOWRAPPER_READLINE_METHODDEF \
295 {"readline", (PyCFunction)_io_TextIOWrapper_readline, METH_FASTCALL, _io_TextIOWrapper_readline__doc__},
296
297 static PyObject *
298 _io_TextIOWrapper_readline_impl(textio *self, Py_ssize_t size);
299
300 static PyObject *
_io_TextIOWrapper_readline(textio * self,PyObject * const * args,Py_ssize_t nargs)301 _io_TextIOWrapper_readline(textio *self, PyObject *const *args, Py_ssize_t nargs)
302 {
303 PyObject *return_value = NULL;
304 Py_ssize_t size = -1;
305
306 if (!_PyArg_ParseStack(args, nargs, "|n:readline",
307 &size)) {
308 goto exit;
309 }
310 return_value = _io_TextIOWrapper_readline_impl(self, size);
311
312 exit:
313 return return_value;
314 }
315
316 PyDoc_STRVAR(_io_TextIOWrapper_seek__doc__,
317 "seek($self, cookie, whence=0, /)\n"
318 "--\n"
319 "\n");
320
321 #define _IO_TEXTIOWRAPPER_SEEK_METHODDEF \
322 {"seek", (PyCFunction)_io_TextIOWrapper_seek, METH_FASTCALL, _io_TextIOWrapper_seek__doc__},
323
324 static PyObject *
325 _io_TextIOWrapper_seek_impl(textio *self, PyObject *cookieObj, int whence);
326
327 static PyObject *
_io_TextIOWrapper_seek(textio * self,PyObject * const * args,Py_ssize_t nargs)328 _io_TextIOWrapper_seek(textio *self, PyObject *const *args, Py_ssize_t nargs)
329 {
330 PyObject *return_value = NULL;
331 PyObject *cookieObj;
332 int whence = 0;
333
334 if (!_PyArg_ParseStack(args, nargs, "O|i:seek",
335 &cookieObj, &whence)) {
336 goto exit;
337 }
338 return_value = _io_TextIOWrapper_seek_impl(self, cookieObj, whence);
339
340 exit:
341 return return_value;
342 }
343
344 PyDoc_STRVAR(_io_TextIOWrapper_tell__doc__,
345 "tell($self, /)\n"
346 "--\n"
347 "\n");
348
349 #define _IO_TEXTIOWRAPPER_TELL_METHODDEF \
350 {"tell", (PyCFunction)_io_TextIOWrapper_tell, METH_NOARGS, _io_TextIOWrapper_tell__doc__},
351
352 static PyObject *
353 _io_TextIOWrapper_tell_impl(textio *self);
354
355 static PyObject *
_io_TextIOWrapper_tell(textio * self,PyObject * Py_UNUSED (ignored))356 _io_TextIOWrapper_tell(textio *self, PyObject *Py_UNUSED(ignored))
357 {
358 return _io_TextIOWrapper_tell_impl(self);
359 }
360
361 PyDoc_STRVAR(_io_TextIOWrapper_truncate__doc__,
362 "truncate($self, pos=None, /)\n"
363 "--\n"
364 "\n");
365
366 #define _IO_TEXTIOWRAPPER_TRUNCATE_METHODDEF \
367 {"truncate", (PyCFunction)_io_TextIOWrapper_truncate, METH_FASTCALL, _io_TextIOWrapper_truncate__doc__},
368
369 static PyObject *
370 _io_TextIOWrapper_truncate_impl(textio *self, PyObject *pos);
371
372 static PyObject *
_io_TextIOWrapper_truncate(textio * self,PyObject * const * args,Py_ssize_t nargs)373 _io_TextIOWrapper_truncate(textio *self, PyObject *const *args, Py_ssize_t nargs)
374 {
375 PyObject *return_value = NULL;
376 PyObject *pos = Py_None;
377
378 if (!_PyArg_UnpackStack(args, nargs, "truncate",
379 0, 1,
380 &pos)) {
381 goto exit;
382 }
383 return_value = _io_TextIOWrapper_truncate_impl(self, pos);
384
385 exit:
386 return return_value;
387 }
388
389 PyDoc_STRVAR(_io_TextIOWrapper_fileno__doc__,
390 "fileno($self, /)\n"
391 "--\n"
392 "\n");
393
394 #define _IO_TEXTIOWRAPPER_FILENO_METHODDEF \
395 {"fileno", (PyCFunction)_io_TextIOWrapper_fileno, METH_NOARGS, _io_TextIOWrapper_fileno__doc__},
396
397 static PyObject *
398 _io_TextIOWrapper_fileno_impl(textio *self);
399
400 static PyObject *
_io_TextIOWrapper_fileno(textio * self,PyObject * Py_UNUSED (ignored))401 _io_TextIOWrapper_fileno(textio *self, PyObject *Py_UNUSED(ignored))
402 {
403 return _io_TextIOWrapper_fileno_impl(self);
404 }
405
406 PyDoc_STRVAR(_io_TextIOWrapper_seekable__doc__,
407 "seekable($self, /)\n"
408 "--\n"
409 "\n");
410
411 #define _IO_TEXTIOWRAPPER_SEEKABLE_METHODDEF \
412 {"seekable", (PyCFunction)_io_TextIOWrapper_seekable, METH_NOARGS, _io_TextIOWrapper_seekable__doc__},
413
414 static PyObject *
415 _io_TextIOWrapper_seekable_impl(textio *self);
416
417 static PyObject *
_io_TextIOWrapper_seekable(textio * self,PyObject * Py_UNUSED (ignored))418 _io_TextIOWrapper_seekable(textio *self, PyObject *Py_UNUSED(ignored))
419 {
420 return _io_TextIOWrapper_seekable_impl(self);
421 }
422
423 PyDoc_STRVAR(_io_TextIOWrapper_readable__doc__,
424 "readable($self, /)\n"
425 "--\n"
426 "\n");
427
428 #define _IO_TEXTIOWRAPPER_READABLE_METHODDEF \
429 {"readable", (PyCFunction)_io_TextIOWrapper_readable, METH_NOARGS, _io_TextIOWrapper_readable__doc__},
430
431 static PyObject *
432 _io_TextIOWrapper_readable_impl(textio *self);
433
434 static PyObject *
_io_TextIOWrapper_readable(textio * self,PyObject * Py_UNUSED (ignored))435 _io_TextIOWrapper_readable(textio *self, PyObject *Py_UNUSED(ignored))
436 {
437 return _io_TextIOWrapper_readable_impl(self);
438 }
439
440 PyDoc_STRVAR(_io_TextIOWrapper_writable__doc__,
441 "writable($self, /)\n"
442 "--\n"
443 "\n");
444
445 #define _IO_TEXTIOWRAPPER_WRITABLE_METHODDEF \
446 {"writable", (PyCFunction)_io_TextIOWrapper_writable, METH_NOARGS, _io_TextIOWrapper_writable__doc__},
447
448 static PyObject *
449 _io_TextIOWrapper_writable_impl(textio *self);
450
451 static PyObject *
_io_TextIOWrapper_writable(textio * self,PyObject * Py_UNUSED (ignored))452 _io_TextIOWrapper_writable(textio *self, PyObject *Py_UNUSED(ignored))
453 {
454 return _io_TextIOWrapper_writable_impl(self);
455 }
456
457 PyDoc_STRVAR(_io_TextIOWrapper_isatty__doc__,
458 "isatty($self, /)\n"
459 "--\n"
460 "\n");
461
462 #define _IO_TEXTIOWRAPPER_ISATTY_METHODDEF \
463 {"isatty", (PyCFunction)_io_TextIOWrapper_isatty, METH_NOARGS, _io_TextIOWrapper_isatty__doc__},
464
465 static PyObject *
466 _io_TextIOWrapper_isatty_impl(textio *self);
467
468 static PyObject *
_io_TextIOWrapper_isatty(textio * self,PyObject * Py_UNUSED (ignored))469 _io_TextIOWrapper_isatty(textio *self, PyObject *Py_UNUSED(ignored))
470 {
471 return _io_TextIOWrapper_isatty_impl(self);
472 }
473
474 PyDoc_STRVAR(_io_TextIOWrapper_flush__doc__,
475 "flush($self, /)\n"
476 "--\n"
477 "\n");
478
479 #define _IO_TEXTIOWRAPPER_FLUSH_METHODDEF \
480 {"flush", (PyCFunction)_io_TextIOWrapper_flush, METH_NOARGS, _io_TextIOWrapper_flush__doc__},
481
482 static PyObject *
483 _io_TextIOWrapper_flush_impl(textio *self);
484
485 static PyObject *
_io_TextIOWrapper_flush(textio * self,PyObject * Py_UNUSED (ignored))486 _io_TextIOWrapper_flush(textio *self, PyObject *Py_UNUSED(ignored))
487 {
488 return _io_TextIOWrapper_flush_impl(self);
489 }
490
491 PyDoc_STRVAR(_io_TextIOWrapper_close__doc__,
492 "close($self, /)\n"
493 "--\n"
494 "\n");
495
496 #define _IO_TEXTIOWRAPPER_CLOSE_METHODDEF \
497 {"close", (PyCFunction)_io_TextIOWrapper_close, METH_NOARGS, _io_TextIOWrapper_close__doc__},
498
499 static PyObject *
500 _io_TextIOWrapper_close_impl(textio *self);
501
502 static PyObject *
_io_TextIOWrapper_close(textio * self,PyObject * Py_UNUSED (ignored))503 _io_TextIOWrapper_close(textio *self, PyObject *Py_UNUSED(ignored))
504 {
505 return _io_TextIOWrapper_close_impl(self);
506 }
507 /*[clinic end generated code: output=b5be870b0039d577 input=a9049054013a1b77]*/
508