mercurial: comparison mercurial/encoding.py

equal deleted inserted replaced

-:81224afd938d
+:f15cb5111a1e
 ]
 # verify the next function will work
 assert all(i.startswith((b"\xe2", b"\xef")) for i in _ignore)
-def hfsignoreclean(s):
+def hfsignoreclean(s: bytes) -> bytes:
-# type: (bytes) -> bytes
 """Remove codepoints ignored by HFS+ from s.
 >>> hfsignoreclean(u'.h\u200cg'.encode('utf-8'))
 '.hg'
 >>> hfsignoreclean(u'.h\ufeffg'.encode('utf-8'))
 s._utf8 = u
 return s
 if typing.TYPE_CHECKING:
 # pseudo implementation to help pytype see localstr() constructor
-def __init__(self, u, l):
+def __init__(self, u: bytes, l: bytes) -> None:
-# type: (bytes, bytes) -> None
 super(localstr, self).__init__(l)
 self._utf8 = u
 def __hash__(self):
 return hash(self._utf8)  # avoid collisions in local string space
 >>> assert b'\\xc3' in {safelocalstr(b'\\xc3'): 0}
 >>> assert safelocalstr(b'\\xc3') in {b'\\xc3': 0}
 """
-def tolocal(s):
+def tolocal(s: bytes) -> bytes:
-# type: (bytes) -> bytes
 """
 Convert a string from internal UTF-8 to local encoding
 All internal strings should be UTF-8 but some repos before the
 implementation of locale support may contain latin1 or possibly
 raise error.Abort(
 pycompat.bytestr(k), hint=b"please check your locale settings"
 )
-def fromlocal(s):
+def fromlocal(s: bytes) -> bytes:
-# type: (bytes) -> bytes
 """
 Convert a string from the local character encoding to UTF-8
 We attempt to decode strings using the encoding mode set by
 HGENCODINGMODE, which defaults to 'strict'. In this mode, unknown
 raise error.Abort(
 pycompat.bytestr(k), hint=b"please check your locale settings"
 )
-def unitolocal(u):
+def unitolocal(u: str) -> bytes:
-# type: (Text) -> bytes
 """Convert a unicode string to a byte string of local encoding"""
 return tolocal(u.encode('utf-8'))
-def unifromlocal(s):
+def unifromlocal(s: bytes) -> str:
-# type: (bytes) -> Text
 """Convert a byte string of local encoding to a unicode string"""
 return fromlocal(s).decode('utf-8')
-def unimethod(bytesfunc):
+def unimethod(bytesfunc: Callable[[Any], bytes]) -> Callable[[Any], str]:
-# type: (Callable[[Any], bytes]) -> Callable[[Any], Text]
 """Create a proxy method that forwards __unicode__() and __str__() of
 Python 3 to __bytes__()"""
 def unifunc(obj):
 return unifromlocal(bytesfunc(obj))
 strtolocal = unitolocal
 strfromlocal = unifromlocal
 strmethod = unimethod
-def lower(s):
+def lower(s: bytes) -> bytes:
-# type: (bytes) -> bytes
 """best-effort encoding-aware case-folding of local string s"""
 try:
 return asciilower(s)
 except UnicodeDecodeError:
 pass
 raise error.Abort(
 pycompat.bytestr(k), hint=b"please check your locale settings"
 )
-def upper(s):
+def upper(s: bytes) -> bytes:
-# type: (bytes) -> bytes
 """best-effort encoding-aware case-folding of local string s"""
 try:
 return asciiupper(s)
 except UnicodeDecodeError:
 return upperfallback(s)
-def upperfallback(s):
+def upperfallback(s: Any) -> Any:
-# type: (Any) -> Any
 try:
 if isinstance(s, localstr):
 u = s._utf8.decode("utf-8")
 else:
 u = s.decode(_sysstr(encoding), _sysstr(encodingmode))
 and b"WFA"
 or b"WF"
 )
-def colwidth(s):
+def colwidth(s: bytes) -> int:
-# type: (bytes) -> int
 """Find the column width of a string for display in the local encoding"""
 return ucolwidth(s.decode(_sysstr(encoding), 'replace'))
-def ucolwidth(d):
+def ucolwidth(d: Text) -> int:
-# type: (Text) -> int
 """Find the column width of a Unicode string for display"""
 eaw = getattr(unicodedata, 'east_asian_width', None)
 if eaw is not None:
 return sum([eaw(c) in _wide and 2 or 1 for c in d])
 return len(d)
-def getcols(s, start, c):
+def getcols(s: bytes, start: int, c: int) -> bytes:
-# type: (bytes, int, int) -> bytes
 """Use colwidth to find a c-column substring of s starting at byte
 index start"""
 for x in range(start + c, len(s)):
 t = s[start:x]
 if colwidth(t) == c:
 return t
 raise ValueError('substring not found')
-def trim(s, width, ellipsis=b'', leftside=False):
+def trim(
-# type: (bytes, int, bytes, bool) -> bytes
+s: bytes,
+width: int,
+ellipsis: bytes = b'',
+leftside: bool = False,
+) -> bytes:
 """Trim string 's' to at most 'width' columns (including 'ellipsis').
 If 'leftside' is True, left side of string 's' is trimmed.
 'ellipsis' is always placed at trimmed side.
 lower = -1
 upper = 1
 other = 0
-def jsonescape(s, paranoid=False):
+def jsonescape(s: Any, paranoid: Any = False) -> Any:
-# type: (Any, Any) -> Any
 """returns a string suitable for JSON
 JSON is problematic for us because it doesn't support non-Unicode
 bytes. To deal with this, we take the following approach:
 _utf8strict = r'surrogatepass'
 _utf8len = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 4]
-def getutf8char(s, pos):
+def getutf8char(s: bytes, pos: int) -> bytes:
-# type: (bytes, int) -> bytes
 """get the next full utf-8 character in the given string, starting at pos
 Raises a UnicodeError if the given location does not start a valid
 utf-8 character.
 """
 # validate with attempted decode
 c.decode("utf-8", _utf8strict)
 return c
-def toutf8b(s):
+def toutf8b(s: bytes) -> bytes:
-# type: (bytes) -> bytes
 """convert a local, possibly-binary string into UTF-8b
 This is intended as a generic method to preserve data when working
 with schemes like JSON and XML that have no provision for
 arbitrary byte strings. As Mercurial often doesn't know
 pos += 1
 r += c
 return bytes(r)
-def fromutf8b(s):
+def fromutf8b(s: bytes) -> bytes:
-# type: (bytes) -> bytes
 """Given a UTF-8b string, return a local, possibly-binary string.
 return the original binary string. This
 is a round-trip process for strings like filenames, but metadata
 that's was passed through tolocal will remain in UTF-8.

changeset 51287	f15cb5111a1e
parent 51285	9d3721552b6c
child 51290	f4a0806081f2