mercurial: comparison mercurial/wireprotoframing.py

equal deleted inserted replaced

-:e8ea403b1c46
+:288de6f5d724
 # This file contains functionality to support the unified frame-based wire
 # protocol. For details about the protocol, see
 # `hg help internals.wireprotocol`.
-from __future__ import absolute_import
 import collections
 import struct
 from .i18n import _
 ARGUMENT_RECORD_HEADER = struct.Struct('<HH')
 def humanflags(mapping, value):
 """Convert a numeric flags value to a human value, using a mapping table."""
-namemap = {v: k for k, v in pycompat.iteritems(mapping)}
+namemap = {v: k for k, v in mapping.items()}
 flags = []
 val = 1
 while value >= val:
 if value & val:
 flags.append(namemap.get(val, b'<unknown 0x%02x>' % val))
 return b'|'.join(flags)
 @attr.s(slots=True)
-class frameheader(object):
+class frameheader:
 """Represents the data in a frame header."""
 length = attr.ib()
 requestid = attr.ib()
 streamid = attr.ib()
 typeid = attr.ib()
 flags = attr.ib()
 @attr.s(slots=True, repr=False)
-class frame(object):
+class frame:
 """Represents a parsed frame."""
 requestid = attr.ib()
 streamid = attr.ib()
 streamflags = attr.ib()
 payload = attr.ib()
 @encoding.strmethod
 def __repr__(self):
 typename = b'<unknown 0x%02x>' % self.typeid
-for name, value in pycompat.iteritems(FRAME_TYPES):
+for name, value in FRAME_TYPES.items():
 if value == self.typeid:
 typename = name
 break
 return (
 flags=0,
 payload=payload,
 )
-class bufferingcommandresponseemitter(object):
+class bufferingcommandresponseemitter:
 """Helper object to emit command response frames intelligently.
 Raw command response data is likely emitted in chunks much smaller
 than what can fit in a single frame. This class exists to buffer
 chunks until enough data is available to fit in a single frame.
 # TODO consider defining encoders/decoders using the util.compressionengine
 # mechanism.
-class identityencoder(object):
+class identityencoder:
 """Encoder for the "identity" stream encoding profile."""
 def __init__(self, ui):
 pass
 def finish(self):
 return b''
-class identitydecoder(object):
+class identitydecoder:
 """Decoder for the "identity" stream encoding profile."""
 def __init__(self, ui, extraobjs):
 if extraobjs:
 raise error.Abort(
 def decode(self, data):
 return data
-class zlibencoder(object):
+class zlibencoder:
 def __init__(self, ui):
 import zlib
 self._zlib = zlib
 self._compressor = zlib.compressobj()
 res = self._compressor.flush(self._zlib.Z_FINISH)
 self._compressor = None
 return res
-class zlibdecoder(object):
+class zlibdecoder:
 def __init__(self, ui, extraobjs):
 import zlib
 if extraobjs:
 raise error.Abort(
 )
 self._decompressor = zlib.decompressobj()
 def decode(self, data):
-# Python 2's zlib module doesn't use the buffer protocol and can't
-# handle all bytes-like types.
-if not pycompat.ispy3 and isinstance(data, bytearray):
-data = bytes(data)
 return self._decompressor.decompress(data)
-class zstdbaseencoder(object):
+class zstdbaseencoder:
 def __init__(self, level):
 from . import zstd
 self._zstd = zstd
 cctx = zstd.ZstdCompressor(level=level)
 class zstd8mbencoder(zstdbaseencoder):
 def __init__(self, ui):
 super(zstd8mbencoder, self).__init__(3)
-class zstdbasedecoder(object):
+class zstdbasedecoder:
 def __init__(self, maxwindowsize):
 from . import zstd
 dctx = zstd.ZstdDecompressor(max_window_size=maxwindowsize)
 self._decompressor = dctx.decompressobj()
 STREAM_ENCODERS[b'identity'] = (identityencoder, identitydecoder)
 STREAM_ENCODERS_ORDER.append(b'identity')
-class stream(object):
+class stream:
 """Represents a logical unidirectional series of frames."""
 def __init__(self, streamid, active=False):
 self.streamid = streamid
 self._active = active
 DEFAULT_PROTOCOL_SETTINGS = {
 b'contentencodings': [b'identity'],
 }
-class serverreactor(object):
+class serverreactor:
 """Holds state of a server handling frame-based protocol requests.
 This class is the "brain" of the unified frame-based protocol server
 component. While the protocol is stateless from the perspective of
 requests/commands, something needs to track which frames have been
 def _onframeerrored(self, frame):
 return self._makeerrorresult(_(b'server already errored'))
-class commandrequest(object):
+class commandrequest:
 """Represents a request to run a command."""
 def __init__(self, requestid, name, args, datafh=None, redirect=None):
 self.requestid = requestid
 self.name = name
 self.datafh = datafh
 self.redirect = redirect
 self.state = b'pending'
-class clientreactor(object):
+class clientreactor:
 """Holds state of a client issuing frame-based protocol requests.
 This is like ``serverreactor`` but for client-side state.
 Each instance is bound to the lifetime of a connection. For persistent

branch	stable
changeset 49366	288de6f5d724
parent 48946	642e31cb55f0
child 50929	18c8c18993f0