signalrcore 0.9.5__py3-none-any.whl → 0.9.6a2__py3-none-any.whl

signalrcore/helpers.py

@@ -1,8 +1,69 @@
 import logging
 import urllib.parse as parse
+import urllib
+import urllib.request
+import ssl
+from typing import Tuple
+import json
+
+
+class RequestHelpers:
+    @staticmethod
+    def post(
+            url: str,
+            headers: dict = {},
+            proxies: dict = {},
+            verify_ssl: bool = False) -> Tuple[int, dict]:
+        return RequestHelpers.request(
+            url,
+            "POST",
+            headers=headers,
+            proxies=proxies,
+            verify_ssl=verify_ssl
+        )
+
+    @staticmethod
+    def request(
+            url: str,
+            method: str,
+            headers: dict = {},
+            proxies: dict = {},
+            verify_ssl: bool = False) -> Tuple[int, dict]:
+        context = ssl.create_default_context()
+        if not verify_ssl:
+            context.check_hostname = False
+            context.verify_mode = ssl.CERT_NONE
+        headers.update({'Content-Type': 'application/json'})
+        proxy_handler = None
+
+        if len(proxies.keys()) > 0:
+            proxy_handler = urllib.request.ProxyHandler(proxies)
+
+        req = urllib.request.Request(
+            url,
+            method=method,
+            headers=headers)
+
+        opener = urllib.request.build_opener(proxy_handler)\
+            if proxy_handler is not None else\
+            urllib.request.urlopen
+
+        with opener(
+                req,
+                context=context) as response:
+            status_code = response.getcode()
+            response_body = response.read().decode('utf-8')
+
+            try:
+                json_data = json.loads(response_body)
+            except json.JSONDecodeError:
+                json_data = None
+
+            return status_code, json_data
 
 
 class Helpers:
+
     @staticmethod
     def configure_logger(level=logging.INFO, handler=None):
         logger = Helpers.get_logger()

signalrcore/hub/base_hub_connection.py

@@ -1,30 +1,23 @@
-from operator import inv
-import websocket
-import threading
-import requests
-import traceback
 import uuid
-import time
-import ssl
-from typing import Callable
+from typing import Callable, List, Union, Optional
 from signalrcore.messages.message_type import MessageType
 from signalrcore.messages.stream_invocation_message\
     import StreamInvocationMessage
-from signalrcore.messages.ping_message import PingMessage
-from .errors import UnAuthorizedHubError, HubError, HubConnectionError
+from .errors import HubConnectionError
 from signalrcore.helpers import Helpers
 from .handlers import StreamHandler, InvocationHandler
-from ..protocol.messagepack_protocol import MessagePackHubProtocol
 from ..transport.websockets.websocket_transport import WebsocketTransport
-from ..helpers import Helpers
 from ..subject import Subject
 from ..messages.invocation_message import InvocationMessage
+from collections import defaultdict
+
 
 class InvocationResult(object):
     def __init__(self, invocation_id) -> None:
         self.invocation_id = invocation_id
         self.message = None
 
