.travis.yml

@@ -3,19 +3,26 @@ arch:
   - amd64
   - ppc64le
 python:
-  - "3.4"
   - "3.5"
   - "3.6"
   - "3.7"
   - "3.8"
   - "3.9"
   - "pypy3"
-# Disable unsuported version  pypy for ppc64le
+# Disable unsupported version  pypy for ppc64le
 jobs:
   exclude:
   - arch: ppc64le
     python: pypy3
 
+matrix:
+  include:
+    - python: 3.9
+      install:
+        - pip install mypy
+      script:
+        - mypy --strict idna/
+
 install:
   - pip install .
 script:

HISTORY.rst

@@ -3,6 +3,12 @@
 History
 -------
 
+3.2 (2021-05-29)
+++++++++++++++++
+
+- Add type hints (Thanks, Seth Michael Larson!)
+- Remove support for Python 3.4
+
 3.1 (2021-01-04)
 ++++++++++++++++
 

MANIFEST.in

@@ -1,5 +1,6 @@
 include *.rst
 include LICENSE.md
+include idna/py.typed
 recursive-include tools *
 recursive-exclude tools *.pyc
 recursive-include tests *

idna/__init__.py

@@ -1,2 +1,44 @@
 from .package_data import __version__
-from .core import *
+from .core import (
+    IDNABidiError,
+    IDNAError,
+    InvalidCodepoint,
+    InvalidCodepointContext,
+    alabel,
+    check_bidi,
+    check_hyphen_ok,
+    check_initial_combiner,
+    check_label,
+    check_nfc,
+    decode,
+    encode,
+    ulabel,
+    uts46_remap,
+    valid_contextj,
+    valid_contexto,
+    valid_label_length,
+    valid_string_length,
+)
+from .intranges import intranges_contain
+
+__all__ = [
+    "IDNABidiError",
+    "IDNAError",
+    "InvalidCodepoint",
+    "InvalidCodepointContext",
+    "alabel",
+    "check_bidi",
+    "check_hyphen_ok",
+    "check_initial_combiner",
+    "check_label",
+    "check_nfc",
+    "decode",
+    "encode",
+    "intranges_contain",
+    "ulabel",
+    "uts46_remap",
+    "valid_contextj",
+    "valid_contexto",
+    "valid_label_length",
+    "valid_string_length",
+]

idna/codec.py

@@ -1,23 +1,24 @@
 from .core import encode, decode, alabel, ulabel, IDNAError
 import codecs
 import re
+from typing import Tuple, Optional
 
 _unicode_dots_re = re.compile('[\u002e\u3002\uff0e\uff61]')
 
 class Codec(codecs.Codec):
 
     def encode(self, data, errors='strict'):
-
+        # type: (str, str) -> Tuple[bytes, int]
         if errors != 'strict':
             raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
 
         if not data:
-            return "", 0
+            return b"", 0
 
         return encode(data), len(data)
 
     def decode(self, data, errors='strict'):
-
+        # type: (bytes, str) -> Tuple[str, int]
         if errors != 'strict':
             raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
 
@@ -27,12 +28,13 @@ def decode(self, data, errors='strict'):
         return decode(data), len(data)
 
 class IncrementalEncoder(codecs.BufferedIncrementalEncoder):
-    def _buffer_encode(self, data, errors, final):
+    def _buffer_encode(self, data, errors, final):  # type: ignore
+        # type: (str, str, bool) -> Tuple[str, int]
         if errors != 'strict':
             raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
 
         if not data:
-            return ('', 0)
+            return "", 0
 
         labels = _unicode_dots_re.split(data)
         trailing_dot = ''
@@ -55,12 +57,13 @@ def _buffer_encode(self, data, errors, final):
             size += len(label)
 
         # Join with U+002E
-        result = '.'.join(result) + trailing_dot
+        result_str = '.'.join(result) + trailing_dot  # type: ignore
         size += len(trailing_dot)
-        return (result, size)
+        return result_str, size
 
 class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
-    def _buffer_decode(self, data, errors, final):
+    def _buffer_decode(self, data, errors, final):  # type: ignore
+        # type: (str, str, bool) -> Tuple[str, int]
         if errors != 'strict':
             raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
 
@@ -87,22 +90,26 @@ def _buffer_decode(self, data, errors, final):
                 size += 1
             size += len(label)
 
-        result = '.'.join(result) + trailing_dot
+        result_str = '.'.join(result) + trailing_dot
         size += len(trailing_dot)
-        return (result, size)
+        return (result_str, size)
 
 
 class StreamWriter(Codec, codecs.StreamWriter):
     pass
 
+
 class StreamReader(Codec, codecs.StreamReader):
     pass
 
+
 def getregentry():
+    # type: () -> codecs.CodecInfo
+    # Compatibility as a search_function for codecs.register()
     return codecs.CodecInfo(
         name='idna',
-        encode=Codec().encode,
-        decode=Codec().decode,
+        encode=Codec().encode,  # type: ignore
+        decode=Codec().decode,  # type: ignore
         incrementalencoder=IncrementalEncoder,
         incrementaldecoder=IncrementalDecoder,
         streamwriter=StreamWriter,

idna/compat.py

@@ -1,12 +1,16 @@
 from .core import *
 from .codec import *
+from typing import Any, Union
 
 def ToASCII(label):
+    # type: (str) -> bytes
     return encode(label)
 
 def ToUnicode(label):
+    # type: (Union[bytes, bytearray]) -> str
     return decode(label)
 
 def nameprep(s):
+    # type: (Any) -> None
     raise NotImplementedError('IDNA 2008 does not utilise nameprep protocol')