Drop support for EOL Python 2.7

Author: hugovk

atest/run.py

@@ -26,8 +26,7 @@
         sys.exit(rc)
     process_output(output, verbose=False)
 output = join(outdir, 'lib-DynamicTypesLibrary-python-%s-robot-%s.xml' % (python_version, rf_version))
-exclude = 'py3' if sys.version_info < (3,) else ''
-rc = run(tests_types, name='Types', output=output, report=None, log=None, loglevel='debug', exclude=exclude)
+rc = run(tests_types, name='Types', output=output, report=None, log=None, loglevel='debug')
 if rc > 250:
     sys.exit(rc)
 process_output(output, verbose=False)

src/robotlibcore.py

@@ -21,7 +21,6 @@
 
 import inspect
 import os
-import sys
 
 from robot.utils import PY_VERSION
 
@@ -33,7 +32,6 @@
 from robot.api.deco import keyword  # noqa F401
 from robot import __version__ as robot_version
 
-PY2 = sys.version_info < (3,)
 RF31 = robot_version < '3.2'
 
 __version__ = '2.2.2.dev1'
@@ -87,10 +85,7 @@ def __getattr__(self, name):
                              .format(type(self).__name__, name))
 
     def __dir__(self):
-        if PY2:
-            my_attrs = dir(type(self)) + list(self.__dict__)
-        else:
-            my_attrs = super().__dir__()
+        my_attrs = super().__dir__()
         return sorted(set(my_attrs) | set(self.attributes))
 
     def get_keyword_names(self):
@@ -172,8 +167,6 @@ def build(cls, function):
 
     @classmethod
     def unwrap(cls, function):
-        if PY2:
-            return function
         return inspect.unwrap(function)
 
     @classmethod
@@ -192,8 +185,6 @@ def _get_arguments(cls, function):
 
     @classmethod
     def _get_arg_spec(cls, function):
-        if PY2:
-            return inspect.getargspec(function)
         return inspect.getfullargspec(function)
 
     @classmethod
@@ -224,15 +215,11 @@ def _get_var_args(cls, arg_spec):
 
     @classmethod
     def _get_kwargs(cls, arg_spec):
-        if PY2:
-            return ['**%s' % arg_spec.keywords] if arg_spec.keywords else []
         return ['**%s' % arg_spec.varkw] if arg_spec.varkw else []
 
     @classmethod
     def _get_kw_only(cls, arg_spec):
         kw_only_args = []
-        if PY2:
-            return kw_only_args
         for arg in arg_spec.kwonlyargs:
             if not arg_spec.kwonlydefaults or arg not in arg_spec.kwonlydefaults:
                 kw_only_args.append(arg)
@@ -258,8 +245,6 @@ def _get_types(cls, function):
 
     @classmethod
     def _get_typing_hints(cls, function):
-        if PY2:
-            return {}
         function = cls.unwrap(function)
         try:
             hints = typing.get_type_hints(function)

utest/test_get_keyword_source.py

@@ -6,7 +6,6 @@
 
 from DynamicLibrary import DynamicLibrary
 from DynamicTypesLibrary import DynamicTypesLibrary
-from robotlibcore import PY2
 
 
 @pytest.fixture(scope='module')
@@ -49,7 +48,6 @@ def test_location_in_class(lib, lib_path_components):
     assert source == '%s:15' % lib_path_components
 
 
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_decorator_wrapper(lib_types, lib_path_types):
     source = lib_types.get_keyword_source('keyword_wrapped')
     assert source == '%s:72' % lib_path_types

utest/test_get_keyword_types.py

@@ -1,13 +1,11 @@
 import pytest
 
 
-from robotlibcore import PY2, RF31
-
-if not PY2:
-    from typing import List, Union, Dict
-    from DynamicTypesAnnotationsLibrary import DynamicTypesAnnotationsLibrary
-    from DynamicTypesAnnotationsLibrary import CustomObject
+from robotlibcore import RF31
 
+from typing import List, Union
+from DynamicTypesAnnotationsLibrary import DynamicTypesAnnotationsLibrary
+from DynamicTypesAnnotationsLibrary import CustomObject
 from DynamicTypesLibrary import DynamicTypesLibrary
 
 
@@ -70,44 +68,37 @@ def test_keyword_none_rf31(lib):
     assert types == {}
 
 
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_single_annotation(lib_types):
     types = lib_types.get_keyword_types('keyword_with_one_annotation')
     assert types == {'arg': str}
 
 
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_multiple_annotations(lib_types):
     types = lib_types.get_keyword_types('keyword_with_multiple_annotations')
     assert types == {'arg1': str, 'arg2': List}
 
 
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_multiple_types(lib_types):
     types = lib_types.get_keyword_types('keyword_multiple_types')
     assert types == {'arg': Union[List, None]}
 
 
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_keyword_new_type(lib_types):
     types = lib_types.get_keyword_types('keyword_new_type')
     assert len(types) == 1
     assert types['arg']
 
 
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_keyword_return_type(lib_types):
     types = lib_types.get_keyword_types('keyword_define_return_type')
     assert types == {'arg': str}
 
 
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_keyword_forward_references(lib_types):
     types = lib_types.get_keyword_types('keyword_forward_references')
     assert types == {'arg': CustomObject}
 
 
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_keyword_with_annotation_and_default(lib_types):
     types = lib_types.get_keyword_types('keyword_with_annotations_and_default')
     assert types == {'arg': str}
