Require Python 3.6 or newer, use f-strings and variable type annotation syntax

.travis.yml

@@ -2,9 +2,9 @@ dist: xenial
 language: python
 conditions: v1
 python:
-- 3.5
 - 3.6
 - 3.7
+- 3.8-dev
 - pypy3
 # blocklist branches
 branches:

pytest.ini

@@ -1,2 +1,4 @@
 [pytest]
 testpaths = tests/
+filterwarnings = error
+xfail_strict = True

setup.py

@@ -34,7 +34,6 @@
 tests_require = (
     'pytest==5.0.1',  # tests framework used
     'pytest-cov==2.7.1',  # coverage reports to verify tests quality
-    'mock==3.0.5',  # tests mocking tool
     'python-daemon==2.2.3',  # used in test for easy creation of daemons
 )
 extras_require = {
@@ -64,7 +63,7 @@ def read(fname):
     author='Clearcode - The A Room',
     author_email='thearoom@clearcode.cc',
     license='LGPL',
-    python_requires='>=3.5',
+    python_requires='>=3.6',
     classifiers=[
         'Development Status :: 5 - Production/Stable',
         'Environment :: Web Environment',
@@ -75,7 +74,6 @@ def read(fname):
         'Operating System :: OS Independent',
         'Programming Language :: Python',
         'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.5',
         'Programming Language :: Python :: 3.6',
         'Programming Language :: Python :: 3.7',
         'Programming Language :: Python :: 3 :: Only',

src/mirakuru/base.py

@@ -151,11 +151,11 @@ def __init__(  # pylint:disable=too-many-arguments
         self._stdout = stdout
         self._stderr = stderr
 
-        self._endtime = None  # type: Optional[float]
-        self.process = None  # type: Optional[subprocess.Popen]
+        self._endtime: Optional[float] = None
+        self.process: Optional[subprocess.Popen] = None
         """A :class:`subprocess.Popen` instance once process is started."""
 
-        self._uuid = '{0}:{1}'.format(os.getpid(), uuid.uuid4())
+        self._uuid = f'{os.getpid()}:{uuid.uuid4()}'
 
     def __enter__(self: SimpleExecutorType) -> SimpleExecutorType:
         """
@@ -196,7 +196,7 @@ def _popen_kwargs(self) -> Dict[str, Any]:
 
         :return:
         """
-        kwargs = {}  # type: Dict[str, Any]
+        kwargs: Dict[str, Any] = {}
 
         if self._stdin:
             kwargs['stdin'] = self._stdin
@@ -239,8 +239,7 @@ def start(self: SimpleExecutorType) -> SimpleExecutorType:
         :rtype: SimpleExecutor
         """
         if self.process is None:
-            command = \
-                self.command  # type: Union[str, List[str], Tuple[str, ...]]
+            command: Union[str, List[str], Tuple[str, ...]] = self.command
             if not self._shell:
                 command = self.command_parts
 
@@ -446,20 +445,15 @@ def __repr__(self) -> str:
         command = self.command
         if len(command) > 10:
             command = command[:10] + '...'
-        return '<{module}.{executor}: "{command}" {id}>'.format(
-            module=self.__class__.__module__,
-            executor=self.__class__.__name__,
-            command=command,
-            id=hex(id(self))
-        )
+        module = self.__class__.__module__
+        executor = self.__class__.__name__
+        return f'<{module}.{executor}: "{command}" {hex(id(self))}>'
 
     def __str__(self) -> str:
         """Return readable executor representation."""
-        return '<{module}.{executor}: "{command}">'.format(
-            module=self.__class__.__module__,
-            executor=self.__class__.__name__,
-            command=self.command
-        )
+        module = self.__class__.__module__
+        executor = self.__class__.__name__
+        return f'<{module}.{executor}: "{self.command}" {hex(id(self))}>'
 
 
 class Executor(SimpleExecutor):

src/mirakuru/base_env.py

@@ -78,7 +78,7 @@ def processes_with_env_ps(env_name: str, env_value: str) -> Set[int]:
              environment variable equal certain value
     :rtype: set
     """
-    pids = set()  # type: Set[int]
+    pids: Set[int] = set()
     ps_xe = ''
     try:
         cmd = 'ps', 'xe', '-o', 'pid,cmd'
@@ -93,7 +93,7 @@ def processes_with_env_ps(env_name: str, env_value: str) -> Set[int]:
     except subprocess.CalledProcessError:
         log.error("`$ ps xe -o pid,cmd` command exited with non-zero code.")
 
-    env = '{0}={1}'.format(env_name, env_value)
+    env = f'{env_name}={env_value}'
 
     for line in ps_xe:
         line = str(line)

src/mirakuru/exceptions.py

@@ -43,8 +43,8 @@ def __str__(self) -> str:
         :returns: string representation
         :rtype: str
         """
-        return 'Executor {0} timed out after {1} seconds'.format(
-            self.executor, self.timeout
+        return (
+            f'Executor {self.executor} timed out after {self.timeout} seconds'
         )
 
 
@@ -63,11 +63,13 @@ def __str__(self) -> str:
         :returns: string representation
         :rtype: str
         """
-        return ("Executor {exc.executor} seems to be already running. "
-                "It looks like the previous executor process hasn't been "
-                "terminated or killed. Also there might be some completely "
-                "different service listening on {exc.executor.port} port."
-                .format(exc=self))
+        port = getattr(self.executor, 'port')
+        return (f"Executor {self.executor} seems to be already running. "
+                f"It looks like the previous executor process hasn't been "
+                f"terminated or killed."
+                + ("" if port is None else
+                   f" Also there might be some completely "
+                   f"different service listening on {port} port."))
 
 
 class ProcessExitedWithError(ExecutorError):
@@ -97,6 +99,5 @@ def __str__(self) -> str:
         :returns: string representation
         :rtype: str
         """
-        return ("The process invoked by the {exc.executor} executor has "
-                "exited with a non-zero code: {exc.exit_code}."
-                .format(exc=self))
+        return (f"The process invoked by the {self.executor} executor has "
+                f"exited with a non-zero code: {self.exit_code}.")

src/mirakuru/output.py

@@ -71,7 +71,7 @@ def start(self: OutputExecutorType) -> OutputExecutorType:
         """
         super(OutputExecutor, self).start()
 
-        polls = []  # type: List[Tuple[select.poll, IO[Any]]]
+        polls: List[Tuple[select.poll, IO[Any]]] = []
 
         for output_handle, output_method in (
                 (self._stdout, self.output),

tests/__init__.py

@@ -15,9 +15,7 @@
 TEST_SOCKET_SERVER_PATH = path.join(TEST_PATH, 'unixsocketserver_for_tests.py')
 SAMPLE_DAEMON_PATH = path.join(TEST_PATH, "sample_daemon.py")
 
-HTTP_SERVER_CMD = (
-    "{python} -m http.server"
-).format(python=sys.executable)
+HTTP_SERVER_CMD = f"{sys.executable} -m http.server"
 
 
 def ps_aux():

tests/executors/test_executor.py

@@ -5,9 +5,9 @@
 import signal
 from subprocess import check_output
 import uuid
+from unittest import mock
 
 import pytest
-import mock
 
 from mirakuru import Executor
 from mirakuru.base import SimpleExecutor
@@ -148,7 +148,7 @@ def test_forgotten_stop():
     # get substituted with 'sleep 300' and the marked commandline would be
     # overwritten.
     # Injecting some flow control (`&&`) forces bash to fork properly.
-    marked_command = 'sleep 300 && true #{0!s}'.format(mark)
+    marked_command = f'sleep 300 && true #{mark!s}'
     executor = SimpleExecutor(marked_command, shell=True)
     executor.start()
     assert executor.running() is True
@@ -168,7 +168,7 @@ def test_executor_raises_if_process_exits_with_error():
     """
     error_code = 12
     failing_executor = Executor(
-        ['bash', '-c', 'exit {0!s}'.format(error_code)],
+        ['bash', '-c', f'exit {error_code!s}'],
         timeout=5
     )
     failing_executor.pre_start_check = mock.Mock(  # type: ignore
@@ -181,7 +181,7 @@ def test_executor_raises_if_process_exits_with_error():
         failing_executor.start()
 
     assert exc.value.exit_code == 12
-    error_msg = 'exited with a non-zero code: {0!s}'.format(error_code)
+    error_msg = f'exited with a non-zero code: {error_code!s}'
     assert error_msg in str(exc.value)
 
     # Pre-start check should have been called - after-start check might or
@@ -228,14 +228,15 @@ def test_executor_methods_returning_self():
 
 def test_mirakuru_cleanup():
     """Test if cleanup_subprocesses is fired correctly on python exit."""
-    cmd = '''
+    cmd = f'''
         python -c 'from mirakuru import SimpleExecutor;
                    from time import sleep;
                    import gc;
                    gc.disable();
-                   ex = SimpleExecutor(("python", "{0}")).start();
+                   ex = SimpleExecutor(
+                       ("python", "{SAMPLE_DAEMON_PATH}")).start();
                    sleep(1);
                   '
-    '''.format(SAMPLE_DAEMON_PATH)
+    '''
     check_output(shlex.split(cmd.replace('\n', '')))
     assert SAMPLE_DAEMON_PATH not in ps_aux()

tests/executors/test_executor_kill.py

@@ -7,7 +7,8 @@
 import errno
 
 import os
-from mock import patch
+from unittest.mock import patch
+import pytest
 
 from mirakuru import SimpleExecutor, HTTPExecutor
 from mirakuru.compat import SIGKILL
@@ -49,6 +50,11 @@ def process_stopped():
     assert not executor.process
 
 
+@pytest.mark.xfail(
+    condition=sys.version_info >= (3, 8),
+    reason='python-daemon 2.2.3 fails with '
+    '<https://pagure.io/python-daemon/issue/34>; '
+    'unxfail when a newer version is used')
 def test_daemons_killing():
     """
     Test if all subprocesses of SimpleExecutor can be killed.
@@ -76,8 +82,8 @@ def test_stopping_brutally():
     by executor with SIGKILL automatically.
     """
     host_port = "127.0.0.1:8000"
-    cmd = '{0} {1} {2} True'.format(sys.executable, TEST_SERVER_PATH, host_port)
-    executor = HTTPExecutor(cmd, 'http://{0!s}/'.format(host_port), timeout=20)
+    cmd = f'{sys.executable} {TEST_SERVER_PATH} {host_port} True'
+    executor = HTTPExecutor(cmd, f'http://{host_port!s}/', timeout=20)
     executor.start()
     assert executor.running() is True