Make use of type aliases for backwards compatibility

Signed-off-by: Matteo Cafasso <noxdafox@gmail.com>

pebble/asynchronous/process.py

@@ -29,9 +29,7 @@
 
 
 @overload
-def process(
-        func: Callable[[common.P], common.T]
-) -> Callable[[common.P], asyncio.Future[common.T]]:
+def process(func: common.CallableType) -> common.AsyncIODecoratorReturnType:
     ...
 @overload
 def process(
@@ -40,8 +38,7 @@ def process(
         timeout: Optional[float] = None,
         mp_context: Optional[multiprocessing.context.BaseContext] = None,
         pool: Optional[ProcessPool] = None
-) -> Callable[[Callable[[common.P], common.T]],
-              Callable[[common.P], asyncio.Future[common.T]]]:
+) -> common.AsyncIODecoratorParamsReturnType:
     ...
 def process(*args, **kwargs):
     """Runs the decorated function in a concurrent process,

pebble/asynchronous/thread.py

@@ -24,17 +24,14 @@
 
 
 @overload
-def thread(
-        func: Callable[[common.P], common.T]
-) -> Callable[[common.P], asyncio.Future[common.T]]:
+def thread(func: common.CallableType) -> common.AsyncIODecoratorReturnType:
     ...
 @overload
 def thread(
         name: Optional[str] = None,
         daemon: bool = True,
         pool: Optional[ThreadPool] = None
-) -> Callable[[Callable[[common.P], common.T]],
-              Callable[[common.P], asyncio.Future[common.T]]]:
+) -> common.AsyncIODecoratorParamsReturnType:
     ...
 def thread(*args, **kwargs):
     """Runs the decorated function within a concurrent thread,

pebble/common/__init__.py

@@ -2,7 +2,13 @@
 from pebble.common.shared import decorate_function, get_asyncio_loop
 from pebble.common.types import ProcessExpired, ProcessFuture, PebbleFuture
 from pebble.common.types import Result, ResultStatus, RemoteException
-from pebble.common.types import FutureStatus, CONSTS, P, T
+from pebble.common.types import FutureStatus, CONSTS, CallableType
+from pebble.common.types import AsyncIODecoratorReturnType
+from pebble.common.types import AsyncIODecoratorParamsReturnType
+from pebble.common.types import ThreadDecoratorReturnType
+from pebble.common.types import ThreadDecoratorParamsReturnType
+from pebble.common.types import ProcessDecoratorReturnType
+from pebble.common.types import ProcessDecoratorParamsReturnType
 from pebble.common.process import launch_process, stop_process
 from pebble.common.process import register_function, maybe_install_trampoline
 from pebble.common.process import process_execute, send_result, function_handler

pebble/common/types.py

@@ -14,16 +14,24 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with Pebble.  If not, see <http://www.gnu.org/licenses/>.
 
-from typing import Any, TypeVar
+import asyncio
+
 from enum import Enum, IntEnum
 from dataclasses import dataclass
 from concurrent.futures import Future
+from typing import Any, TypeVar, Callable
 
 
 P = TypeVar("P")
 T = TypeVar("T")
 
 
+try:
+    FutureType = Future[T]
+except TypeError:
+    FutureType = Future
+
+
 class ProcessExpired(OSError):
     """Raised when process dies unexpectedly."""
     def __init__(self, msg, code=0, pid=None):
@@ -32,7 +40,7 @@ def __init__(self, msg, code=0, pid=None):
         self.pid = pid
 
 
-class PebbleFuture(Future):
+class PebbleFuture(FutureType):
     # Same as base class, removed logline
     def set_running_or_notify_cancel(self):
         """Mark the future as running or process any cancel notifications.
@@ -71,7 +79,13 @@ def set_running_or_notify_cancel(self):
                 raise RuntimeError('Future in unexpected state')
 
 
-class ProcessFuture(PebbleFuture):
+try:
+    PebbleFutureType = PebbleFuture[T]
+except TypeError:
+    PebbleFutureType = PebbleFuture
+
+
+class ProcessFuture(PebbleFutureType):
     def cancel(self):
         """Cancel the future.
 
@@ -167,4 +181,25 @@ class Consts:
     the amount of seconds to wait before issuing a SIGKILL signal."""
 
 
+try:
+    CallableType = Callable[[P], T]
+    AsyncIODecoratorReturnType = Callable[[P], asyncio.Future[T]]
+    AsyncIODecoratorParamsReturnType = Callable[[Callable[[P], T]],
+                                                Callable[[P], asyncio.Future[T]]]
+    ThreadDecoratorReturnType = Callable[[P], Future[T]]
+    ThreadDecoratorParamsReturnType = Callable[[Callable[[P], T]],
+                                               Callable[[P], Future[T]]]
+    ProcessDecoratorReturnType = Callable[[P], ProcessFuture[T]]
+    ProcessDecoratorParamsReturnType = Callable[[Callable[[P], T]],
+                                                Callable[[P], ProcessFuture[T]]]
+except TypeError:
+    ReturnType = Callable
+    AsyncIODecoratorReturnType = Callable
+    AsyncIODecoratorParamsReturnType = Callable
+    ThreadDecoratorReturnType = Callable
+    ThreadDecoratorParamsReturnType = Callable
+    ProcessDecoratorReturnType = Callable
+    ProcessDecoratorParamsReturnType = Callable
+
+
 CONSTS = Consts()

pebble/concurrent/process.py

@@ -29,9 +29,7 @@
 
 
 @overload
-def process(
-        func: Callable[[common.P], common.T]
-) -> Callable[[common.P], common.ProcessFuture[common.T]]:
+def process(func: common.CallableType) -> common.ProcessDecoratorReturnType:
     ...
 @overload
 def process(
@@ -40,8 +38,7 @@ def process(
         timeout: Optional[float] = None,
         mp_context: Optional[multiprocessing.context.BaseContext] = None,
         pool: Optional[ProcessPool] = None
-) -> Callable[[Callable[[common.P], common.T]],
-              Callable[[common.P], common.ProcessFuture[common.T]]]:
+) -> common.ProcessDecoratorParamsReturnType:
     ...
 def process(*args, **kwargs):
     """Runs the decorated function in a concurrent process,

pebble/concurrent/thread.py

@@ -16,23 +16,20 @@
 
 from functools import wraps
 from concurrent.futures import Future
-from typing import Callable, Optional, Union, overload
+from typing import Callable, Optional, overload
 
 from pebble import common
 from pebble.pool.thread import ThreadPool
 
 @overload
-def thread(
-        func: Callable[[common.P], common.T]
-) -> Callable[[common.P], Future[common.T]]:
+def thread(func: common.CallableType) -> common.ThreadDecoratorReturnType:
     ...
 @overload
 def thread(
         name: Optional[str] = None,
         daemon: bool = True,
         pool: Optional[ThreadPool] = None
-) -> Callable[[Callable[[common.P], common.T]],
-              Callable[[common.P], Future[common.T]]]:
+) -> common.ThreadDecoratorParamsReturnType:
     ...
 def thread(*args, **kwargs):
     """Runs the decorated function within a concurrent thread,