10000 Use _private names for non public data members. (fix #44) · pyway/msgpack-python@a865f8f · GitHub
[go: up one dir, main page]
Skip to content

Commit a865f8f

Browse files
methanemethane
committed
Use _private names for non public data members. (fix msgpack#44)
1 parent 1951b19 commit a865f8f

File tree

1 file changed

+76
-75
lines changed

1 file changed

+76
-75
lines changed

‎msgpack/fallback.py

Lines changed: 76 additions & 75 deletions
Original file line numberDiff line numberDiff line change
@@ -168,18 +168,18 @@ def __init__(self, file_like=None, read_size=0, use_list=True,
168168
self._fb_buf_o = 0
169169
self._fb_buf_i = 0
170170
self._fb_buf_n < 10000 span class=pl-c1>= 0
171-
self.max_buffer_size = (2**31-1 if max_buffer_size == 0
172-
else max_buffer_size)
173-
self.read_size = (read_size if read_size != 0
174-
else min(self.max_buffer_size, 2048))
175-
if read_size > self.max_buffer_size:
171+
self._max_buffer_size = (2**31-1 if max_buffer_size == 0
172+
else max_buffer_size)
173+
self._read_size = (read_size if read_size != 0
174+
else min(self._max_buffer_size, 2048))
175+
if read_size > self._max_buffer_size:
176176
raise ValueError("read_size must be smaller than max_buffer_size")
177-
self.encoding = encoding
178-
self.unicode_errors = unicode_errors
179-
self.use_list = use_list
180-
self.list_hook = list_hook
181-
self.object_hook = object_hook
182-
self.object_pairs_hook = object_pairs_hook
177+
self._encoding = encoding
178+
self._unicode_errors = unicode_errors
179+
self._use_list = use_list
180+
self._list_hook = list_hook
181+
self._object_hook = object_hook
182+
self._object_pairs_hook = object_pairs_hook
183183

184184
if list_hook is not None and not callable(list_hook):
185185
raise ValueError('`list_hook` is not callable')
@@ -195,7 +195,7 @@ def feed(self, next_bytes):
195195
if isinstance(next_bytes, array.array):
196196
next_bytes = next_bytes.tostring()
197197
assert self._fb_feeding
198-
if self._fb_buf_n + len(next_bytes) > self.max_buffer_size:
198+
if self._fb_buf_n + len(next_bytes) > self._max_buffer_size:
199199
raise BufferFull
200200
self._fb_buf_n += len(next_bytes)
201201
self._fb_buffers.append(next_bytes)
@@ -246,7 +246,7 @@ def _fb_read(self, n, write_bytes=None):
246246
if self._fb_buf_i == len(self._fb_buffers):
247247
if self._fb_feeding:
248248
break
249-
tmp = self.file_like.read(self.read_size)
249+
tmp = self.file_like.read(self._read_size)
250250
if not tmp:
251251
break
252252
self._fb_buffers.append(tmp)
@@ -349,19 +349,19 @@ def _fb_unpack(self, execute=EX_CONSTRUCT, write_bytes=None):
349349
ret = []
350350
for i in xrange(n):
351351
ret.append(self._fb_unpack(EX_CONSTRUCT, write_bytes))
352-
if self.list_hook is not None:
353-
ret = self.list_hook(ret)
352+
if self._list_hook is not None:
353+
ret = self._list_hook(ret)
354354
# TODO is the interaction between `list_hook` and `use_list` ok?
355-
return ret if self.use_list else tuple(ret)
355+
return ret if self._use_list else tuple(ret)
356356
if typ == TYPE_MAP:
357357
if execute == EX_SKIP:
358358
for i in xrange(n):
359359
# TODO check whether we need to call hooks
360360
self._fb_unpack(EX_SKIP, write_bytes)
361361
self._fb_unpack(EX_SKIP, write_bytes)
362362
return
363-
if self.object_pairs_hook is not None:
364-
ret = self.object_pairs_hook(
363+
if self._object_pairs_hook is not None:
364+
ret = self._object_pairs_hook(
365365
(self._fb_unpack(EX_CONSTRUCT, write_bytes),
366366
self._fb_unpack(EX_CONSTRUCT, write_bytes))
367367
for _ in xrange(n)
@@ -371,14 +371,14 @@ def _fb_unpack(self, execute=EX_CONSTRUCT, write_bytes=None):
371371
for _ in xrange(n):
372372
key = self._fb_unpack(EX_CONSTRUCT, write_bytes)
373373
ret[key] = self._fb_unpack(EX_CONSTRUCT, write_bytes)
374-
if self.object_hook is not None:
375-
ret = self.object_hook(ret)
374+
if self._object_hook is not None:
375+
ret = self._object_hook(ret)
376376
return ret
377377
if execute == EX_SKIP:
378378
return
379379
if typ == TYPE_RAW:
380-
if self.encoding is not None:
381-
obj = obj.decode(self.encoding, self.unicode_errors)
380+
if self._encoding is not None:
381+
obj = obj.decode(self._encoding, self._unicode_errors)
382382
return obj
383383
assert typ == TYPE_IMMEDIATE
384384
return obj
@@ -411,14 +411,15 @@ def read_map_header(self, write_bytes=None):
411411
self._fb_consume()
412412
return ret
413413

414+
414415
class Packer(object):
415416
def __init__(self, default=None, encoding='utf-8', unicode_errors='strict',
416417
use_single_float=False, autoreset=True):
417-
self.use_float = use_single_float
418-
self.autoreset = autoreset
419-
self.encoding = encoding
420-
self.unicode_errors = unicode_errors
421-
self.buffer = StringIO()
418+
self._use_float = use_single_float
419+
self._autoreset = autoreset
420+
self._encoding = encoding
421+
self._unicode_errors = unicode_errors
422+
self._buffer = StringIO()
422423
if default is not None:
423424
if not callable(default):
424425
raise TypeError("default must be callable")
@@ -428,55 +429,55 @@ def _pack(self, obj, nest_limit=DEFAULT_RECURSE_LIMIT, isinstance=isinstance):
428429
if nest_limit < 0:
429430
raise PackValueError("recursion limit exceeded")
430431
if obj is None:
431-
return self.buffer.write(b"\xc0")
432+
return self._buffer.write(b"\xc0")
432433
if isinstance(obj, bool):
433434
if obj:
434-
return self.buffer.write(b"\xc3")
435-
return self.buffer.write(b"\xc2")
435+
return self._buffer.write(b"\xc3")
436+
return self._buffer.write(b"\xc2")
436437
if isinstance(obj, int_types):
437438
if 0 <= obj < 0x80:
438-
return self.buffer.write(struct.pack("B", obj))
439+
return self._buffer.write(struct.pack("B", obj))
439440
if -0x20 <= obj < 0:
440-
return self.buffer.write(struct.pack("b", obj))
441+
return self._buffer.write(struct.pack("b", obj))
441442
if 0x80 <= obj <= 0xff:
442-
return self.buffer.write(struct.pack("BB", 0xcc, obj))
443+
return self._buffer.write(struct.pack("BB", 0xcc, obj))
443444
if -0x80 <= obj < 0:
444-
return self.buffer.write(struct.pack(">Bb", 0xd0, obj))
445+
return self._buffer.write(struct.pack(">Bb", 0xd0, obj))
445446
if 0xff < obj <= 0xffff:
446-
return self.buffer.write(struct.pack(">BH", 0xcd, obj))
447+
return self._buffer.write(struct.pack(">BH", 0xcd, obj))
447448
if -0x8000 <= obj < -0x80:
448-
return self.buffer.write(struct.pack(">Bh", 0xd1, obj))
449+
return self._buffer.write(struct.pack(">Bh", 0xd1, obj))
449450
if 0xffff < obj <= 0xffffffff:
450-
return self.buffer.write(struct.pack(">BI", 0xce, obj))
451+
return self._buffer.write(struct.pack(">BI", 0xce, obj))
451452
if -0x80000000 <= obj < -0x8000:
452-
return self.buffer.write(struct.pack(">Bi", 0xd2, obj))
453+
return self._buffer.write(struct.pack(">Bi", 0xd2, obj))
453454
if 0xffffffff < obj <= 0xffffffffffffffff:
454-
return self.buffer.write(struct.pack(">BQ", 0xcf, obj))
455+
return self._buffer.write(struct.pack(">BQ", 0xcf, obj))
455456
if -0x8000000000000000 <= obj < -0x80000000:
456-
return self.buffer.write(struct.pack(">Bq", 0xd3, obj))
457+
return self._buffer.write(struct.pack(">Bq", 0xd3, obj))
457458
raise PackValueError("Integer value out of range")
458459
if isinstance(obj, (Unicode, bytes)):
459460
if isinstance(obj, Unicode):
460-
if self.encoding is None:
461+
if self._encoding is None:
461462
raise TypeError(
462463
"Can't encode unicode string: "
463464
"no encoding is specified")
464-
obj = obj.encode(self.encoding, self.unicode_errors)
465+
obj = obj.encode(self._encoding, self._unicode_errors)
465466
n = len(obj)
466467
if n <= 0x1f:
467-
self.buffer.write(struct.pack('B', 0xa0 + n))
468-
return self.buffer.write(obj)
468+
self._buffer.write(struct.pack('B', 0xa0 + n))
469+
return self._buffer.write(obj)
469470
if n <= 0xffff:
470-
self.buffer.write(struct.pack(">BH", 0xda, n))
471-
return self.buffer.write(obj)
471+
self._buffer.write(struct.pack(">BH", 0xda, n))
472+
return self._buffer.write(obj)
472473
if n <= 0xffffffff:
473-
self.buffer.write(struct.pack(">BI", 0xdb, n))
474-
return self.buffer.write(obj)
474+
self._buffer.write(struct.pack(">BI", 0xdb, n))
475+
return self._buffer.write(obj)
475476
raise PackValueError("String is too large")
476477
if isinstance(obj, float):
477-
if self.use_float:
478-
return self.buffer.write(struct.pack(">Bf", 0xca, obj))
479-
return self.buffer.write(struct.pack(">Bd", 0xcb, obj))
478+
if self._use_float:
479+
return self._buffer.write(struct.pack(">Bf", 0xca, obj))
480+
return self._buffer.write(struct.pack(">Bd", 0xcb, obj))
480481
if isinstance(obj, list) or isinstance(obj, tuple):
481482
n = len(obj)
482483
self._fb_pack_array_header(n)
@@ -492,56 +493,56 @@ def _pack(self, obj, nest_limit=DEFAULT_RECURSE_LIMIT, isinstance=isinstance):
492493

493494
def pack(self, obj):
494495
self._pack(obj)
495-
ret = self.buffer.getvalue()
496-
if self.autoreset:
497-
self.buffer = StringIO()
496+
ret = self._buffer.getvalue()
497+
if self._autoreset:
498+
self._buffer = StringIO()
498499
elif USING_STRINGBUILDER:
499-
self.buffer = StringIO(ret)
500+
self._buffer = StringIO(ret)
500501
return ret
501502

502503
def pack_map_pairs(self, pairs):
503504
self._fb_pack_map_pairs(len(pairs), pairs)
504-
ret = self.buffer.getvalue()
505-
if self.autoreset:
506-
self.buffer = StringIO()
505+
ret = self._buffer.getvalue()
506+
if self._autoreset:
507+
self._buffer = StringIO()
507508
elif USING_STRI 17AE NGBUILDER:
508-
self.buffer = StringIO(ret)
509+
self._buffer = StringIO(ret)
509510
return ret
510511

511512
def pack_array_header(self, n):
512513
self._fb_pack_array_header(n)
513-
ret = self.buffer.getvalue()
514-
if self.autoreset:
515-
self.buffer = StringIO()
514+
ret = self._buffer.getvalue()
515+
if self._autoreset:
516+
self._buffer = StringIO()
516517
elif USING_STRINGBUILDER:
517-
self.buffer = StringIO(ret)
518+
self._buffer = StringIO(ret)
518519
return ret
519520

520521
def pack_map_header(self, n):
521522
self._fb_pack_map_header(n)
522-
ret = self.buffer.getvalue()
523-
if self.autoreset:
524-
self.buffer = StringIO()
523+
ret = self._buffer.getvalue()
524+
if self._autoreset:
525+
self._buffer = StringIO()
525526
elif USING_STRINGBUILDER:
526-
self.buffer = StringIO(ret)
527+
self._buffer = StringIO(ret)
527528
return ret
528529

529530
def _fb_pack_array_header(self, n):
530531
if n <= 0x0f:
531-
return self.buffer.write(struct.pack('B', 0x90 + n))
532+
return self._buffer.write(struct.pack('B', 0x90 + n))
532533
if n <= 0xffff:
533-
return self.buffer.write(struct.pack(">BH", 0xdc, n))
534+
return self._buffer.write(struct.pack(">BH", 0xdc, n))
534535
if n <= 0xffffffff:
535-
return self.buffer.write(struct.pack(">BI", 0xdd, n))
536+
return self._buffer.write(struct.pack(">BI", 0xdd, n))
536537
raise PackValueError("Array is too large")
537538

538539
def _fb_pack_map_header(self, n):
539540
if n <= 0x0f:
540-
return self.buffer.write(struct.pack('B', 0x80 + n))
541+
return self._buffer.write(struct.pack('B', 0x80 + n))
541542
if n <= 0xffff:
542-
return self.buffer.write(struct.pack(">BH", 0xde, n))
543+
return self._buffer.write(struct.pack(">BH", 0xde, n))
543544
if n <= 0xffffffff:
544-
return self.buffer.write(struct.pack(">BI", 0xdf, n))
545+
return self._buffer.write(struct.pack(">BI", 0xdf, n))
545546
raise PackValueError("Dict is too large")
546547

547548
def _fb_pack_map_pairs(self, n, pairs, nest_limit=DEFAULT_RECURSE_LIMIT):
@@ -551,7 +552,7 @@ def _fb_pack_map_pairs(self, n, pairs, nest_limit=DEFAULT_RECURSE_LIMIT):
551552
self._pack(v, nest_limit - 1)
552553

553554
def bytes(self):
554-
return self.buffer.getvalue()
555+
return self._buffer.getvalue()
555556

556557
def reset(self):
557-
self.buffer = StringIO()
558+
self._buffer = StringIO()

0 commit comments

Comments
 (0)
0