- Notifications
You must be signed in to change notification settings - Fork68
Expand file tree
/
Copy pathbase.py
More file actions
315 lines (213 loc) · 7.84 KB
/
base.py
File metadata and controls
315 lines (213 loc) · 7.84 KB
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
# Copyright (C) 2010, 2011 Sebastian Thiel (byronimo@gmail.com) and contributors
#
# This module is part of GitDB and is released under
# the New BSD License: http://www.opensource.org/licenses/bsd-license.php
"""Module with basic data structures - they are designed to be lightweight and fast"""
fromgitdb.utilimportbin_to_hex
fromgitdb.funimport (
type_id_to_type_map,
type_to_type_id_map
)
__all__= ('OInfo','OPackInfo','ODeltaPackInfo',
'OStream','OPackStream','ODeltaPackStream',
'IStream','InvalidOInfo','InvalidOStream')
#{ ODB Bases
classOInfo(tuple):
"""Carries information about an object in an ODB, providing information
about the binary sha of the object, the type_string as well as the uncompressed size
in bytes.
It can be accessed using tuple notation and using attribute access notation::
assert dbi[0] == dbi.binsha
assert dbi[1] == dbi.type
assert dbi[2] == dbi.size
The type is designed to be as lightweight as possible."""
__slots__=tuple()
def__new__(cls,sha,type,size):
returntuple.__new__(cls, (sha,type,size))
def__init__(self,*args):
tuple.__init__(self)
#{ Interface
@property
defbinsha(self):
""":return: our sha as binary, 20 bytes"""
returnself[0]
@property
defhexsha(self):
""":return: our sha, hex encoded, 40 bytes"""
returnbin_to_hex(self[0])
@property
deftype(self):
returnself[1]
@property
deftype_id(self):
returntype_to_type_id_map[self[1]]
@property
defsize(self):
returnself[2]
#} END interface
classOPackInfo(tuple):
"""As OInfo, but provides a type_id property to retrieve the numerical type id, and
does not include a sha.
Additionally, the pack_offset is the absolute offset into the packfile at which
all object information is located. The data_offset property points to the absolute
location in the pack at which that actual data stream can be found."""
__slots__=tuple()
def__new__(cls,packoffset,type,size):
returntuple.__new__(cls, (packoffset,type,size))
def__init__(self,*args):
tuple.__init__(self)
#{ Interface
@property
defpack_offset(self):
returnself[0]
@property
deftype(self):
returntype_id_to_type_map[self[1]]
@property
deftype_id(self):
returnself[1]
@property
defsize(self):
returnself[2]
#} END interface
classODeltaPackInfo(OPackInfo):
"""Adds delta specific information,
Either the 20 byte sha which points to some object in the database,
or the negative offset from the pack_offset, so that pack_offset - delta_info yields
the pack offset of the base object"""
__slots__=tuple()
def__new__(cls,packoffset,type,size,delta_info):
returntuple.__new__(cls, (packoffset,type,size,delta_info))
#{ Interface
@property
defdelta_info(self):
returnself[3]
#} END interface
classOStream(OInfo):
"""Base for object streams retrieved from the database, providing additional
information about the stream.
Generally, ODB streams are read-only as objects are immutable"""
__slots__=tuple()
def__new__(cls,sha,type,size,stream,*args,**kwargs):
"""Helps with the initialization of subclasses"""
returntuple.__new__(cls, (sha,type,size,stream))
def__init__(self,*args,**kwargs):
tuple.__init__(self)
#{ Stream Reader Interface
defread(self,size=-1):
returnself[3].read(size)
@property
defstream(self):
returnself[3]
#} END stream reader interface
classODeltaStream(OStream):
"""Uses size info of its stream, delaying reads"""
def__new__(cls,sha,type,size,stream,*args,**kwargs):
"""Helps with the initialization of subclasses"""
returntuple.__new__(cls, (sha,type,size,stream))
#{ Stream Reader Interface
@property
defsize(self):
returnself[3].size
#} END stream reader interface
classOPackStream(OPackInfo):
"""Next to pack object information, a stream outputting an undeltified base object
is provided"""
__slots__=tuple()
def__new__(cls,packoffset,type,size,stream,*args):
"""Helps with the initialization of subclasses"""
returntuple.__new__(cls, (packoffset,type,size,stream))
#{ Stream Reader Interface
defread(self,size=-1):
returnself[3].read(size)
@property
defstream(self):
returnself[3]
#} END stream reader interface
classODeltaPackStream(ODeltaPackInfo):
"""Provides a stream outputting the uncompressed offset delta information"""
__slots__=tuple()
def__new__(cls,packoffset,type,size,delta_info,stream):
returntuple.__new__(cls, (packoffset,type,size,delta_info,stream))
#{ Stream Reader Interface
defread(self,size=-1):
returnself[4].read(size)
@property
defstream(self):
returnself[4]
#} END stream reader interface
classIStream(list):
"""Represents an input content stream to be fed into the ODB. It is mutable to allow
the ODB to record information about the operations outcome right in this instance.
It provides interfaces for the OStream and a StreamReader to allow the instance
to blend in without prior conversion.
The only method your content stream must support is 'read'"""
__slots__=tuple()
def__new__(cls,type,size,stream,sha=None):
returnlist.__new__(cls, (sha,type,size,stream,None))
def__init__(self,type,size,stream,sha=None):
list.__init__(self, (sha,type,size,stream,None))
#{ Interface
@property
defhexsha(self):
""":return: our sha, hex encoded, 40 bytes"""
returnbin_to_hex(self[0])
def_error(self):
""":return: the error that occurred when processing the stream, or None"""
returnself[4]
def_set_error(self,exc):
"""Set this input stream to the given exc, may be None to reset the error"""
self[4]=exc
error=property(_error,_set_error)
#} END interface
#{ Stream Reader Interface
defread(self,size=-1):
"""Implements a simple stream reader interface, passing the read call on
to our internal stream"""
returnself[3].read(size)
#} END stream reader interface
#{ interface
def_set_binsha(self,binsha):
self[0]=binsha
def_binsha(self):
returnself[0]
binsha=property(_binsha,_set_binsha)
def_type(self):
returnself[1]
def_set_type(self,type):
self[1]=type
type=property(_type,_set_type)
def_size(self):
returnself[2]
def_set_size(self,size):
self[2]=size
size=property(_size,_set_size)
def_stream(self):
returnself[3]
def_set_stream(self,stream):
self[3]=stream
stream=property(_stream,_set_stream)
#} END odb info interface
classInvalidOInfo(tuple):
"""Carries information about a sha identifying an object which is invalid in
the queried database. The exception attribute provides more information about
the cause of the issue"""
__slots__=tuple()
def__new__(cls,sha,exc):
returntuple.__new__(cls, (sha,exc))
def__init__(self,sha,exc):
tuple.__init__(self, (sha,exc))
@property
defbinsha(self):
returnself[0]
@property
defhexsha(self):
returnbin_to_hex(self[0])
@property
deferror(self):
""":return: exception instance explaining the failure"""
returnself[1]
classInvalidOStream(InvalidOInfo):
"""Carries information about an invalid ODB stream"""
__slots__=tuple()
#} END ODB Bases