fix types and rename class

Author: mosquito

wsrpc_aiohttp/websocket/abc.py

@@ -1,8 +1,5 @@
 import asyncio
-from abc import (
-    ABC, abstractmethod, abstractclassmethod, abstractproperty,
-    abstractstaticmethod
-)
+from abc import ABC, abstractmethod
 from enum import IntEnum
 from typing import Any, Mapping, Coroutine, Union, Callable, Dict, Tuple
 
@@ -16,7 +13,8 @@ class AbstractWebSocket(ABC):
     def __init__(self, request: Request):
         raise NotImplementedError(request)
 
-    @abstractclassmethod
+    @classmethod
+    @abstractmethod
     def configure(cls, keepalive_timeout: int,
                   client_timeout: int,
                   max_concurrent_requests: int) -> None:
@@ -55,7 +53,8 @@ async def authorize(self) -> bool:
     async def __handle_request(self) -> WebSocketResponse:
         raise NotImplementedError
 
-    @abstractclassmethod
+    @classmethod
+    @abstractmethod
     def broadcast(
         cls, func, callback=None, return_exceptions=True,
         **kwargs: Mapping[str, Any]
@@ -115,7 +114,7 @@ def __getattr__(self, item: str):
 EventListenerType = Callable[[Dict[str, Any]], Any]
 
 
-class AbstactWSRPC(ABC):
+class WSRPCBase(ABC):
     @abstractmethod
     def __init__(self, loop: asyncio.AbstractEventLoop = None,
                  timeout: Union[int, float] = None):
@@ -138,28 +137,31 @@ async def handle_message(self, message: WSMessage):
     async def _on_message(self, msg: WSMessage):
         raise NotImplementedError
 
-    @abstractclassmethod
+    @classmethod
+    @abstractmethod
     def get_routes(cls) -> Mapping[str, "RouteType"]:
         raise NotImplementedError
 
     @classmethod
-    def get_clients(cls) -> Dict[str, "AbstactWSRPC"]:
+    def get_clients(cls) -> Dict[str, "AbstractWSRPC"]:
         raise NotImplementedError
 
-    @abstractproperty
+    @property
+    @abstractmethod
     def routes(self) -> Dict[str, "RouteType"]:
         raise NotImplementedError
 
     @property
-    def clients(self) -> Dict[str, "AbstactWSRPC"]:
+    def clients(self) -> Dict[str, "AbstractWSRPC"]:
         """ Property which contains the socket clients """
         raise NotImplementedError
 
     @abstractmethod
     def prepare_args(self, args) -> Tuple[Tuple[Any, ...], Dict[str, Any]]:
         raise NotImplementedError
 
-    @abstractstaticmethod
+    @staticmethod
+    @abstractmethod
     def is_route(func) -> bool:
         raise NotImplementedError
 
@@ -217,30 +219,6 @@ async def make_something(self, foo, bar):
     async def emit(self, event: Any) -> None:
         pass
 
-    @abstractclassmethod
-    def add_route(cls, route: str,
-                  handler: Union[AbstractRoute, Callable]) -> None:
-        """ Expose local function through RPC
-
-        :param route: Name which function will be aliased for this function.
-                      Remote side should call function by this name.
-        :param handler: Function or Route class (classes based on
-                        :class:`wsrpc_aiohttp.WebSocketRoute`).
-                        For route classes the public methods will
-                        be registered automatically.
-
-        .. note::
-
-            Route classes might be initialized only once for the each
-            socket instance.
-
-            In case the method of class will be called first,
-            :func:`wsrpc_aiohttp.WebSocketRoute.init` will be called
-            without params before callable method.
-
-        """
-        raise NotImplementedError
-
     @abstractmethod
     def add_event_listener(self, func: EventListenerType) -> None:
         raise NotImplementedError
@@ -255,7 +233,8 @@ def remove_route(cls, route: str, fail=True):
 
         raise NotImplementedError
 
-    @abstractproperty
+    @property
+    @abstractmethod
     def proxy(self) -> Proxy:
         """ Special property which allow run the remote functions
         by `dot` notation
@@ -272,8 +251,39 @@ def proxy(self) -> Proxy:
 
 
 RouteType = Union[
-    Callable[[AbstactWSRPC, Any], Any],
-    Callable[[AbstactWSRPC, Any], Coroutine[Any, None, Any]],
+    Callable[[WSRPCBase, Any], Any],
+    Callable[[WSRPCBase, Any], Coroutine[Any, None, Any]],
     AbstractRoute
 ]
+
+
+class AbstractWSRPC(WSRPCBase, ABC):
+    @classmethod
+    @abstractmethod
+    def add_route(cls, route: str, handler: RouteType) -> None:
+        """ Expose local function through RPC
+
+        :param route: Name which function will be aliased for this function.
+                      Remote side should call function by this name.
+        :param handler: Function or Route class (classes based on
+                        :class:`wsrpc_aiohttp.WebSocketRoute`).
+                        For route classes the public methods will
+                        be registered automatically.
+
+        .. note::
+
+            Route classes might be initialized only once for each
+            socket instance.
+
+            In case the method of class will be called first,
+            :func:`wsrpc_aiohttp.WebSocketRoute.init` will be called
+            without params before callable method.
+
+        """
+        raise NotImplementedError
+
+
+# backward compatibility for typo
+# noinspection SpellCheckingInspection
+AbstactWSRPC = AbstractWSRPC
 FrameMappingItemType = Mapping[IntEnum, Callable[[WSMessage], Any]]

wsrpc_aiohttp/websocket/common.py

@@ -10,7 +10,7 @@
 
 from . import decorators
 from .abc import (
-    Proxy, AbstactWSRPC, FrameMappingItemType, RouteType, EventListenerType
+    Proxy, AbstractWSRPC, FrameMappingItemType, RouteType, EventListenerType
 )
 from .route import Route
 from .tools import Singleton, awaitable, loads
@@ -59,10 +59,10 @@ def __repr__(self):
 
 
 RouteCollectionType = t.DefaultDict[
-    t.Type[AbstactWSRPC], t.Dict[str, RouteType]
+    t.Type[AbstractWSRPC], t.Dict[str, RouteType]
 ]
 ClientCollectionType = t.DefaultDict[
-    t.Type[AbstactWSRPC], t.Dict[str, AbstactWSRPC]
+    t.Type[AbstractWSRPC], t.Dict[str, AbstractWSRPC]
 ]
 LocksCollectionType = t.DefaultDict[int, asyncio.Lock]
 FutureCollectionType = t.DefaultDict[int, asyncio.Future]
@@ -73,7 +73,7 @@ def _route_maker() -> t.Dict[str, RouteType]:
     return {"ping": ping}   # type: ignore
 
 
-class WSRPCBase(AbstactWSRPC):
+class WSRPCBase(AbstractWSRPC):
     """ Common WSRPC abstraction """
 
     _ROUTES = defaultdict(_route_maker)       # type: RouteCollectionType
@@ -249,7 +249,7 @@ def get_routes(cls) -> t.Dict[str, RouteType]:
         return cls._ROUTES[cls]
 
     @classmethod
-    def get_clients(cls) -> t.Dict[str, AbstactWSRPC]:
+    def get_clients(cls) -> t.Dict[str, AbstractWSRPC]:
         return cls._CLIENTS[cls]
 
     @property
@@ -258,7 +258,7 @@ def routes(self) -> t.Dict[str, RouteType]:
         return self.get_routes()
 
     @property
-    def clients(self) -> t.Dict[str, AbstactWSRPC]:
+    def clients(self) -> t.Dict[str, AbstractWSRPC]:
         """ Property which contains the socket clients """
         return self.get_clients()
 
@@ -451,7 +451,7 @@ async def emit(self, event):
         await self._send(**event)
 
     @classmethod
-    def add_route(cls, route: str, handler: RouteType):
+    def add_route(cls, route: str, handler: RouteType) -> None:
         """ Expose local function through RPC
 
         :param route: Name which function will be aliased for this function.

wsrpc_aiohttp/websocket/route.py

@@ -63,7 +63,7 @@ class RouteBase(AbstractRoute, metaclass=RouteMeta):
     def __init__(self, socket: AbstractWebSocket):
         super().__init__(socket)
         self.__socket = socket
-        self.__loop = getattr(self.socket, "_loop", None)
+        self.__loop = getattr(self.socket, "_loop") or asyncio.get_event_loop()
 
         if self.__loop is None:
             self.__loop = asyncio.get_event_loop()