FazBrowse GitHub Viewer
|
Trending
|
URL:
|
Home
Tools:
[Download Repo ZIP]
[Original HTTPS Page]
cpython/Lib/chunk.py at 3.5 · python/cpython · GitHub
python
cpython
Repository navigation
Code
Issues
5k+
(5k+)
Pull requests
2.5k
(2.5k)
Actions
Projects
Security and quality
Insights
Expand file tree
Breadcrumbs
cpython
/
Lib
/
chunk.py
Copy path
More file actions
More file actions
Latest commit
History
History
History
169 lines (149 loc) · 5.3 KB
Breadcrumbs
cpython
/
Lib
/
chunk.py
Copy path
File metadata and controls
169 lines (149 loc) · 5.3 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
"""Simple class to read IFF chunks.
An IFF chunk (used in formats such as AIFF, TIFF, RMFF (RealMedia File
Format)) has the following structure:
+----------------+
| ID (4 bytes) |
+----------------+
| size (4 bytes) |
+----------------+
| data |
| ... |
+----------------+
The ID is a 4-byte string which identifies the type of chunk.
The size field (a 32-bit value, encoded using big-endian byte order)
gives the size of the whole chunk, including the 8-byte header.
Usually an IFF-type file consists of one or more chunks. The proposed
usage of the Chunk class defined here is to instantiate an instance at
the start of each chunk and read from the instance until it reaches
the end, after which a new instance can be instantiated. At the end
of the file, creating a new instance will fail with an EOFError
exception.
Usage:
while True:
try:
chunk = Chunk(file)
except EOFError:
break
chunktype = chunk.getname()
while True:
data = chunk.read(nbytes)
if not data:
pass
# do something with data
The interface is file-like. The implemented methods are:
read, close, seek, tell, isatty.
Extra methods are: skip() (called by close, skips to the end of the chunk),
getname() (returns the name (ID) of the chunk)
The __init__ method has one required argument, a file-like object
(including a chunk instance), and one optional argument, a flag which
specifies whether or not chunks are aligned on 2-byte boundaries. The
default is 1, i.e. aligned.
"""
class
Chunk
:
def
__init__
(
self
,
file
,
align
=
True
,
bigendian
=
True
,
inclheader
=
False
):
import
struct
self
.
closed
=
False
self
.
align
=
align
# whether to align to word (2-byte) boundaries
if
bigendian
:
strflag
=
'>'
else
:
strflag
=
'<'
self
.
file
=
file
self
.
chunkname
=
file
.
read
(
4
)
if
len
(
self
.
chunkname
)
<
4
:
raise
EOFError
try
:
self
.
chunksize
=
struct
.
unpack_from
(
strflag
+
'L'
,
file
.
read
(
4
))[
0
]
except
struct
.
error
:
raise
EOFError
if
inclheader
:
self
.
chunksize
=
self
.
chunksize
-
8
# subtract header
self
.
size_read
=
0
try
:
self
.
offset
=
self
.
file
.
tell
()
except
(
AttributeError
,
OSError
):
self
.
seekable
=
False
else
:
self
.
seekable
=
True
def
getname
(
self
):
"""Return the name (ID) of the current chunk."""
return
self
.
chunkname
def
getsize
(
self
):
"""Return the size of the current chunk."""
return
self
.
chunksize
def
close
(
self
):
if
not
self
.
closed
:
try
:
self
.
skip
()
finally
:
self
.
closed
=
True
def
isatty
(
self
):
if
self
.
closed
:
raise
ValueError
(
"I/O operation on closed file"
)
return
False
def
seek
(
self
,
pos
,
whence
=
0
):
"""Seek to specified position into the chunk.
Default position is 0 (start of chunk).
If the file is not seekable, this will result in an error.
"""
if
self
.
closed
:
raise
ValueError
(
"I/O operation on closed file"
)
if
not
self
.
seekable
:
raise
OSError
(
"cannot seek"
)
if
whence
==
1
:
pos
=
pos
+
self
.
size_read
elif
whence
==
2
:
pos
=
pos
+
self
.
chunksize
if
pos
<
0
or
pos
>
self
.
chunksize
:
raise
RuntimeError
self
.
file
.
seek
(
self
.
offset
+
pos
,
0
)
self
.
size_read
=
pos
def
tell
(
self
):
if
self
.
closed
:
raise
ValueError
(
"I/O operation on closed file"
)
return
self
.
size_read
def
read
(
self
,
size
=
-
1
):
"""Read at most size bytes from the chunk.
If size is omitted or negative, read until the end
of the chunk.
"""
if
self
.
closed
:
raise
ValueError
(
"I/O operation on closed file"
)
if
self
.
size_read
>=
self
.
chunksize
:
return
b''
if
size
<
0
:
size
=
self
.
chunksize
-
self
.
size_read
if
size
>
self
.
chunksize
-
self
.
size_read
:
size
=
self
.
chunksize
-
self
.
size_read
data
=
self
.
file
.
read
(
size
)
self
.
size_read
=
self
.
size_read
+
len
(
data
)
if
self
.
size_read
==
self
.
chunksize
and
\
self
.
align
and
\
(
self
.
chunksize
&
1
):
dummy
=
self
.
file
.
read
(
1
)
self
.
size_read
=
self
.
size_read
+
len
(
dummy
)
return
data
def
skip
(
self
):
"""Skip the rest of the chunk.
If you are not interested in the contents of the chunk,
this method should be called so that the file points to
the start of the next chunk.
"""
if
self
.
closed
:
raise
ValueError
(
"I/O operation on closed file"
)
if
self
.
seekable
:
try
:
n
=
self
.
chunksize
-
self
.
size_read
# maybe fix alignment
if
self
.
align
and
(
self
.
chunksize
&
1
):
n
=
n
+
1
self
.
file
.
seek
(
n
,
1
)
self
.
size_read
=
self
.
size_read
+
n
return
except
OSError
:
pass
while
self
.
size_read
<
self
.
chunksize
:
n
=
min
(
8192
,
self
.
chunksize
-
self
.
size_read
)
dummy
=
self
.
read
(
n
)
if
not
dummy
:
raise
EOFError
Back
|
FazBrowse Home
|
New Git URL