+
 class BaseHubConnection(object):
     def __init__(
             self,
@@ -37,10 +30,12 @@ class BaseHubConnection(object):
         else:
             self.headers = headers
         self.logger = Helpers.get_logger()
-        self.handlers = []
-        self.stream_handlers = []
+        self.handlers = defaultdict(list)
+        self.stream_handlers = defaultdict(list)
+
         self._on_error = lambda error: self.logger.info(
             "on_error not defined {0}".format(error))
+
         self.transport = WebsocketTransport(
             url=url,
             protocol=protocol,
@@ -71,7 +66,7 @@ class BaseHubConnection(object):
         connection.on_open(lambda: print(
             "connection opened "))
         Args:
-            callback (function): funciton without params
+            callback (function): function without params
         """
         self.transport.on_open_callback(callback)
 
@@ -101,30 +96,57 @@ class BaseHubConnection(object):
         Args:
             event (string):  Event name
             callback_function (Function): callback function,
-                arguments will be binded
+                arguments will be bound
         """
         self.logger.debug("Handler registered started {0}".format(event))
-        self.handlers.append((event, callback_function))
+        self.handlers[event].append(callback_function)
+
+    def unsubscribe(self, event, callback_function: Callable):
+        """Removes a callback from the specified event
+        Args:
+            event (string): Event name
+            callback_function (Function): callback function,
+                arguments will be bound
+        """
+        self.logger.debug("Handler removed {0}".format(event))
+
+        self.handlers[event].remove(callback_function)
+
+        if len(self.handlers[event]) == 0:
+            del self.handlers[event]
+
+    def send(self, method, arguments, on_invocation=None, invocation_id=None)\
+            -> InvocationResult:
+        return self.invoke(method, arguments, on_invocation, invocation_id)
 
-    def send(self, method, arguments, on_invocation=None, invocation_id=str(uuid.uuid4())) -> InvocationResult:
-        """Sends a message
+    def invoke(
+            self,
+            method: str,
+            arguments: Union[List, Subject],
+            on_invocation: Optional[Callable] = None,
+            invocation_id: Optional[str] = None)\
+            -> InvocationResult:
+        """invokes a server function
 
         Args:
             method (string): Method name
             arguments (list|Subject): Method parameters
             on_invocation (function, optional): On invocation send callback
                 will be raised on send server function ends. Defaults to None.
-            invocation_id (string, optional): Override invocation ID. Exceptions
-                thrown by the hub will use this ID, making it easier to handle
-                with the on_error call.
+            invocation_id (string, optional): Override invocation ID.
+                Exceptions thrown by the hub will use this ID,
+                making it easier to handle with the on_error call.
 
         Raises:
             HubConnectionError: If hub is not ready to send
             TypeError: If arguments are invalid list or Subject
         """
+        if invocation_id is None:
+            invocation_id = str(uuid.uuid4())
+
         if not self.transport.is_running():
             raise HubConnectionError(
-                "Hub is not running you cand send messages")
+                "Cannot connect to SignalR hub. Unable to transmit messages")
 
         if type(arguments) is not list and type(arguments) is not Subject:
             raise TypeError("Arguments of a message must be a list or subject")
@@ -139,25 +161,23 @@ class BaseHubConnection(object):
                 headers=self.headers)
 
             if on_invocation:
-                self.stream_handlers.append(
+                self.stream_handlers[message.invocation_id].append(
                     InvocationHandler(
                         message.invocation_id,
                         on_invocation))
-            
+
             self.transport.send(message)
             result.message = message
-        
+
         if type(arguments) is Subject:
             arguments.connection = self
             arguments.target = method
             arguments.start()
             result.invocation_id = arguments.invocation_id
             result.message = arguments
-        
 
         return result
 
-
     def on_message(self, messages):
         for message in messages:
             if message.type == MessageType.invocation_binding_failure:
@@ -169,13 +189,14 @@ class BaseHubConnection(object):
                 continue
 
             if message.type == MessageType.invocation:
-                fired_handlers = list(
-                    filter(
-                        lambda h: h[0] == message.target,
-                        self.handlers))
+
+                fired_handlers = self.handlers.get(message.target, [])
+
                 if len(fired_handlers) == 0:
-                    self.logger.debug(f"event '{message.target}' hasn't fired any handler")
-                for _, handler in fired_handlers:
+                    self.logger.debug(
+                        f"event '{message.target}' hasn't fired any handler")
+
+                for handler in fired_handlers:
                     handler(message.arguments)
 
             if message.type == MessageType.close:
@@ -188,30 +209,26 @@ class BaseHubConnection(object):
                     self._on_error(message)
 
                 # Send callbacks
-                fired_handlers = list(
-                    filter(
-                        lambda h: h.invocation_id == message.invocation_id,
-                        self.stream_handlers))
+                fired_handlers = self.stream_handlers.get(
+                    message.invocation_id, [])
 
                 # Stream callbacks
                 for handler in fired_handlers:
                     handler.complete_callback(message)
 
                 # unregister handler
-                self.stream_handlers = list(
-                    filter(
-                        lambda h: h.invocation_id != message.invocation_id,
-                        self.stream_handlers))
+                if message.invocation_id in self.stream_handlers:
+                    del self.stream_handlers[message.invocation_id]
 
             if message.type == MessageType.stream_item:
-                fired_handlers = list(
-                    filter(
-                        lambda h: h.invocation_id == message.invocation_id,
-                        self.stream_handlers))
+                fired_handlers = self.stream_handlers.get(
+                    message.invocation_id, [])
+
                 if len(fired_handlers) == 0:
                     self.logger.warning(
                         "id '{0}' hasn't fire any stream handler".format(
                             message.invocation_id))
+
                 for handler in fired_handlers:
                     handler.next_callback(message.item)
 
@@ -219,10 +236,9 @@ class BaseHubConnection(object):
                 pass
 
             if message.type == MessageType.cancel_invocation:
-                fired_handlers = list(
-                    filter(
-                        lambda h: h.invocation_id == message.invocation_id,
-                        self.stream_handlers))
+                fired_handlers = self.stream_handlers.get(
+                    message.invocation_id, [])
+
                 if len(fired_handlers) == 0:
                     self.logger.warning(
                         "id '{0}' hasn't fire any stream handler".format(
@@ -232,10 +248,8 @@ class BaseHubConnection(object):
                     handler.error_callback(message)
 
                 # unregister handler
-                self.stream_handlers = list(
-                    filter(
-                        lambda h: h.invocation_id != message.invocation_id,
-                        self.stream_handlers))
+                if message.invocation_id in self.stream_handlers:
+                    del self.stream_handlers[message.invocation_id]
 
     def stream(self, event, event_params):
         """Starts server streaming
@@ -256,11 +270,11 @@ class BaseHubConnection(object):
         """
         invocation_id = str(uuid.uuid4())
         stream_obj = StreamHandler(event, invocation_id)
-        self.stream_handlers.append(stream_obj)
+        self.stream_handlers[invocation_id].append(stream_obj)
         self.transport.send(
             StreamInvocationMessage(
                 invocation_id,
                 event,
                 event_params,
                 headers=self.headers))
-        return stream_obj
+        return stream_obj

signalrcore/hub/errors.py

@@ -1,9 +1,11 @@
 class HubError(OSError):
     pass
 
+
 class UnAuthorizedHubError(HubError):
     pass
 
+
 class HubConnectionError(ValueError):
     """Hub connection error
     """

signalrcore/hub/handlers.py

@@ -1,7 +1,7 @@
-import logging
-
 from typing import Callable
 from ..helpers import Helpers
+
+
 class StreamHandler(object):
     def __init__(self, event: str, invocation_id: str):
         self.event = event

signalrcore/hub_connection_builder.py

@@ -1,12 +1,9 @@
-import uuid
 from .hub.base_hub_connection import BaseHubConnection
 from .hub.auth_hub_connection import AuthHubConnection
 from .transport.websockets.reconnection import \
     IntervalReconnectionHandler, RawReconnectionHandler, ReconnectionType
 from .helpers import Helpers
-from .messages.invocation_message import InvocationMessage
 from .protocol.json_hub_protocol import JsonHubProtocol
-from .subject import Subject
 
 
 class HubConnectionBuilder(object):
@@ -37,6 +34,7 @@ class HubConnectionBuilder(object):
         self.enable_trace = False  # socket trace
         self.skip_negotiation = False  # By default do not skip negotiation
         self.running = False
+        self.proxies = dict()
 
     def with_url(
             self,
@@ -85,7 +83,7 @@ class HubConnectionBuilder(object):
         if hub_url is None or hub_url.strip() == "":
             raise ValueError("hub_url must be a valid url.")
 
-        if options is not None and type(options) != dict:
+        if options is not None and type(options) is not dict:
             raise TypeError(
                 "options must be a dict {0}.".format(self.options))
 
@@ -127,6 +125,28 @@ class HubConnectionBuilder(object):
         self.enable_trace = socket_trace
         return self
 
+    def configure_proxies(
+            self,
+            proxies: dict):
+        """configures proxies
+
+        Args:
+            proxies (dict): {
+              "http"  : "http://host:port",
+              "https" : "https://host:port",
+              "ftp"   : "ftp://port:port"
+            }
+
+        Returns:
+            [HubConnectionBuilder]: Instance hub with proxies configured
+        """
+
+        if "http" not in proxies.keys() or "https" not in proxies.keys():
+            raise ValueError("Only http and https keys are allowed")
+
+        self.proxies = proxies
+        return self
+
     def with_hub_protocol(self, protocol):
         """Changes transport protocol
             from signalrcore.protocol.messagepack_protocol\
@@ -182,6 +202,7 @@ class HubConnectionBuilder(object):
                 keep_alive_interval=self.keep_alive_interval,
                 reconnection_handler=self.reconnection_handler,
                 verify_ssl=self.verify_ssl,
+                proxies=self.proxies,
                 skip_negotiation=self.skip_negotiation,
                 enable_trace=self.enable_trace)\
             if self.has_auth_configured else\
@@ -192,9 +213,10 @@ class HubConnectionBuilder(object):
                 reconnection_handler=self.reconnection_handler,
                 headers=self.headers,
                 verify_ssl=self.verify_ssl,
+                proxies=self.proxies,
                 skip_negotiation=self.skip_negotiation,
                 enable_trace=self.enable_trace)
