Mass backport from 3.4

* type hints

Signed-off-by: Aleksei Stepanov <penguinolog@gmail.com>

Author: penguinolog

.travis.yml

@@ -10,13 +10,13 @@ install:
 _python:
 - &python27
   name: "Python 2.7"
-  python: 2.7
+  python: "2.7"
 - &pypy
   name: "PyPy"
-  python: pypy
+  python: "pypy"
 - &python37
   name: "Python 3.7"
-  python: 3.7
+  python: "3.7"
   dist: xenial
   sudo: true
 
@@ -41,7 +41,6 @@ after_success:
 - coveralls
 
 jobs:
-  fast_finish: true
   include:
   - <<: *static_analysis
     name: "PyLint"

exec_helpers/_ssh_client_base.py

@@ -67,6 +67,7 @@ def __init__(
         super(RetryOnExceptions, self).__init__(lambda e: isinstance(e, retry_on) and not isinstance(e, reraise))
 
 
+# noinspection PyTypeHints
 class SshExecuteAsyncResult(api.ExecuteAsyncResult):
     """Override original NamedTuple with proper typing."""
 

exec_helpers/_subprocess_helpers.py

@@ -51,15 +51,15 @@ def safe_stop(proc, kill=False):  # type: (psutil.Process, bool) -> None
             pass
 
     parent = psutil.Process(pid)
-    children = parent.children(recursive=True)
+    children = parent.children(recursive=True)  # type: typing.List[psutil.Process]
     for child in children:  # type: psutil.Process
         safe_stop(child)  # SIGTERM to allow cleanup
-    _, alive = psutil.wait_procs(children, timeout=5)
-    for child in alive:  # type: psutil.Process
+    _, alive = psutil.wait_procs(children, timeout=1)
+    for child in alive:
         safe_stop(child, kill=True)  # 2nd shot: SIGKILL
     if including_parent:
         safe_stop(parent)  # SIGTERM to allow cleanup
-        _, alive = psutil.wait_procs((parent,), timeout=5)
+        _, alive = psutil.wait_procs((parent,), timeout=1)
         if alive:
             safe_stop(parent, kill=True)  # 2nd shot: SIGKILL
         parent.wait(5)

exec_helpers/api.py

@@ -115,32 +115,32 @@ def _mask_command(
         def mask(text, rules):  # type: (str, typing.Text) -> str
             """Mask part of text using rules."""
             indexes = [0]  # Start of the line
+            masked = ""
 
             # places to exclude
             for match in re.finditer(rules, text):
                 for idx, _ in enumerate(match.groups()):
                     indexes.extend(match.span(idx + 1))
             indexes.append(len(text))  # End
 
-            masked = ""
-
             # Replace inserts
             for idx in range(0, len(indexes) - 2, 2):
                 start = indexes[idx]
                 end = indexes[idx + 1]
                 masked += text[start:end] + "<*masked*>"
 
+            # noinspection PyPep8
             masked += text[indexes[-2] : indexes[-1]]  # final part
             return masked
 
-        cmd = cmd.rstrip()
+        result = cmd.rstrip()  # type: str
 
-        if self.log_mask_re:
-            cmd = mask(cmd, self.log_mask_re)
-        if log_mask_re:
-            cmd = mask(cmd, log_mask_re)
+        if self.log_mask_re is not None:
+            result = mask(result, self.log_mask_re)
+        if log_mask_re is not None:
+            result = mask(result, log_mask_re)
 
-        return cmd
+        return result
 
     @abc.abstractmethod
     def execute_async(
@@ -249,7 +249,7 @@ def execute(
 
         result = self._exec_command(
             command=command, async_result=async_result, timeout=timeout, verbose=verbose, **kwargs
-        )
+        )  # type: exec_result.ExecResult
         message = "Command {result.cmd!r} exit code: {result.exit_code!s}".format(result=result)
         self.logger.log(level=logging.INFO if verbose else logging.DEBUG, msg=message)  # type: ignore
         return result
@@ -315,18 +315,21 @@ def check_call(
         .. versionchanged:: 1.10.0 Expected is not optional, defaults os dependent
         """
         expected_codes = proc_enums.exit_codes_to_enums(expected)
-        ret = self.execute(command, verbose, timeout, **kwargs)
-        if ret.exit_code not in expected_codes:
+        result = self.execute(command, verbose, timeout, **kwargs)  # type: exec_result.ExecResult
+        if result.exit_code not in expected_codes:
             message = (
                 "{append}Command {result.cmd!r} returned exit code "
                 "{result.exit_code!s} while expected {expected!s}".format(
-                    append=error_info + "\n" if error_info else "", result=ret, expected=expected_codes
+                    append=error_info + "\n" if error_info else "", result=result, expected=expected_codes
                 )
             )
             self.logger.error(msg=message)
             if raise_on_err:
-                raise kwargs.get("exception_class", exceptions.CalledProcessError)(result=ret, expected=expected_codes)
-        return ret
+                raise kwargs.get("exception_class", exceptions.CalledProcessError)(
+                    result=result,
+                    expected=expected_codes
+                )
+        return result
 
     def check_stderr(
         self,
@@ -358,20 +361,21 @@ def check_stderr(
 
         .. versionchanged:: 1.2.0 default timeout 1 hour
         """
-        ret = self.check_call(
+        result = self.check_call(
             command, verbose, timeout=timeout, error_info=error_info, raise_on_err=raise_on_err, **kwargs
         )
-        if ret.stderr:
+        append = error_info + "\n" if error_info else ""  # type: str
+        if result.stderr:
             message = (
                 "{append}Command {result.cmd!r} output contains STDERR while not expected\n"
-                "\texit code: {result.exit_code!s}".format(append=error_info + "\n" if error_info else "", result=ret)
+                "\texit code: {result.exit_code!s}".format(append=append, result=result)
             )
             self.logger.error(msg=message)
             if raise_on_err:
                 raise kwargs.get("exception_class", exceptions.CalledProcessError)(
-                    result=ret, expected=kwargs.get("expected")
+                    result=result, expected=kwargs.get("expected")
                 )
-        return ret
+        return result
 
     @staticmethod
     def _string_bytes_bytearray_as_bytes(src):  # type: (typing.Union[six.text_type, bytes, bytearray]) -> bytes

exec_helpers/exec_result.py

@@ -85,10 +85,11 @@ def __init__(
 
         self.__cmd = cmd
         if isinstance(stdin, six.binary_type):
-            stdin = self._get_str_from_bin(bytearray(stdin))
+            self.__stdin = self._get_str_from_bin(bytearray(stdin))  # type: typing.Optional[typing.Text]
         elif isinstance(stdin, bytearray):
-            stdin = self._get_str_from_bin(stdin)
-        self.__stdin = stdin  # type: typing.Optional[typing.Text]
+            self.__stdin = self._get_str_from_bin(stdin)
+        else:
+            self.__stdin = stdin
 
         if stdout is not None:
             self._stdout = tuple(stdout)  # type: typing.Tuple[bytes, ...]
@@ -107,10 +108,10 @@ def __init__(
         self.__started = started  # type: typing.Optional[datetime.datetime]
 
         # By default is none:
-        self._stdout_str = None
-        self._stderr_str = None
-        self._stdout_brief = None
-        self._stderr_brief = None
+        self._stdout_str = None  # type: typing.Optional[typing.Text]
+        self._stderr_str = None  # type: typing.Optional[typing.Text]
+        self._stdout_brief = None  # type: typing.Optional[typing.Text]
+        self._stderr_brief = None  # type: typing.Optional[typing.Text]
 
     @property
     def stdout_lock(self):  # type: () -> threading.RLock
@@ -176,7 +177,7 @@ def _get_str_from_bin(src):  # type: (bytearray) -> typing.Text
         return src.strip().decode(encoding="utf-8", errors="backslashreplace")
 
     @classmethod
-    def _get_brief(cls, data):  # type: (typing.Tuple[bytes]) -> typing.Text
+    def _get_brief(cls, data):  # type: (typing.Tuple[bytes, ...]) -> typing.Text
         """Get brief output: 7 lines maximum (3 first + ... + 3 last).
 
         :param data: source to process
@@ -228,7 +229,7 @@ def _poll_stream(
         log=None,  # type: typing.Optional[logging.Logger]
         verbose=False,  # type: bool
     ):  # type: (...) -> typing.List[bytes]
-        dst = []
+        dst = []  # type: typing.List[bytes]
         try:
             for line in src:
                 dst.append(line)
@@ -323,8 +324,8 @@ def stdout_str(self):  # type: () -> typing.Text
         """
         with self.stdout_lock:
             if self._stdout_str is None:
-                self._stdout_str = self._get_str_from_bin(self.stdout_bin)  # type: ignore
-            return self._stdout_str  # type: ignore
+                self._stdout_str = self._get_str_from_bin(self.stdout_bin)
+            return self._stdout_str
 
     @property
     def stderr_str(self):  # type: () -> typing.Text
@@ -334,8 +335,8 @@ def stderr_str(self):  # type: () -> typing.Text
         """
         with self.stderr_lock:
             if self._stderr_str is None:
-                self._stderr_str = self._get_str_from_bin(self.stderr_bin)  # type: ignore
-            return self._stderr_str  # type: ignore
+                self._stderr_str = self._get_str_from_bin(self.stderr_bin)
+            return self._stderr_str
 
     @property
     def stdout_brief(self):  # type: () -> typing.Text
@@ -345,8 +346,8 @@ def stdout_brief(self):  # type: () -> typing.Text
         """
         with self.stdout_lock:
             if self._stdout_brief is None:
-                self._stdout_brief = self._get_brief(self.stdout)  # type: ignore
-            return self._stdout_brief  # type: ignore
+                self._stdout_brief = self._get_brief(self.stdout)
+            return self._stdout_brief
 
     @property
     def stderr_brief(self):  # type: () -> typing.Text
@@ -356,8 +357,8 @@ def stderr_brief(self):  # type: () -> typing.Text
         """
         with self.stderr_lock:
             if self._stderr_brief is None:
-                self._stderr_brief = self._get_brief(self.stderr)  # type: ignore
-            return self._stderr_brief  # type: ignore
+                self._stderr_brief = self._get_brief(self.stderr)
+            return self._stderr_brief
 
     @property
     def exit_code(self):  # type: () -> typing.Union[int, proc_enums.ExitCodes]
@@ -382,7 +383,7 @@ def exit_code(self, new_val):  # type: (typing.Union[int, proc_enums.ExitCodes])
         if self.timestamp:
             raise RuntimeError("Exit code is already received.")
         if not isinstance(new_val, (six.integer_types, proc_enums.ExitCodes)):
-            raise TypeError("Exit code is strictly int, got {!r}".format(new_val))
+            raise TypeError("Exit code is strictly int, received: {code!r}".format(code=new_val))
         with self.stdout_lock, self.stderr_lock:
             self.__exit_code = proc_enums.exit_code_to_enum(new_val)
             if self.__exit_code != proc_enums.INVALID:

exec_helpers/proc_enums.py

@@ -193,16 +193,17 @@ def __str__(self):  # type: () -> str
 def exit_code_to_enum(code):  # type: (typing.Union[int, ExitCodes]) -> typing.Union[int, ExitCodes]  # pragma: no cover
     """Convert exit code to enum if possible."""
     if "win32" == sys.platform:
-        return float(code)
-    if isinstance(code, int) and code in ExitCodes.__members__.values():
+        return digit_type(code)
+    if isinstance(code, six.integer_types) and code in ExitCodes.__members__.values():
         return ExitCodes(code)
     return code
 
 
 def exit_codes_to_enums(
     codes=None  # type: typing.Optional[typing.Iterable[typing.Union[int, ExitCodes]]]
-):  # type: (...) -> typing.Iterable[typing.Union[int, ExitCodes]]
+):  # type: (...) -> typing.Tuple[typing.Union[int, ExitCodes], ...]
     """Convert integer exit codes to enums."""
     if codes is None:
+        # noinspection PyRedundantParentheses
         return (EXPECTED,)
     return tuple(exit_code_to_enum(code) for code in codes)

exec_helpers/ssh_auth.py

@@ -72,7 +72,7 @@ def __init__(
         self.__username = username
         self.__password = password
         self.__key = key
-        self.__keys = [None]
+        self.__keys = [None]  # type: typing.List[typing.Union[None, paramiko.RSAKey]]
         if key is not None:
             # noinspection PyTypeChecker
             self.__keys.append(key)
@@ -161,7 +161,7 @@ def connect(
             if self.__passphrase is not None:
                 kwargs["passphrase"] = self.__passphrase
 
-        keys = [self.__key]
+        keys = [self.__key]  # type: typing.List[typing.Union[None, paramiko.RSAKey]]
         keys.extend([k for k in self.__keys if k != self.__key])
 
         for key in keys:
@@ -170,7 +170,7 @@ def connect(
                 client.connect(**kwargs)
                 if self.__key != key:
                     self.__key = key
-                    logger.debug("Main key has been updated, public key is: \n{}".format(self.public_key))
+                    logger.debug("Main key has been updated, public key is: \n%s", self.public_key)
                 return
             except paramiko.PasswordRequiredException:
                 if self.__password is None:

setup.py

@@ -151,12 +151,11 @@ def get_simple_vars_from_src(src):
 ]
 
 setup_args = dict(
-    name='exec-helpers',
-    author=variables['__author__'],
-    author_email=variables['__author_email__'],
-    maintainer=', '.join(
-        '{name} <{email}>'.format(name=name, email=email)
-        for name, email in variables['__maintainers__'].items()
+    name="exec-helpers",
+    author=variables["__author__"],
+    author_email=variables["__author_email__"],
+    maintainer=", ".join(
+        "{name} <{email}>".format(name=name, email=email) for name, email in variables["__maintainers__"].items()
     ),
     url=variables["__url__"],
     license=variables["__license__"],

test/test_ssh_client_init_special.py

@@ -101,7 +101,7 @@ def test_001_require_key(paramiko_ssh_client, auto_add_policy, ssh_auth_logger):
     auto_add_policy.assert_called_once()
 
     ssh_auth_logger.debug.assert_called_once_with(
-        "Main key has been updated, public key is: \n" "{}".format(ssh.auth.public_key)
+        "Main key has been updated, public key is: \n%s", ssh.auth.public_key
     )
 
     pkey = private_keys[0]
@@ -138,7 +138,7 @@ def test_002_use_next_key(paramiko_ssh_client, auto_add_policy, ssh_auth_logger)
     auto_add_policy.assert_called_once()
 
     ssh_auth_logger.debug.assert_called_once_with(
-        "Main key has been updated, public key is: \n" "{}".format(ssh.auth.public_key)
+        "Main key has been updated, public key is: \n%s", ssh.auth.public_key
     )
 
     kwargs = dict(hostname=host, pkey=None, port=port, username=username, password=None)
@@ -261,7 +261,7 @@ def test_009_auth_pass_no_key(paramiko_ssh_client, auto_add_policy, ssh_auth_log
     # Test
     ssh = exec_helpers.SSHClient(host=host, auth=exec_helpers.SSHAuth(username=username, password=password, key=key))
 
-    ssh_auth_logger.assert_has_calls((mock.call.debug("Main key has been updated, public key is: \nNone"),))
+    ssh_auth_logger.assert_has_calls((mock.call.debug("Main key has been updated, public key is: \n%s", None),))
 
     assert ssh.auth == exec_helpers.SSHAuth(username=username, password=password, keys=[key])