Added support for Python 3.9 and 3.10 (#236)

This patch introduces Python versions 3.9 and 3.10 in continuous
integration.

Fixes #235.

.github/workflows/ci.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [3.6, 3.7, 3.8]
+        python-version: ['3.6', '3.7', '3.8', '3.9', '3.10']
 
     steps:
       - uses: actions/checkout@master

.gitignore

@@ -1,5 +1,4 @@
-venv3/
-venv/
+venv*/
 .mypy_cache/
 .idea/
 *.pyc

icontract/_metaclass.py

@@ -1,7 +1,7 @@
 """Define the metaclass necessary to inherit the contracts from the base classes."""
 import abc
 import inspect
-import platform
+import sys
 import weakref
 from typing import List, MutableMapping, Any, Callable, Optional, cast, Set, Type, \
     TypeVar  # pylint: disable=unused-import
@@ -316,12 +316,12 @@ class DBCMeta(abc.ABCMeta):
     # instead of ``mcs``.
     # pylint: disable=bad-mcs-classmethod-argument
 
-    if platform.python_version_tuple() < ('3', ):
-        raise NotImplementedError("Python versions below not supported, got: {}".format(platform.python_version()))
+    if sys.version_info < (3, ):
+        raise NotImplementedError("Python versions below not supported, got: {}".format(sys.version_info))
 
-    if platform.python_version_tuple() <= ('3', '5'):
+    if sys.version_info < (3, 6):
         # pylint: disable=arguments-differ
-        def __new__(mlcs, name, bases, namespace):  # type: ignore
+        def __new__(mlcs, name, bases, namespace):
             """Create a class with inherited preconditions, postconditions and invariants."""
             _dbc_decorate_namespace(bases, namespace)
 
@@ -335,7 +335,7 @@ def __new__(mlcs, name, bases, namespace):  # type: ignore
             # This usually works since icontract-hypothesis does not use DBCMeta,
             # but blows up since icontract creates DBC with DBCMeta meta-class at the import time.
             if cls.__module__ != __name__:
-                _register_for_hypothesis(cls)  # type: ignore
+                _register_for_hypothesis(cls)
 
             return cls
     else:

icontract/_recompute.py

@@ -5,7 +5,6 @@
 import copy
 import functools
 import inspect
-import platform
 import sys
 import uuid
 from typing import (Any, Mapping, Dict, List, Optional, Union, Tuple, Set, Callable, cast, Iterable, TypeVar)  # pylint: disable=unused-import
@@ -163,11 +162,11 @@ def _translate_all_expression_to_a_module(generator_exp: ast.GeneratorExp, gener
 
     args = [ast.arg(arg=name, annotation=None) for name in sorted(name_to_value.keys())]
 
-    if platform.python_version_tuple() < ('3', '5'):
-        raise NotImplementedError("Python versions below 3.5 not supported, got: {}".format(platform.python_version()))
+    if sys.version_info < (3, 5):
+        raise NotImplementedError("Python versions below 3.5 not supported, got: {}".format(sys.version_info))
 
     if not is_async:
-        if platform.python_version_tuple() < ('3', '8'):
+        if sys.version_info < (3, 8):
             func_def_node = ast.FunctionDef(
                 name=generated_function_name,
                 args=ast.arguments(args=args, kwonlyargs=[], kw_defaults=[], defaults=[], vararg=None, kwarg=None),
@@ -185,23 +184,23 @@ def _translate_all_expression_to_a_module(generator_exp: ast.GeneratorExp, gener
 
             module_node = ast.Module(body=[func_def_node], type_ignores=[])
     else:
-        if platform.python_version_tuple() < ('3', '8'):
-            func_def_node = ast.AsyncFunctionDef(
+        if sys.version_info < (3, 8):
+            async_func_def_node = ast.AsyncFunctionDef(
                 name=generated_function_name,
                 args=ast.arguments(args=args, kwonlyargs=[], kw_defaults=[], defaults=[], vararg=None, kwarg=None),
                 decorator_list=[],
                 body=block)
 
-            module_node = ast.Module(body=[func_def_node])
+            module_node = ast.Module(body=[async_func_def_node])
         else:
-            func_def_node = ast.AsyncFunctionDef(
+            async_func_def_node = ast.AsyncFunctionDef(
                 name=generated_function_name,
                 args=ast.arguments(
                     args=args, posonlyargs=[], kwonlyargs=[], kw_defaults=[], defaults=[], vararg=None, kwarg=None),
                 decorator_list=[],
                 body=block)
 
-            module_node = ast.Module(body=[func_def_node], type_ignores=[])
+            module_node = ast.Module(body=[async_func_def_node], type_ignores=[])
 
     ast.fix_missing_locations(module_node)
 
@@ -664,16 +663,18 @@ def visit_NamedExpr(self, node: ast.NamedExpr) -> Any:
 
             return value
 
-    def visit_Index(self, node: ast.Index) -> Any:
-        """Visit the node's ``value``."""
-        result = self.visit(node=node.value)
+    if sys.version_info < (3, 9):
 
-        # Please see "NOTE ABOUT PLACEHOLDERS AND RE-COMPUTATION"
-        if result is PLACEHOLDER:
-            return PLACEHOLDER
+        def visit_Index(self, node: ast.Index) -> Any:
+            """Visit the node's ``value``."""
+            result = self.visit(node=node.value)
 
-        self.recomputed_values[node] = result
-        return result
+            # Please see "NOTE ABOUT PLACEHOLDERS AND RE-COMPUTATION"
+            if result is PLACEHOLDER:
+                return PLACEHOLDER
+
+            self.recomputed_values[node] = result
+            return result
 
     def visit_Slice(self, node: ast.Slice) -> Union[slice, Placeholder]:
         """Visit ``lower``, ``upper`` and ``step`` and recompute the node as a ``slice``."""
@@ -698,15 +699,17 @@ def visit_Slice(self, node: ast.Slice) -> Union[slice, Placeholder]:
         self.recomputed_values[node] = result
         return result
 
-    def visit_ExtSlice(self, node: ast.ExtSlice) -> Union[Tuple[Any, ...], Placeholder]:
-        """Visit each dimension of the advanced slicing and assemble the dimensions in a tuple."""
-        result = tuple(self.visit(node=dim) for dim in node.dims)
+    if sys.version_info < (3, 9):
 
-        if any(value is PLACEHOLDER for value in result):
-            return PLACEHOLDER
+        def visit_ExtSlice(self, node: ast.ExtSlice) -> Union[Tuple[Any, ...], Placeholder]:
+            """Visit each dimension of the advanced slicing and assemble the dimensions in a tuple."""
+            result = tuple(self.visit(node=dim) for dim in node.dims)
 
-        self.recomputed_values[node] = result
-        return result
+            if any(value is PLACEHOLDER for value in result):
+                return PLACEHOLDER
+
+            self.recomputed_values[node] = result
+            return result
 
     def visit_Subscript(self, node: ast.Subscript) -> Any:
         """Visit the ``slice`` and a ``value`` and get the element."""
@@ -780,11 +783,10 @@ def _execute_comprehension(self, node: Union[ast.ListComp, ast.SetComp, ast.Gene
 
         args = [ast.arg(arg=name, annotation=None) for name in sorted(self._name_to_value.keys())]
 
-        if platform.python_version_tuple() < ('3', ):
-            raise NotImplementedError("Python versions below 3 not supported, got: {}".format(
-                platform.python_version()))
+        if sys.version_info < (3, ):
+            raise NotImplementedError("Python versions below 3 not supported, got: {}".format(sys.version_info))
 
-        if platform.python_version_tuple() < ('3', '8'):
+        if sys.version_info < (3, 8):
             func_def_node = ast.FunctionDef(
                 name="generator_expr",
                 args=ast.arguments(args=args, kwonlyargs=[], kw_defaults=[], defaults=[]),

setup.py

@@ -41,7 +41,9 @@
         'License :: OSI Approved :: MIT License',
         'Programming Language :: Python :: 3.6',
         'Programming Language :: Python :: 3.7',
-        'Programming Language :: Python :: 3.8'
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10'
         # yapf: enable
     ],
     license='License :: OSI Approved :: MIT License',
@@ -50,7 +52,7 @@
     install_requires=install_requires,
     extras_require={
         'dev': [
-            'mypy==0.910', 'pylint==2.9.6', 'yapf==0.20.2', 'tox>=3.0.0', 'pydocstyle>=2.1.1,<3', 'coverage>=4.5.1,<5',
+            'mypy==0.910', 'pylint==2.9.6', 'yapf==0.20.2', 'tox>=3.0.0', 'pydocstyle>=6.1.1,<7', 'coverage>=4.5.1,<5',
             'docutils>=0.14,<1', 'pygments>=2.2.0,<3', 'dpcontracts==0.6.0', 'tabulate>=0.8.7,<1',
             'py-cpuinfo>=5.0.0,<6', 'typeguard>=2,<3', 'astor==0.8.1', 'numpy>=1,<2'
         ] + (['deal==4.1.0'] if sys.version_info >= (3, 8) else []) + (['asyncstdlib==3.9.1']

tests/test_checkers.py

@@ -66,7 +66,8 @@ def some_func(x: int, y: int) -> None:
             type_error = error
 
         assert type_error is not None
-        self.assertEqual("some_func() takes 2 positional arguments but 3 were given", str(type_error))
+        self.assertRegex(
+            str(type_error), r"^([a-zA-Z_0-9<>.]+\.)?some_func\(\) takes 2 positional arguments but 3 were given$")
 
     def test_that_result_in_kwargs_raises_an_error(self) -> None:
         @icontract.ensure(lambda result: result > 0)

tests/test_inheritance_postcondition.py

@@ -3,6 +3,7 @@
 # pylint: disable=no-self-use
 
 import abc
+import sys
 import textwrap
 import unittest
 from typing import Optional  # pylint: disable=unused-import
@@ -478,7 +479,10 @@ class B(A):
             type_err = err
 
         self.assertIsNotNone(type_err)
-        self.assertEqual("Can't instantiate abstract class B with abstract methods func", str(type_err))
+        if sys.version_info < (3, 9):
+            self.assertEqual("Can't instantiate abstract class B with abstract methods func", str(type_err))
+        else:
+            self.assertEqual("Can't instantiate abstract class B with abstract method func", str(type_err))
 
 
 if __name__ == '__main__':

tests/test_inheritance_precondition.py

@@ -3,6 +3,7 @@
 # pylint: disable=no-self-use
 
 import abc
+import sys
 import textwrap
 import unittest
 from typing import Optional, Sequence, cast  # pylint: disable=unused-import
@@ -526,7 +527,10 @@ class B(A):
             type_err = err
 
         self.assertIsNotNone(type_err)
-        self.assertEqual("Can't instantiate abstract class B with abstract methods func", str(type_err))
+        if sys.version_info < (3, 9):
+            self.assertEqual("Can't instantiate abstract class B with abstract methods func", str(type_err))
+        else:
+            self.assertEqual("Can't instantiate abstract class B with abstract method func", str(type_err))
 
     def test_cant_weaken_base_function_without_preconditions(self) -> None:
         class A(icontract.DBC):

tests/test_precondition.py

@@ -9,7 +9,7 @@
 import textwrap
 import time
 import unittest
-from typing import Optional, Callable, Any  # pylint: disable=unused-import
+from typing import Optional  # pylint: disable=unused-import
 
 import icontract
 from icontract._globals import CallableT
@@ -611,7 +611,8 @@ def some_func() -> None:
             type_error = err
 
         self.assertIsNotNone(type_error)
-        self.assertEqual('some_func() takes 0 positional arguments but 1 was given', str(type_error))
+        self.assertRegex(
+            str(type_error), r'^([a-zA-Z_0-9<>.]+\.)?some_func\(\) takes 0 positional arguments but 1 was given$')
 
     def test_unexpected_keyword_argument(self) -> None:
         @icontract.require(lambda: True)
@@ -626,7 +627,8 @@ def some_func() -> None:
             type_error = err
 
         self.assertIsNotNone(type_error)
-        self.assertEqual("some_func() got an unexpected keyword argument 'x'", str(type_error))
+        self.assertRegex(
+            str(type_error), r"^([a-zA-Z_0-9<>.]+\.)?some_func\(\) got an unexpected keyword argument 'x'$")
 
 
 if __name__ == '__main__':