← Back to branch summary

~ubuntu-branches/ubuntu/utopic/dulwich/utopic

« back to all changes in this revision

Viewing changes to dulwich/pack.py

  • Committer: Package Import Robot
  • Author(s): Jelmer Vernooij
  • Date: 2014-04-23 01:41:04 UTC
  • mfrom: (1.5.5)
  • Revision ID: package-import@ubuntu.com-20140423014104-nulhaisomztpfriy
Tags: 0.9.6-1
* New upstream release.
* Allow output to stderr in autopktest.

Show diffs side-by-side

added added

removed removed

Lines of Context:
dulwich/pack.py
33
33
from collections import defaultdict
34
34
 
35
35
import binascii
36
 
from cStringIO import (
37
 
    StringIO,
38
 
    )
 
36
from io import BytesIO
39
37
from collections import (
40
38
    deque,
41
39
    )
624
622
        offset = self._pack_offset_table_offset + i * 4
625
623
        offset = unpack_from('>L', self._contents, offset)[0]
626
624
        if offset & (2**31):
627
 
            offset = self._pack_offset_largetable_offset + (offset&(2**31-1)) * 8L
 
625
            offset = self._pack_offset_largetable_offset + (offset&(2**31-1)) * 8
628
626
            offset = unpack_from('>Q', self._contents, offset)[0]
629
627
        return offset
630
628
 
719
717
    return unpacked, unused
720
718
 
721
719
 
722
 
def _compute_object_size((num, obj)):
 
720
def _compute_object_size(value):
723
721
    """Compute the size of a unresolved object for use with LRUSizeCache."""
 
722
    (num, obj) = value
724
723
    if num in DELTA_TYPES:
725
724
        return chunks_length(obj[1])
726
725
    return chunks_length(obj)
741
740
            self.read_some = read_some
742
741
        self.sha = sha1()
743
742
        self._offset = 0
744
 
        self._rbuf = StringIO()
 
743
        self._rbuf = BytesIO()
745
744
        # trailer is a deque to avoid memory allocation on small reads
746
745
        self._trailer = deque()
747
746
        self._zlib_bufsize = zlib_bufsize
794
793
        if buf_len >= size:
795
794
            return self._rbuf.read(size)
796
795
        buf_data = self._rbuf.read()
797
 
        self._rbuf = StringIO()
 
796
        self._rbuf = BytesIO()
798
797
        return buf_data + self._read(self.read_all, size - buf_len)
799
798
 
800
799
    def recv(self, size):
803
802
        if buf_len:
804
803
            data = self._rbuf.read(size)
805
804
            if size >= buf_len:
806
 
                self._rbuf = StringIO()
 
805
                self._rbuf = BytesIO()
807
806
            return data
808
807
        return self._read(self.read_some, size)
809
808
 
840
839
            unpacked.offset = offset
841
840
 
842
841
            # prepend any unused data to current read buffer
843
 
            buf = StringIO()
 
842
            buf = BytesIO()
844
843
            buf.write(unused)
845
844
            buf.write(self._rbuf.read())
846
845
            buf.seek(0)
1265
1264
            return
1266
1265
 
1267
1266
        for base_sha, pending in sorted(self._pending_ref.iteritems()):
 
1267
            if base_sha not in self._pending_ref:
 
1268
                continue
1268
1269
            try:
1269
1270
                type_num, chunks = self._resolve_ext_ref(base_sha)
1270
1271
            except KeyError:
1650
1651
    :param src_buf: Source buffer
1651
1652
    :param delta: Delta instructions
1652
1653
    """
1653
 
    if type(src_buf) != str:
 
1654
    if not isinstance(src_buf, str):
1654
1655
        src_buf = ''.join(src_buf)
1655
 
    if type(delta) != str:
 
1656
    if not isinstance(delta, str):
1656
1657
        delta = ''.join(delta)
1657
1658
    out = []
1658
1659
    index = 0
1806
1807
            self._idx.close()
1807
1808
 
1808
1809
    def __eq__(self, other):
1809
 
        return type(self) == type(other) and self.index == other.index
 
1810
        return isinstance(self, type(other)) and self.index == other.index
1810
1811
 
1811
1812
    def __len__(self):
1812
1813
        """Number of entries in this pack."""