@@ -118,36 +109,30 @@ def test_keyword_with_many_defaults(lib):
     assert types == {}
 
 
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_keyword_with_annotation_external_class(lib_types):
     types = lib_types.get_keyword_types('keyword_with_webdriver')
     assert types == {'arg': CustomObject}
 
 
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_keyword_with_annotation_and_default(lib_types):
     types = lib_types.get_keyword_types('keyword_default_and_annotation')
     assert types == {'arg1': int, 'arg2': Union[bool, str]}
 
 
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_keyword_with_robot_types_and_annotations(lib_types):
     types = lib_types.get_keyword_types('keyword_robot_types_and_annotations')
     assert types == {'arg': str}
 
 
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_keyword_with_robot_types_disbaled_and_annotations(lib_types):
     types = lib_types.get_keyword_types('keyword_robot_types_disabled_and_annotations')
     assert types is None
 
 
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_keyword_with_robot_types_and_bool_annotations(lib_types):
     types = lib_types.get_keyword_types('keyword_robot_types_and_bool_hint')
     assert types == {'arg1': str}
 
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_init_args(lib_types):
     types = lib_types.get_keyword_types('__init__')
     assert types == {'arg': str}
@@ -163,85 +148,72 @@ def test_varargs(lib):
     assert types == {}
 
 
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_init_args_with_annotation(lib_types):
     types = lib_types.get_keyword_types('__init__')
     assert types == {'arg': str}
 
 
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_exception_in_annotations(lib_types):
     types = lib_types.get_keyword_types('keyword_exception_annotations')
     assert types == {'arg': 'NotHere'}
 
 
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_keyword_only_arguments(lib_types):
     types = lib_types.get_keyword_types('keyword_only_arguments')
     assert types == {}
 
 
 @pytest.mark.skipif(RF31, reason='Only for RF3.2+')
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_keyword_only_arguments_many(lib_types):
     types = lib_types.get_keyword_types('keyword_only_arguments_many')
     assert types == {}
 
 
 @pytest.mark.skipif(not RF31, reason='Only for RF3.1')
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_keyword_only_arguments_many(lib_types):
     types = lib_types.get_keyword_types('keyword_only_arguments_many')
     assert types == {}
 
 
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_keyword_mandatory_and_keyword_only_arguments(lib_types):
     types = lib_types.get_keyword_types('keyword_mandatory_and_keyword_only_arguments')
     assert types == {'arg': int, 'some': bool}
 
 
 @pytest.mark.skipif(RF31, reason='Only for RF3.2+')
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_keyword_only_arguments_many_positional_and_default_rf32(lib_types):
     types = lib_types.get_keyword_types('keyword_only_arguments_many_positional_and_default')
     assert types == {'four': Union[int, str], 'six': Union[bool, str]}
 
 
 @pytest.mark.skipif(not RF31, reason='Only for RF3.1')
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_keyword_only_arguments_many_positional_and_default_rf31(lib_types):
     types = lib_types.get_keyword_types('keyword_only_arguments_many_positional_and_default')
     assert types == {'four': Union[int, str], 'six': Union[bool, str]}
 
 
 @pytest.mark.skipif(RF31, reason='Only for RF3.2+')
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_keyword_all_args_rf32(lib_types):
     types = lib_types.get_keyword_types('keyword_all_args')
     assert types == {}
 
 
 @pytest.mark.skipif(not RF31, reason='Only for RF3.1')
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_keyword_all_args_rf31(lib_types):
     types = lib_types.get_keyword_types('keyword_all_args')
     assert types == {}
 
 
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_keyword_self_and_types(lib_types):
     types = lib_types.get_keyword_types('keyword_self_and_types')
     assert types == {'mandatory': str, 'other': bool}
 
 
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_keyword_self_and_keyword_only_types(lib_types):
     types = lib_types.get_keyword_types('keyword_self_and_keyword_only_types')
     assert types == {'varargs': int, 'other': bool, 'kwargs': int}
 
 
-@pytest.mark.skipif(PY2, reason='Only applicable on Python 3')
 def test_keyword_with_decorator_arguments(lib_types):
     types = lib_types.get_keyword_types('keyword_with_deco_and_signature')
     assert types == {'arg1': bool, 'arg2': bool}

utest/test_keyword_builder.py

@@ -1,10 +1,9 @@
 import pytest
 
-from robotlibcore import PY2, RF31, KeywordBuilder
+from robotlibcore import RF31, KeywordBuilder
 from moc_library import MockLibrary
-if not PY2:
-    from moc_library_py3 import MockLibraryPy3
-    from DynamicTypesAnnotationsLibrary import DynamicTypesAnnotationsLibrary
+from moc_library_py3 import MockLibraryPy3
+from DynamicTypesAnnotationsLibrary import DynamicTypesAnnotationsLibrary
 
 
 @pytest.fixture