-            
+
     def with_automatic_reconnect(self, data: dict):
         """Configures automatic reconnection
             https://devblogs.microsoft.com/aspnet/asp-net-core-updates-in-net-core-3-0-preview-4/

signalrcore/protocol/base_hub_protocol.py

@@ -10,7 +10,7 @@ from ..messages.cancel_invocation_message import CancelInvocationMessage  # 5
 from ..messages.ping_message import PingMessage  # 6
 from ..messages.close_message import CloseMessage  # 7
 from ..messages.message_type import MessageType
-from ..helpers import Helpers
+
 
 class BaseHubProtocol(object):
     def __init__(self, protocol, version, transfer_format, record_separator):
@@ -21,9 +21,10 @@ class BaseHubProtocol(object):
 
     @staticmethod
     def get_message(dict_message):
-        message_type =  MessageType.close\
-            if not "type" in dict_message.keys() else MessageType(dict_message["type"])
-        
+        message_type = MessageType.close\
+            if "type" not in dict_message.keys() else\
+            MessageType(dict_message["type"])
+
         dict_message["invocation_id"] = dict_message.get("invocationId", None)
         dict_message["headers"] = dict_message.get("headers", {})
         dict_message["error"] = dict_message.get("error", None)
@@ -45,10 +46,13 @@ class BaseHubProtocol(object):
 
     def decode_handshake(self, raw_message: str) -> HandshakeResponseMessage:
         messages = raw_message.split(self.record_separator)
-        messages = list(filter(lambda x: x != "", messages))        
+        messages = list(filter(lambda x: x != "", messages))
         data = json.loads(messages[0])
         idx = raw_message.index(self.record_separator)
-        return HandshakeResponseMessage(data.get("error", None)), self.parse_messages(raw_message[idx + 1 :]) if len(messages) > 1 else []
+        return (
+            HandshakeResponseMessage(data.get("error", None)),
+            self.parse_messages(raw_message[idx + 1:])
+            if len(messages) > 1 else [])
 
     def handshake_message(self) -> HandshakeRequestMessage:
         return HandshakeRequestMessage(self.protocol, self.version)

signalrcore/protocol/messagepack_protocol.py

@@ -37,30 +37,47 @@ class MessagePackHubProtocol(BaseHubProtocol):
         try:
             messages = []
             offset = 0
+            max_length_prefix_size = 5
+            num_bits_to_shift = [0, 7, 14, 21, 28]
             while offset < len(raw):
-                length = msgpack.unpackb(raw[offset: offset + 1])
-                values = msgpack.unpackb(raw[offset + 1: offset + length + 1])
-                offset = offset + length + 1
+                length = 0
+                num_bytes = 0
+                while True:
+                    byte_read = raw[offset + num_bytes]
+                    length |=\
+                        (byte_read & 0x7F) << num_bits_to_shift[num_bytes]
+                    num_bytes += 1
+                    if byte_read & 0x80 == 0:
+                        break
+                    if offset == max_length_prefix_size\
+                            or offset + num_bytes > len(raw):
+                        raise Exception("Cannot read message length")
+                offset = offset + num_bytes
+                values = msgpack.unpackb(raw[offset: offset + length])
+                offset = offset + length
                 message = self._decode_message(values)
                 messages.append(message)
         except Exception as ex:
-            Helpers.get_logger().error("Parse messages Error {0}".format(ex))
-            Helpers.get_logger().error("raw msg '{0}'".format(raw))
+            self.logger.error("Parse messages Error {0}".format(ex))
+            self.logger.error("raw msg '{0}'".format(raw))
         return messages
 
     def decode_handshake(self, raw_message):
         try:
             has_various_messages = 0x1E in raw_message
-            handshake_data = raw_message[0: raw_message.index(0x1E)] if has_various_messages else raw_message
-            messages = self.parse_messages(raw_message[raw_message.index(0x1E) + 1:]) if has_various_messages else []
+            handshake_data = raw_message[0: raw_message.index(0x1E)]\
+                if has_various_messages else raw_message
+            messages = self.parse_messages(
+                raw_message[raw_message.index(0x1E) + 1:])\
+                if has_various_messages else []
             data = json.loads(handshake_data)
             return HandshakeResponseMessage(data.get("error", None)), messages
         except Exception as ex:
             if type(raw_message) is str:
                 data = json.loads(raw_message[0: raw_message.index("}") + 1])
                 return HandshakeResponseMessage(data.get("error", None)), []
-            Helpers.get_logger().error(raw_message)
-            Helpers.get_logger().error(ex)
+            self.logger.error(raw_message)
+            self.logger.error(ex)
             raise ex
 
     def encode(self, message):

signalrcore/transport/base_transport.py

@@ -1,32 +1,34 @@
 from ..protocol.json_hub_protocol import JsonHubProtocol
 from ..helpers import Helpers
 
+
 class BaseTransport(object):
     def __init__(self, protocol=JsonHubProtocol(), on_message=None):
         self.protocol = protocol
-        self._on_message= on_message
+        self._on_message = on_message
         self.logger = Helpers.get_logger()
         self._on_open = lambda: self.logger.info("on_connect not defined")
         self._on_close = lambda: self.logger.info("on_disconnect not defined")
-        self._on_reconnect = lambda: self.logger.info("on_reconnect not defined")
+        self._on_reconnect =\
+            lambda: self.logger.info("on_reconnect not defined")
 
     def on_open_callback(self, callback):
         self._on_open = callback
-    
+
     def on_close_callback(self, callback):
         self._on_close = callback
 
     def on_reconnect_callback(self, callback):
         self._on_reconnect = callback
 
-    def start(self): # pragma: no cover
+    def start(self):  # pragma: no cover
         raise NotImplementedError()
 
-    def stop(self): # pragma: no cover
+    def stop(self):  # pragma: no cover
         raise NotImplementedError()
-    
-    def is_running(self): # pragma: no cover
+
+    def is_running(self):  # pragma: no cover
         raise NotImplementedError()
 
-    def send(self, message, on_invocation = None): # pragma: no cover
-        raise NotImplementedError()
+    def send(self, message, on_invocation=None):  # pragma: no cover
+        raise NotImplementedError()