signalrcore 0.9.5__tar.gz → 0.9.6a2__tar.gz

{signalrcore-0.9.5/signalrcore.egg-info → signalrcore-0.9.6a2}/PKG-INFO

@@ -1,15 +1,16 @@
 Metadata-Version: 2.1
 Name: signalrcore
-Version: 0.9.5
-Summary: A Python SignalR Core client(json and messagepack), with invocation auth and two way streaming. Compatible with azure / serverless functions. Also with automatic reconnect and manually reconnect.
+Version: 0.9.6a2
+Summary: A Python SignalR Core client(json and messagepack),with invocation auth and two way streaming.Compatible with azure / serverless functions.Also with automatic reconnect and manually reconnect.
 Home-page: https://github.com/mandrewcito/signalrcore
 Author: mandrewcito
-Author-email: anbaalo@gmail.com
-License: UNKNOWN
+Author-email: signalrcore@mandrewcito.dev
 Keywords: signalr core client 3.1
-Platform: UNKNOWN
-Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.8
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
+Provides-Extra: dev
 License-File: LICENSE
 
 # SignalR core client
@@ -34,24 +35,16 @@ License-File: LICENSE
 
 # Develop
 
-Test server will be avaiable in [here](https://github.com/mandrewcito/signalrcore-containertestservers) and docker compose is required.
+Test server will be available in [here](https://github.com/mandrewcito/signalrcore-containertestservers) and docker compose is required.
 
 ```bash
 git clone https://github.com/mandrewcito/signalrcore-containertestservers
 cd signalrcore-containertestservers
-docker-compose up
+docker compose up
 cd ../signalrcore
 make tests
 ```
 
-## Known Issues
-
-Issues related with closing sockets are inherited from the websocket-client library. Due to these problems i can't update the library to versions higher than websocket-client 0.54.0. 
-I'm working to solve it but for now its patched (Error number 1. Raises an exception, and then exception is treated for prevent errors). 
-If I update the websocket library I fall into error number 2, on local machine I can't reproduce it but travis builds fail (sometimes and randomly :()
-* [1. Closing socket error](https://github.com/slackapi/python-slackclient/issues/171)
-* [2. Random errors closing socket](https://github.com/websocket-client/websocket-client/issues/449)
-
 # A Tiny How To
 
 ## Connect to a server without auth
@@ -159,7 +152,7 @@ connection = HubConnectionBuilder()\
             })\
             .build()
 ```
-## Congfiguring skip negotiation
+## Configuring skip negotiation
 ```python
 hub_connection = HubConnectionBuilder() \
         .with_url("ws://"+server_url, options={
@@ -330,5 +323,3 @@ hub_connection.stop()
 sys.exit(0)
 
 ```
-
-

{signalrcore-0.9.5 → signalrcore-0.9.6a2}/README.md

@@ -20,24 +20,16 @@
 
 # Develop
 
-Test server will be avaiable in [here](https://github.com/mandrewcito/signalrcore-containertestservers) and docker compose is required.
+Test server will be available in [here](https://github.com/mandrewcito/signalrcore-containertestservers) and docker compose is required.
 
 ```bash
 git clone https://github.com/mandrewcito/signalrcore-containertestservers
 cd signalrcore-containertestservers
-docker-compose up
+docker compose up
 cd ../signalrcore
 make tests
 ```
 
-## Known Issues
-
-Issues related with closing sockets are inherited from the websocket-client library. Due to these problems i can't update the library to versions higher than websocket-client 0.54.0. 
-I'm working to solve it but for now its patched (Error number 1. Raises an exception, and then exception is treated for prevent errors). 
-If I update the websocket library I fall into error number 2, on local machine I can't reproduce it but travis builds fail (sometimes and randomly :()
-* [1. Closing socket error](https://github.com/slackapi/python-slackclient/issues/171)
-* [2. Random errors closing socket](https://github.com/websocket-client/websocket-client/issues/449)
-
 # A Tiny How To
 
 ## Connect to a server without auth
@@ -145,7 +137,7 @@ connection = HubConnectionBuilder()\
             })\
             .build()
 ```
-## Congfiguring skip negotiation
+## Configuring skip negotiation
 ```python
 hub_connection = HubConnectionBuilder() \
         .with_url("ws://"+server_url, options={

signalrcore-0.9.6a2/setup.py

@@ -0,0 +1,38 @@
+import setuptools
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name="signalrcore",
+    version="0.9.6a2",
+    author="mandrewcito",
+    author_email="signalrcore@mandrewcito.dev",
+    description="A Python SignalR Core client(json and messagepack),"
+    "with invocation auth and two way streaming."
+    "Compatible with azure / serverless functions."
+    "Also with automatic reconnect and manually reconnect.",
+    keywords="signalr core client 3.1",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    license_file="LICENSE",
+    url="https://github.com/mandrewcito/signalrcore",
+    packages=setuptools.find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3.8",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent"
+    ],
+    install_requires=[
+        "msgpack==1.0.2"
+    ],
+    extras_require={
+        'dev': [
+            'requests',
+            'flake8',
+            'coverage',
+            'pytest',
+            'pytest-cov'
+        ]
+    },
+)

{signalrcore-0.9.5 → signalrcore-0.9.6a2}/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-0.9.5 → signalrcore-0.9.6a2}/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-0.9.5 → signalrcore-0.9.6a2}/signalrcore/hub/errors.py

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

{signalrcore-0.9.5 → signalrcore-0.9.6a2}/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-0.9.5 → signalrcore-0.9.6a2}/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-0.9.5 → signalrcore-0.9.6a2}/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-0.9.5 → signalrcore-0.9.6a2}/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):