@@ -68,20 +67,17 @@ def test_varargs_and_kwargs(lib):
     assert spec.argument_specification == ['*vargs', '**kwargs']
 
 
-@pytest.mark.skipif(PY2, reason='Only for Python 3')
 def test_named_only(lib_py3):
     spec = KeywordBuilder.build(lib_py3.named_only)
     assert spec.argument_specification == ['*varargs', 'key1', 'key2']
 
 
-@pytest.mark.skipif(PY2, reason='Only for Python 3')
 @pytest.mark.skipif(RF31, reason='Only for RF3.2+')
 def test_named_only_rf32(lib_py3):
     spec = KeywordBuilder.build(lib_py3.named_only_with_defaults)
     assert spec.argument_specification == ['*varargs', 'key1', 'key2', ('key3', 'default1'), ('key4', True)]
 
 
-@pytest.mark.skipif(PY2, reason='Only for Python 3')
 @pytest.mark.skipif(not RF31, reason='Only for RF3.1')
 def test_named_only_rf31(lib_py3):
     spec = KeywordBuilder.build(lib_py3.named_only_with_defaults)
@@ -98,25 +94,21 @@ def test_types_disabled_in_keyword_deco(lib):
     assert spec.argument_types is None
 
 
-@pytest.mark.skipif(PY2, reason='Only for Python 3')
 def test_types_(lib_py3):
     spec = KeywordBuilder.build(lib_py3.args_with_type_hints)
     assert spec.argument_types == {'arg3': str, 'arg4': type(None)}
 
 
-@pytest.mark.skipif(PY2, reason='Only for Python 3')
 def test_types(lib_py3):
     spec = KeywordBuilder.build(lib_py3.self_and_keyword_only_types)
     assert spec.argument_types == {'varargs': int, 'other': bool, 'kwargs': int}
 
 
-@pytest.mark.skipif(PY2, reason='Only for Python 3')
 def test_optional_none(lib_py3):
     spec = KeywordBuilder.build(lib_py3.optional_none)
     assert spec.argument_types == {'arg1': str, 'arg2': str}
 
 
-@pytest.mark.skipif(PY2, reason='Only for Python 3')
 @pytest.mark.skipif(RF31, reason='For RF 3.2')
 def test_complex_deco_rf32(dyn_types):
     spec = KeywordBuilder.build(dyn_types.keyword_with_deco_and_signature)
@@ -125,7 +117,6 @@ def test_complex_deco_rf32(dyn_types):
     assert spec.documentation == "Test me doc here"
 
 
-@pytest.mark.skipif(PY2, reason='Only for Python 3')
 @pytest.mark.skipif(not RF31, reason='For RF 3.2')
 def test_complex_deco_rf31(dyn_types):
     spec = KeywordBuilder.build(dyn_types.keyword_with_deco_and_signature)

utest/test_robotlibcore.py

@@ -1,13 +1,10 @@
-import sys
-
 import pytest
 from robot import __version__ as robot_version
 
-from robotlibcore import HybridCore, PY2
+from robotlibcore import HybridCore
 from HybridLibrary import HybridLibrary
 from DynamicLibrary import DynamicLibrary
-if not PY2:
-    from DynamicTypesAnnotationsLibrary import DynamicTypesAnnotationsLibrary
+from DynamicTypesAnnotationsLibrary import DynamicTypesAnnotationsLibrary
 
 
 @pytest.fixture(scope='module')
@@ -125,7 +122,6 @@ def test_get_keyword_arguments_rf32():
         args('__foobar__')
 
 
-@pytest.mark.skipif(PY2, reason='Only for Python 3')
 @pytest.mark.skipif(robot_version < '3.2', reason='For RF 3.2 or greater')
 def test_keyword_only_arguments_for_get_keyword_arguments_rf32():
     args = DynamicTypesAnnotationsLibrary(1).get_keyword_arguments
@@ -138,7 +134,6 @@ def test_keyword_only_arguments_for_get_keyword_arguments_rf32():
     assert args('keyword_with_deco_and_signature') == [('arg1', False), ('arg2', False)]
 
 
-@pytest.mark.skipif(PY2, reason='Only for Python 3')
 @pytest.mark.skipif(robot_version >= '3.2', reason='For RF 3.1')
 def test_keyword_only_arguments_for_get_keyword_arguments_rf31():
     args = DynamicTypesAnnotationsLibrary(1).get_keyword_arguments
@@ -176,13 +171,3 @@ def test_library_cannot_be_class():
         HybridCore([HybridLibrary])
     assert str(exc_info.value) == \
         "Libraries must be modules or instances, got class 'HybridLibrary' instead."
-
-
-@pytest.mark.skipif(sys.version_info[0] > 2, reason='Only applicable on Py 2')
-def test_library_cannot_be_old_style_class_instance():
-    class OldStyle:
-        pass
-    with pytest.raises(TypeError) as exc_info:
-        HybridCore([OldStyle()])
-    assert str(exc_info.value) == \
-           "Libraries must be modules or new-style class instances, got old-style class 'OldStyle' instead."