FazBrowse GitHub Viewer
|
Trending
|
URL:
|
Home
Tools:
[Download Repo ZIP]
[View Raw Code]
[Original HTTPS Page]
Source.Python/addons/source-python/Python3/_pyio.py at concommand_fix · CookStar/Source.Python · GitHub
CookStar
Source.Python
Repository navigation
Code
Issues
Pull requests
Actions
Projects
Security and quality
Insights
Expand file tree
Breadcrumbs
Source.Python
/
addons
/
source-python
/
Python3
/
_pyio.py
Copy path
More file actions
More file actions
Latest commit
History
History
History
2531 lines (2113 loc) · 86 KB
Breadcrumbs
Source.Python
/
addons
/
source-python
/
Python3
/
_pyio.py
Copy path
File metadata and controls
2531 lines (2113 loc) · 86 KB
Raw
Copy raw file
Download raw file
Open symbols panel
Edit and raw actions
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
"""
Python implementation of the io module.
"""
import
os
import
abc
import
codecs
import
errno
import
stat
import
sys
# Import _thread instead of threading to reduce startup cost
try
:
from
_thread
import
allocate_lock
as
Lock
except
ImportError
:
from
_dummy_thread
import
allocate_lock
as
Lock
if
sys
.
platform
in
{
'win32'
,
'cygwin'
}:
from
msvcrt
import
setmode
as
_setmode
else
:
_setmode
=
None
import
io
from
io
import
(
__all__
,
SEEK_SET
,
SEEK_CUR
,
SEEK_END
)
valid_seek_flags
=
{
0
,
1
,
2
}
# Hardwired values
if
hasattr
(
os
,
'SEEK_HOLE'
) :
valid_seek_flags
.
add
(
os
.
SEEK_HOLE
)
valid_seek_flags
.
add
(
os
.
SEEK_DATA
)
# open() uses st_blksize whenever we can
DEFAULT_BUFFER_SIZE
=
8
*
1024
# bytes
# NOTE: Base classes defined here are registered with the "official" ABCs
# defined in io.py. We don't use real inheritance though, because we don't want
# to inherit the C implementations.
# Rebind for compatibility
BlockingIOError
=
BlockingIOError
def
open
(
file
,
mode
=
"r"
,
buffering
=
-
1
,
encoding
=
None
,
errors
=
None
,
newline
=
None
,
closefd
=
True
,
opener
=
None
):
r"""Open file and return a stream. Raise OSError upon failure.
file is either a text or byte string giving the name (and the path
if the file isn't in the current working directory) of the file to
be opened or an integer file descriptor of the file to be
wrapped. (If a file descriptor is given, it is closed when the
returned I/O object is closed, unless closefd is set to False.)
mode is an optional string that specifies the mode in which the file is
opened. It defaults to 'r' which means open for reading in text mode. Other
common values are 'w' for writing (truncating the file if it already
exists), 'x' for exclusive creation of a new file, and 'a' for appending
(which on some Unix systems, means that all writes append to the end of the
file regardless of the current seek position). In text mode, if encoding is
not specified the encoding used is platform dependent. (For reading and
writing raw bytes use binary mode and leave encoding unspecified.) The
available modes are:
========= ===============================================================
Character Meaning
--------- ---------------------------------------------------------------
'r' open for reading (default)
'w' open for writing, truncating the file first
'x' create a new file and open it for writing
'a' open for writing, appending to the end of the file if it exists
'b' binary mode
't' text mode (default)
'+' open a disk file for updating (reading and writing)
'U' universal newline mode (deprecated)
========= ===============================================================
The default mode is 'rt' (open for reading text). For binary random
access, the mode 'w+b' opens and truncates the file to 0 bytes, while
'r+b' opens the file without truncation. The 'x' mode implies 'w' and
raises an `FileExistsError` if the file already exists.
Python distinguishes between files opened in binary and text modes,
even when the underlying operating system doesn't. Files opened in
binary mode (appending 'b' to the mode argument) return contents as
bytes objects without any decoding. In text mode (the default, or when
't' is appended to the mode argument), the contents of the file are
returned as strings, the bytes having been first decoded using a
platform-dependent encoding or using the specified encoding if given.
'U' mode is deprecated and will raise an exception in future versions
of Python. It has no effect in Python 3. Use newline to control
universal newlines mode.
buffering is an optional integer used to set the buffering policy.
Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
line buffering (only usable in text mode), and an integer > 1 to indicate
the size of a fixed-size chunk buffer. When no buffering argument is
given, the default buffering policy works as follows:
* Binary files are buffered in fixed-size chunks; the size of the buffer
is chosen using a heuristic trying to determine the underlying device's
"block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.
On many systems, the buffer will typically be 4096 or 8192 bytes long.
* "Interactive" text files (files for which isatty() returns True)
use line buffering. Other text files use the policy described above
for binary files.
encoding is the str name of the encoding used to decode or encode the
file. This should only be used in text mode. The default encoding is
platform dependent, but any encoding supported by Python can be
passed. See the codecs module for the list of supported encodings.
errors is an optional string that specifies how encoding errors are to
be handled---this argument should not be used in binary mode. Pass
'strict' to raise a ValueError exception if there is an encoding error
(the default of None has the same effect), or pass 'ignore' to ignore
errors. (Note that ignoring encoding errors can lead to data loss.)
See the documentation for codecs.register for a list of the permitted
encoding error strings.
newline is a string controlling how universal newlines works (it only
applies to text mode). It can be None, '', '\n', '\r', and '\r\n'. It works
as follows:
* On input, if newline is None, universal newlines mode is
enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
these are translated into '\n' before being returned to the
caller. If it is '', universal newline mode is enabled, but line
endings are returned to the caller untranslated. If it has any of
the other legal values, input lines are only terminated by the given
string, and the line ending is returned to the caller untranslated.
* On output, if newline is None, any '\n' characters written are
translated to the system default line separator, os.linesep. If
newline is '', no translation takes place. If newline is any of the
other legal values, any '\n' characters written are translated to
the given string.
closedfd is a bool. If closefd is False, the underlying file descriptor will
be kept open when the file is closed. This does not work when a file name is
given and must be True in that case.
The newly created file is non-inheritable.
A custom opener can be used by passing a callable as *opener*. The
underlying file descriptor for the file object is then obtained by calling
*opener* with (*file*, *flags*). *opener* must return an open file
descriptor (passing os.open as *opener* results in functionality similar to
passing None).
open() returns a file object whose type depends on the mode, and
through which the standard file operations such as reading and writing
are performed. When open() is used to open a file in a text mode ('w',
'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open
a file in a binary mode, the returned class varies: in read binary
mode, it returns a BufferedReader; in write binary and append binary
modes, it returns a BufferedWriter, and in read/write mode, it returns
a BufferedRandom.
It is also possible to use a string or bytearray as a file for both
reading and writing. For strings StringIO can be used like a file
opened in a text mode, and for bytes a BytesIO can be used like a file
opened in a binary mode.
"""
if
not
isinstance
(
file
,
int
):
file
=
os
.
fspath
(
file
)
if
not
isinstance
(
file
, (
str
,
bytes
,
int
)):
raise
TypeError
(
"invalid file: %r"
%
file
)
if
not
isinstance
(
mode
,
str
):
raise
TypeError
(
"invalid mode: %r"
%
mode
)
if
not
isinstance
(
buffering
,
int
):
raise
TypeError
(
"invalid buffering: %r"
%
buffering
)
if
encoding
is
not
None
and
not
isinstance
(
encoding
,
str
):
raise
TypeError
(
"invalid encoding: %r"
%
encoding
)
if
errors
is
not
None
and
not
isinstance
(
errors
,
str
):
raise
TypeError
(
"invalid errors: %r"
%
errors
)
modes
=
set
(
mode
)
if
modes
-
set
(
"axrwb+tU"
)
or
len
(
mode
)
>
len
(
modes
):
raise
ValueError
(
"invalid mode: %r"
%
mode
)
creating
=
"x"
in
modes
reading
=
"r"
in
modes
writing
=
"w"
in
modes
appending
=
"a"
in
modes
updating
=
"+"
in
modes
text
=
"t"
in
modes
binary
=
"b"
in
modes
if
"U"
in
modes
:
if
creating
or
writing
or
appending
or
updating
:
raise
ValueError
(
"mode U cannot be combined with 'x', 'w', 'a', or '+'"
)
import
warnings
warnings
.
warn
(
"'U' mode is deprecated"
,
DeprecationWarning
,
2
)
reading
=
True
if
text
and
binary
:
raise
ValueError
(
"can't have text and binary mode at once"
)
if
creating
+
reading
+
writing
+
appending
>
1
:
raise
ValueError
(
"can't have read/write/append mode at once"
)
if
not
(
creating
or
reading
or
writing
or
appending
):
raise
ValueError
(
"must have exactly one of read/write/append mode"
)
if
binary
and
encoding
is
not
None
:
raise
ValueError
(
"binary mode doesn't take an encoding argument"
)
if
binary
and
errors
is
not
None
:
raise
ValueError
(
"binary mode doesn't take an errors argument"
)
if
binary
and
newline
is
not
None
:
raise
ValueError
(
"binary mode doesn't take a newline argument"
)
raw
=
FileIO
(
file
,
(
creating
and
"x"
or
""
)
+
(
reading
and
"r"
or
""
)
+
(
writing
and
"w"
or
""
)
+
(
appending
and
"a"
or
""
)
+
(
updating
and
"+"
or
""
),
closefd
,
opener
=
opener
)
result
=
raw
try
:
line_buffering
=
False
if
buffering
==
1
or
buffering
<
0
and
raw
.
isatty
():
buffering
=
-
1
line_buffering
=
True
if
buffering
<
0
:
buffering
=
DEFAULT_BUFFER_SIZE
try
:
bs
=
os
.
fstat
(
raw
.
fileno
()).
st_blksize
except
(
OSError
,
AttributeError
):
pass
else
:
if
bs
>
1
:
buffering
=
bs
if
buffering
<
0
:
raise
ValueError
(
"invalid buffering size"
)
if
buffering
==
0
:
if
binary
:
return
result
raise
ValueError
(
"can't have unbuffered text I/O"
)
if
updating
:
buffer
=
BufferedRandom
(
raw
,
buffering
)
elif
creating
or
writing
or
appending
:
buffer
=
BufferedWriter
(
raw
,
buffering
)
elif
reading
:
buffer
=
BufferedReader
(
raw
,
buffering
)
else
:
raise
ValueError
(
"unknown mode: %r"
%
mode
)
result
=
buffer
if
binary
:
return
result
text
=
TextIOWrapper
(
buffer
,
encoding
,
errors
,
newline
,
line_buffering
)
result
=
text
text
.
mode
=
mode
return
result
except
:
result
.
close
()
raise
class
DocDescriptor
:
"""Helper for builtins.open.__doc__
"""
def
__get__
(
self
,
obj
,
typ
):
return
(
"open(file, mode='r', buffering=-1, encoding=None, "
"errors=None, newline=None, closefd=True)
\n
\n
"
+
open
.
__doc__
)
class
OpenWrapper
:
"""Wrapper for builtins.open
Trick so that open won't become a bound method when stored
as a class variable (as dbm.dumb does).
See initstdio() in Python/pylifecycle.c.
"""
__doc__
=
DocDescriptor
()
def
__new__
(
cls
,
*
args
,
**
kwargs
):
return
open
(
*
args
,
**
kwargs
)
# In normal operation, both `UnsupportedOperation`s should be bound to the
# same object.
try
:
UnsupportedOperation
=
io
.
UnsupportedOperation
except
AttributeError
:
class
UnsupportedOperation
(
OSError
,
ValueError
):
pass
class
IOBase
(
metaclass
=
abc
.
ABCMeta
):
"""The abstract base class for all I/O classes, acting on streams of
bytes. There is no public constructor.
This class provides dummy implementations for many methods that
derived classes can override selectively; the default implementations
represent a file that cannot be read, written or seeked.
Even though IOBase does not declare read, readinto, or write because
their signatures will vary, implementations and clients should
consider those methods part of the interface. Also, implementations
may raise UnsupportedOperation when operations they do not support are
called.
The basic type used for binary data read from or written to a file is
bytes. Other bytes-like objects are accepted as method arguments too. In
some cases (such as readinto), a writable object is required. Text I/O
classes work with str data.
Note that calling any method (even inquiries) on a closed stream is
undefined. Implementations may raise OSError in this case.
IOBase (and its subclasses) support the iterator protocol, meaning
that an IOBase object can be iterated over yielding the lines in a
stream.
IOBase also supports the :keyword:`with` statement. In this example,
fp is closed after the suite of the with statement is complete:
with open('spam.txt', 'r') as fp:
fp.write('Spam and eggs!')
"""
### Internal ###
def
_unsupported
(
self
,
name
):
"""Internal: raise an OSError exception for unsupported operations."""
raise
UnsupportedOperation
(
"%s.%s() not supported"
%
(
self
.
__class__
.
__name__
,
name
))
### Positioning ###
def
seek
(
self
,
pos
,
whence
=
0
):
"""Change stream position.
Change the stream position to byte offset pos. Argument pos is
interpreted relative to the position indicated by whence. Values
for whence are ints:
* 0 -- start of stream (the default); offset should be zero or positive
* 1 -- current stream position; offset may be negative
* 2 -- end of stream; offset is usually negative
Some operating systems / file systems could provide additional values.
Return an int indicating the new absolute position.
"""
self
.
_unsupported
(
"seek"
)
def
tell
(
self
):
"""Return an int indicating the current stream position."""
return
self
.
seek
(
0
,
1
)
def
truncate
(
self
,
pos
=
None
):
"""Truncate file to size bytes.
Size defaults to the current IO position as reported by tell(). Return
the new size.
"""
self
.
_unsupported
(
"truncate"
)
### Flush and close ###
def
flush
(
self
):
"""Flush write buffers, if applicable.
This is not implemented for read-only and non-blocking streams.
"""
self
.
_checkClosed
()
# XXX Should this return the number of bytes written???
__closed
=
False
def
close
(
self
):
"""Flush and close the IO object.
This method has no effect if the file is already closed.
"""
if
not
self
.
__closed
:
try
:
self
.
flush
()
finally
:
self
.
__closed
=
True
def
__del__
(
self
):
"""Destructor. Calls close()."""
# The try/except block is in case this is called at program
# exit time, when it's possible that globals have already been
# deleted, and then the close() call might fail. Since
# there's nothing we can do about such failures and they annoy
# the end users, we suppress the traceback.
try
:
self
.
close
()
except
:
pass
### Inquiries ###
def
seekable
(
self
):
"""Return a bool indicating whether object supports random access.
If False, seek(), tell() and truncate() will raise OSError.
This method may need to do a test seek().
"""
return
False
def
_checkSeekable
(
self
,
msg
=
None
):
"""Internal: raise UnsupportedOperation if file is not seekable
"""
if
not
self
.
seekable
():
raise
UnsupportedOperation
(
"File or stream is not seekable."
if
msg
is
None
else
msg
)
def
readable
(
self
):
"""Return a bool indicating whether object was opened for reading.
If False, read() will raise OSError.
"""
return
False
def
_checkReadable
(
self
,
msg
=
None
):
"""Internal: raise UnsupportedOperation if file is not readable
"""
if
not
self
.
readable
():
raise
UnsupportedOperation
(
"File or stream is not readable."
if
msg
is
None
else
msg
)
def
writable
(
self
):
"""Return a bool indicating whether object was opened for writing.
If False, write() and truncate() will raise OSError.
"""
return
False
def
_checkWritable
(
self
,
msg
=
None
):
"""Internal: raise UnsupportedOperation if file is not writable
"""
if
not
self
.
writable
():
raise
UnsupportedOperation
(
"File or stream is not writable."
if
msg
is
None
else
msg
)
@
property
def
closed
(
self
):
"""closed: bool. True iff the file has been closed.
For backwards compatibility, this is a property, not a predicate.
"""
return
self
.
__closed
def
_checkClosed
(
self
,
msg
=
None
):
"""Internal: raise a ValueError if file is closed
"""
if
self
.
closed
:
raise
ValueError
(
"I/O operation on closed file."
if
msg
is
None
else
msg
)
### Context manager ###
def
__enter__
(
self
):
# That's a forward reference
"""Context management protocol. Returns self (an instance of IOBase)."""
self
.
_checkClosed
()
return
self
def
__exit__
(
self
,
*
args
):
"""Context management protocol. Calls close()"""
self
.
close
()
### Lower-level APIs ###
# XXX Should these be present even if unimplemented?
def
fileno
(
self
):
"""Returns underlying file descriptor (an int) if one exists.
An OSError is raised if the IO object does not use a file descriptor.
"""
self
.
_unsupported
(
"fileno"
)
def
isatty
(
self
):
"""Return a bool indicating whether this is an 'interactive' stream.
Return False if it can't be determined.
"""
self
.
_checkClosed
()
return
False
### Readline[s] and writelines ###
def
readline
(
self
,
size
=
-
1
):
r"""Read and return a line of bytes from the stream.
If size is specified, at most size bytes will be read.
Size should be an int.
The line terminator is always b'\n' for binary files; for text
files, the newlines argument to open can be used to select the line
terminator(s) recognized.
"""
# For backwards compatibility, a (slowish) readline().
if
hasattr
(
self
,
"peek"
):
def
nreadahead
():
readahead
=
self
.
peek
(
1
)
if
not
readahead
:
return
1
n
=
(
readahead
.
find
(
b"
\n
"
)
+
1
)
or
len
(
readahead
)
if
size
>=
0
:
n
=
min
(
n
,
size
)
return
n
else
:
def
nreadahead
():
return
1
if
size
is
None
:
size
=
-
1
elif
not
isinstance
(
size
,
int
):
raise
TypeError
(
"size must be an integer"
)
res
=
bytearray
()
while
size
<
0
or
len
(
res
)
<
size
:
b
=
self
.
read
(
nreadahead
())
if
not
b
:
break
res
+=
b
if
res
.
endswith
(
b"
\n
"
):
break
return
bytes
(
res
)
def
__iter__
(
self
):
self
.
_checkClosed
()
return
self
def
__next__
(
self
):
line
=
self
.
readline
()
if
not
line
:
raise
StopIteration
return
line
def
readlines
(
self
,
hint
=
None
):
"""Return a list of lines from the stream.
hint can be specified to control the number of lines read: no more
lines will be read if the total size (in bytes/characters) of all
lines so far exceeds hint.
"""
if
hint
is
None
or
hint
<=
0
:
return
list
(
self
)
n
=
0
lines
=
[]
for
line
in
self
:
lines
.
append
(
line
)
n
+=
len
(
line
)
if
n
>=
hint
:
break
return
lines
def
writelines
(
self
,
lines
):
self
.
_checkClosed
()
for
line
in
lines
:
self
.
write
(
line
)
io
.
IOBase
.
register
(
IOBase
)
class
RawIOBase
(
IOBase
):
"""Base class for raw binary I/O."""
# The read() method is implemented by calling readinto(); derived
# classes that want to support read() only need to implement
# readinto() as a primitive operation. In general, readinto() can be
# more efficient than read().
# (It would be tempting to also provide an implementation of
# readinto() in terms of read(), in case the latter is a more suitable
# primitive operation, but that would lead to nasty recursion in case
# a subclass doesn't implement either.)
def
read
(
self
,
size
=
-
1
):
"""Read and return up to size bytes, where size is an int.
Returns an empty bytes object on EOF, or None if the object is
set not to block and has no data to read.
"""
if
size
is
None
:
size
=
-
1
if
size
<
0
:
return
self
.
readall
()
b
=
bytearray
(
size
.
__index__
())
n
=
self
.
readinto
(
b
)
if
n
is
None
:
return
None
del
b
[
n
:]
return
bytes
(
b
)
def
readall
(
self
):
"""Read until EOF, using multiple read() call."""
res
=
bytearray
()
while
True
:
data
=
self
.
read
(
DEFAULT_BUFFER_SIZE
)
if
not
data
:
break
res
+=
data
if
res
:
return
bytes
(
res
)
else
:
# b'' or None
return
data
def
readinto
(
self
,
b
):
"""Read bytes into a pre-allocated bytes-like object b.
Returns an int representing the number of bytes read (0 for EOF), or
None if the object is set not to block and has no data to read.
"""
self
.
_unsupported
(
"readinto"
)
def
write
(
self
,
b
):
"""Write the given buffer to the IO stream.
Returns the number of bytes written, which may be less than the
length of b in bytes.
"""
self
.
_unsupported
(
"write"
)
io
.
RawIOBase
.
register
(
RawIOBase
)
from
_io
import
FileIO
RawIOBase
.
register
(
FileIO
)
class
BufferedIOBase
(
IOBase
):
"""Base class for buffered IO objects.
The main difference with RawIOBase is that the read() method
supports omitting the size argument, and does not have a default
implementation that defers to readinto().
In addition, read(), readinto() and write() may raise
BlockingIOError if the underlying raw stream is in non-blocking
mode and not ready; unlike their raw counterparts, they will never
return None.
A typical implementation should not inherit from a RawIOBase
implementation, but wrap one.
"""
def
read
(
self
,
size
=
None
):
"""Read and return up to size bytes, where size is an int.
If the argument is omitted, None, or negative, reads and
returns all data until EOF.
If the argument is positive, and the underlying raw stream is
not 'interactive', multiple raw reads may be issued to satisfy
the byte count (unless EOF is reached first). But for
interactive raw streams (XXX and for pipes?), at most one raw
read will be issued, and a short result does not imply that
EOF is imminent.
Returns an empty bytes array on EOF.
Raises BlockingIOError if the underlying raw stream has no
data at the moment.
"""
self
.
_unsupported
(
"read"
)
def
read1
(
self
,
size
=
None
):
"""Read up to size bytes with at most one read() system call,
where size is an int.
"""
self
.
_unsupported
(
"read1"
)
def
readinto
(
self
,
b
):
"""Read bytes into a pre-allocated bytes-like object b.
Like read(), this may issue multiple reads to the underlying raw
stream, unless the latter is 'interactive'.
Returns an int representing the number of bytes read (0 for EOF).
Raises BlockingIOError if the underlying raw stream has no
data at the moment.
"""
return
self
.
_readinto
(
b
,
read1
=
False
)
def
readinto1
(
self
,
b
):
"""Read bytes into buffer *b*, using at most one system call
Returns an int representing the number of bytes read (0 for EOF).
Raises BlockingIOError if the underlying raw stream has no
data at the moment.
"""
return
self
.
_readinto
(
b
,
read1
=
True
)
def
_readinto
(
self
,
b
,
read1
):
if
not
isinstance
(
b
,
memoryview
):
b
=
memoryview
(
b
)
b
=
b
.
cast
(
'B'
)
if
read1
:
data
=
self
.
read1
(
len
(
b
))
else
:
data
=
self
.
read
(
len
(
b
))
n
=
len
(
data
)
b
[:
n
]
=
data
return
n
def
write
(
self
,
b
):
"""Write the given bytes buffer to the IO stream.
Return the number of bytes written, which is always the length of b
in bytes.
Raises BlockingIOError if the buffer is full and the
underlying raw stream cannot accept more data at the moment.
"""
self
.
_unsupported
(
"write"
)
def
detach
(
self
):
"""
Separate the underlying raw stream from the buffer and return it.
After the raw stream has been detached, the buffer is in an unusable
state.
"""
self
.
_unsupported
(
"detach"
)
io
.
BufferedIOBase
.
register
(
BufferedIOBase
)
class
_BufferedIOMixin
(
BufferedIOBase
):
"""A mixin implementation of BufferedIOBase with an underlying raw stream.
This passes most requests on to the underlying raw stream. It
does *not* provide implementations of read(), readinto() or
write().
"""
def
__init__
(
self
,
raw
):
self
.
_raw
=
raw
### Positioning ###
def
seek
(
self
,
pos
,
whence
=
0
):
new_position
=
self
.
raw
.
seek
(
pos
,
whence
)
if
new_position
<
0
:
raise
OSError
(
"seek() returned an invalid position"
)
return
new_position
def
tell
(
self
):
pos
=
self
.
raw
.
tell
()
if
pos
<
0
:
raise
OSError
(
"tell() returned an invalid position"
)
return
pos
def
truncate
(
self
,
pos
=
None
):
# Flush the stream. We're mixing buffered I/O with lower-level I/O,
# and a flush may be necessary to synch both views of the current
# file state.
self
.
flush
()
if
pos
is
None
:
pos
=
self
.
tell
()
# XXX: Should seek() be used, instead of passing the position
# XXX directly to truncate?
return
self
.
raw
.
truncate
(
pos
)
### Flush and close ###
def
flush
(
self
):
if
self
.
closed
:
raise
ValueError
(
"flush of closed file"
)
self
.
raw
.
flush
()
def
close
(
self
):
if
self
.
raw
is
not
None
and
not
self
.
closed
:
try
:
# may raise BlockingIOError or BrokenPipeError etc
self
.
flush
()
finally
:
self
.
raw
.
close
()
def
detach
(
self
):
if
self
.
raw
is
None
:
raise
ValueError
(
"raw stream already detached"
)
self
.
flush
()
raw
=
self
.
_raw
self
.
_raw
=
None
return
raw
### Inquiries ###
def
seekable
(
self
):
return
self
.
raw
.
seekable
()
@
property
def
raw
(
self
):
return
self
.
_raw
@
property
def
closed
(
self
):
return
self
.
raw
.
closed
@
property
def
name
(
self
):
return
self
.
raw
.
name
@
property
def
mode
(
self
):
return
self
.
raw
.
mode
def
__getstate__
(
self
):
raise
TypeError
(
"can not serialize a '{0}' object"
.
format
(
self
.
__class__
.
__name__
))
def
__repr__
(
self
):
modname
=
self
.
__class__
.
__module__
clsname
=
self
.
__class__
.
__qualname__
try
:
name
=
self
.
name
except
Exception
:
return
"<{}.{}>"
.
format
(
modname
,
clsname
)
else
:
return
"<{}.{} name={!r}>"
.
format
(
modname
,
clsname
,
name
)
### Lower-level APIs ###
def
fileno
(
self
):
return
self
.
raw
.
fileno
()
def
isatty
(
self
):
return
self
.
raw
.
isatty
()
class
BytesIO
(
BufferedIOBase
):
"""Buffered I/O implementation using an in-memory bytes buffer."""
def
__init__
(
self
,
initial_bytes
=
None
):
buf
=
bytearray
()
if
initial_bytes
is
not
None
:
buf
+=
initial_bytes
self
.
_buffer
=
buf
self
.
_pos
=
0
def
__getstate__
(
self
):
if
self
.
closed
:
raise
ValueError
(
"__getstate__ on closed file"
)
return
self
.
__dict__
.
copy
()
def
getvalue
(
self
):
"""Return the bytes value (contents) of the buffer
"""
if
self
.
closed
:
raise
ValueError
(
"getvalue on closed file"
)
return
bytes
(
self
.
_buffer
)
def
getbuffer
(
self
):
"""Return a readable and writable view of the buffer.
"""
if
self
.
closed
:
raise
ValueError
(
"getbuffer on closed file"
)
return
memoryview
(
self
.
_buffer
)
def
close
(
self
):
self
.
_buffer
.
clear
()
super
().
close
()
def
read
(
self
,
size
=
None
):
if
self
.
closed
:
raise
ValueError
(
"read from closed file"
)
if
size
is
None
:
size
=
-
1
if
size
<
0
:
size
=
len
(
self
.
_buffer
)
if
len
(
self
.
_buffer
)
<=
self
.
_pos
:
return
b""
newpos
=
min
(
len
(
self
.
_buffer
),
self
.
_pos
+
size
)
b
=
self
.
_buffer
[
self
.
_pos
:
newpos
]
self
.
_pos
=
newpos
return
bytes
(
b
)
def
read1
(
self
,
size
):
"""This is the same as read.
"""
return
self
.
read
(
size
)
def
write
(
self
,
b
):
if
self
.
closed
:
raise
ValueError
(
"write to closed file"
)
if
isinstance
(
b
,
str
):
raise
TypeError
(
"can't write str to binary stream"
)
with
memoryview
(
b
)
as
view
:
n
=
view
.
nbytes
# Size of any bytes-like object
if
n
==
0
:
return
0
pos
=
self
.
_pos
if
pos
>
len
(
self
.
_buffer
):
# Inserts null bytes between the current end of the file
# and the new write position.
padding
=
b'
\x00
'
*
(
pos
-
len
(
self
.
_buffer
))
self
.
_buffer
+=
padding
self
.
_buffer
[
pos
:
pos
+
n
]
=
b
self
.
_pos
+=
n
return
n
def
seek
(
self
,
pos
,
whence
=
0
):
if
self
.
closed
:
raise
ValueError
(
"seek on closed file"
)
try
:
pos
.
__index__
except
AttributeError
as
err
:
raise
TypeError
(
"an integer is required"
)
from
err
if
whence
==
0
:
if
pos
<
0
:
raise
ValueError
(
"negative seek position %r"
%
(
pos
,))
self
.
_pos
=
pos
elif
whence
==
1
:
self
.
_pos
=
max
(
0
,
self
.
_pos
+
pos
)
elif
whence
==
2
:
self
.
_pos
=
max
(
0
,
len
(
self
.
_buffer
)
+
pos
)
else
:
raise
ValueError
(
"unsupported whence value"
)
return
self
.
_pos
def
tell
(
self
):
if
self
.
closed
:
raise
ValueError
(
"tell on closed file"
)
return
self
.
_pos
def
truncate
(
self
,
pos
=
None
):
if
self
.
closed
:
raise
ValueError
(
"truncate on closed file"
)
if
pos
is
None
:
pos
=
self
.
_pos
else
:
try
:
pos
.
__index__
except
AttributeError
as
err
:
raise
TypeError
(
"an integer is required"
)
from
err
if
pos
<
0
:
raise
ValueError
(
"negative truncate position %r"
%
(
pos
,))
del
self
.
_buffer
[
pos
:]
return
pos
def
readable
(
self
):
if
self
.
closed
:
raise
ValueError
(
"I/O operation on closed file."
)
return
True
def
writable
(
self
):
if
self
.
closed
:
raise
ValueError
(
"I/O operation on closed file."
)
return
True
def
seekable
(
self
):
if
self
.
closed
:
raise
ValueError
(
"I/O operation on closed file."
)
return
True
class
BufferedReader
(
_BufferedIOMixin
):
"""BufferedReader(raw[, buffer_size])
A buffer for a readable, sequential BaseRawIO object.
The constructor creates a BufferedReader for the given readable raw
stream and buffer_size. If buffer_size is omitted, DEFAULT_BUFFER_SIZE
is used.
"""
def
__init__
(
self
,
raw
,
buffer_size
=
DEFAULT_BUFFER_SIZE
):
"""Create a new buffered reader using the given readable raw IO object.
"""
if
not
raw
.
readable
():
raise
OSError
(
'"raw" argument must be readable.'
)
_BufferedIOMixin
.
__init__
(
self
,
raw
)
if
buffer_size
<=
0
:
raise
ValueError
(
"invalid buffer size"
)
self
.
buffer_size
=
buffer_size
self
.
_reset_read_buf
()
self
.
_read_lock
=
Lock
()
def
readable
(
self
):
return
self
.
raw
.
readable
()
def
_reset_read_buf
(
self
):
self
.
_read_buf
=
b""
self
.
_read_pos
=
0
def
read
(
self
,
size
=
None
):
"""Read size bytes.
Returns exactly size bytes of data unless the underlying raw IO
stream reaches EOF or if the call would block in non-blocking
mode. If size is negative, read until EOF or until read() would
block.
"""
if
size
is
not
None
and
size
<
-
1
:
raise
ValueError
(
"invalid number of bytes to read"
)
with
self
.
_read_lock
:
View remainder of file in raw view
Back
|
FazBrowse Home
|
New Git URL