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

signalrcore/transport/websockets/websocket_client.py

@@ -0,0 +1,263 @@
+import socket
+import ssl
+import base64
+import threading
+import os
+import struct
+import urllib.parse as parse
+from typing import Optional, Callable, Union
+from signalrcore.helpers import Helpers
+
+
+THREAD_NAME = "Signalrcore websocket client"
+WINDOW_SIZE = 1024
+
+
+class NoHeaderException(Exception):
+    """Error reading messages from socket, empty content
+    """
+    pass
+
+
+class SocketHandshakeError(Exception):
+    """Error during connection
+
+    Args:
+        msg (str): message
+    """
+    def __init__(self, msg: str):
+        super().__init__(msg)
+
+
+class WebSocketClient(object):
+    """Minimal websocket client
+
+    Args:
+        url (str): Websocket url
+        headers (Optional[dict]): additional headers
+        verify_ssl (bool): Verify SSL y/n
+        on_message (callable): on message callback
+        on_error (callable): on error callback
+        on_open (callable): on open callback
+        on_close (callable): on close callback
+    """
+    def __init__(
+            self,
+            url: str,
+            is_binary: bool = False,
+            headers: Optional[dict] = None,
+            proxies: dict = {},
+            verify_ssl: bool = True,
+            enable_trace: bool = False,
+            on_message: Callable = None,
+            on_open: Callable = None,
+            on_error: Callable = None,
+            on_close: Callable = None):
+        self.is_trace_enabled = enable_trace
+        self.proxies = proxies
+        self.url = url
+        self.is_binary = is_binary
+        self.headers = headers or {}
+        self.verify_ssl = verify_ssl
+        self.sock = None
+        self.ssl_context = ssl.create_default_context()\
+            if verify_ssl else\
+            ssl._create_unverified_context()
+        self.logger = Helpers.get_logger()
+        self.recv_thread = None
+        self.on_message = on_message
+        self.on_close = on_close
+        self.on_error = on_error
+        self.on_open = on_open
+        self.running = False
+        self.is_closing = False
+
+    def connect(self):
+        # ToDo URL PARSE
+        parsed_url = parse.urlparse(self.url)
+        is_secure_connection = parsed_url.scheme == "wss"\
+            or parsed_url.scheme == "https"
+
+        proxy_info = None
+        if is_secure_connection\
+                and self.proxies.get("https", None) is not None:
+            proxy_info = parse.urlparse(self.proxies.get("https"))
+
+        if not is_secure_connection\
+                and self.proxies.get("http", None) is not None:
+            proxy_info = parse.urlparse(self.proxies.get("http"))
+
+        host, port = parsed_url.hostname, parsed_url.port
+
+        if proxy_info is not None:
+            host = proxy_info.hostname,
+            port = proxy_info.port
+
+        raw_sock = socket.create_connection((host, port))
+
+        if is_secure_connection:
+            raw_sock = self.ssl_context.wrap_socket(
+                raw_sock,
+                server_hostname=host)
+
+        self.sock = raw_sock
+
+        # Perform the WebSocket handshake
+        key = base64.b64encode(os.urandom(16)).decode("utf-8")
+        request_headers = [
+            f"GET {parsed_url.path} HTTP/1.1",
+            f"Host: {parsed_url.hostname}",
+            "Upgrade: websocket",
+            "Connection: Upgrade",
+            f"Sec-WebSocket-Key: {key}",
+            "Sec-WebSocket-Version: 13"
+        ]
+        for k, v in self.headers.items():
+            request_headers.append(f"{k}: {v}")
+
+        request = "\r\n".join(request_headers) + "\r\n\r\n"
+        req = request.encode("utf-8")
+
+        if self.is_trace_enabled:
+            self.logger.debug(req)
+
+        self.sock.sendall(req)
+
+        # Read handshake response
+        response = b""
+        while b"\r\n\r\n" not in response:
+            chunk = self.sock.recv(WINDOW_SIZE)
+            if self.is_trace_enabled:
+                self.logger.debug(chunk)
+
+            if not chunk:
+                raise SocketHandshakeError(
+                    "Connection closed during handshake")
+
+            response += chunk
+
+        if b"101" not in response:
+            raise SocketHandshakeError(
+                f"Handshake failed: {response.decode()}")
+
+        self.running = True
+        self.recv_thread = threading.Thread(
+            target=self._recv_loop,
+            name=THREAD_NAME)
+        self.recv_thread.daemon = True
+        self.recv_thread.start()
+
+    def _recv_loop(self):
+        self.on_open()
+        try:
+            while self.running:
+                message = self._recv_frame()
+
+                if self.on_message:
+                    self.on_message(self, message)
+        except Exception as e:
+            self.running = False
+
+            # is closing and no header indicates
+            # that socket has not received anything
+            has_no_content = type(e) is NoHeaderException
+
+            # is closing and errno indicates
+            # that file descriptor points to a closed file
+            has_closed_fd = type(e) is OSError and e.errno == 9
+
+            if (has_no_content or has_closed_fd) and self.is_closing:
+                return
+
+            if self.logger:
+                self.logger.error(f"Receive error: {e}")
+            self.on_error(e)
+
+    def _recv_frame(self):
+        # Very basic, single-frame, unfragmented
+        try:
+            header = self.sock.recv(2)
+        except ssl.SSLError as ex:
+            self.logger.error(ex)
+            header = None
+
+        if header is None or len(header) < 2:
+            raise NoHeaderException()
+
+        fin_opcode = header[0]
+        masked_len = header[1]
+
+        if self.logger:
+            self.logger.debug(
+                f"fin opcode: {fin_opcode}, masked len: {masked_len}")
+
+        payload_len = masked_len & 0x7F
+        if payload_len == 126:
+            payload_len = struct.unpack(">H", self.sock.recv(2))[0]
+        elif payload_len == 127:
+            payload_len = struct.unpack(">Q", self.sock.recv(8))[0]
+
+        if masked_len & 0x80:
+            masking_key = self.sock.recv(4)
+            masked_data = self.sock.recv(payload_len)
+            data = bytes(
+                b ^ masking_key[i % 4]
+                for i, b in enumerate(masked_data))
+        else:
+            data = self.sock.recv(payload_len)
+
+        if self.is_trace_enabled:
+            self.logger.debug(data)
+
+        if self.is_binary:
+            return data
+
+        return data.decode("utf-8")
+
+    def send(
+            self,
+            message: Union[str, bytes],
+            opcode=0x1):
+        # Text or binary opcode (no fragmentation)
+        payload = message.encode("utf-8")\
+            if type(message) is str else message
+        header = bytes([0x80 | opcode])
+        length = len(payload)
+        if length <= 125:
+            header += bytes([0x80 | length])
+        elif length <= 65535:
+            header += bytes([0x80 | 126]) + struct.pack(">H", length)
+        else:
+            header += bytes([0x80 | 127]) + struct.pack(">Q", length)
+
+        # Mask the payload
+        masking_key = os.urandom(4)
+        masked_payload = bytes(
+            b ^ masking_key[i % 4]
+            for i, b in enumerate(payload))
+        frame = header + masking_key + masked_payload
+        self.sock.sendall(frame)
+
+    def dispose(self):
+        if self.sock:
+            self.sock.close()
+        is_same_thread = threading.current_thread().name == THREAD_NAME
+        if self.recv_thread and not is_same_thread:
+            self.recv_thread.join()
+            self.recv_thread = None
+
+    def close(self):
+        self.logger.debug("Start closing socket")
+        try:
+            self.is_closing = True
+            self.running = False
+
+            self.dispose()
+
+            self.on_close()
+            self.logger.debug("socket closed successfully")
+        except Exception as ex:
+            self.logger.error(ex)
+            self.on_error(ex)
+        finally:
+            self.is_closing = False

signalrcore/transport/websockets/websocket_transport.py

@@ -1,20 +1,18 @@
-import websocket
-import threading
-import requests
 import traceback
 import time
-import ssl
 from .reconnection import ConnectionStateChecker
 from .connection import ConnectionState
 from ...messages.ping_message import PingMessage
-from ...hub.errors import HubError, HubConnectionError, UnAuthorizedHubError
+from ...hub.errors import HubError, UnAuthorizedHubError
 from ...protocol.messagepack_protocol import MessagePackHubProtocol
-from ...protocol.json_hub_protocol import JsonHubProtocol
 from ..base_transport import BaseTransport
-from ...helpers import Helpers
+from ...helpers import Helpers, RequestHelpers
+from .websocket_client import WebSocketClient
+
 
 class WebsocketTransport(BaseTransport):
-    def __init__(self,
+    def __init__(
+            self,
             url="",
             headers=None,
             keep_alive_interval=15,
@@ -22,13 +20,14 @@ class WebsocketTransport(BaseTransport):
             verify_ssl=False,
             skip_negotiation=False,
             enable_trace=False,
+            proxies: dict = {},
             **kwargs):
         super(WebsocketTransport, self).__init__(**kwargs)
         self._ws = None
         self.enable_trace = enable_trace
-        self._thread = None
         self.skip_negotiation = skip_negotiation
         self.url = url
+        self.proxies = proxies
         if headers is None:
             self.headers = dict()
         else:
@@ -37,7 +36,6 @@ class WebsocketTransport(BaseTransport):
         self.token = None  # auth
         self.state = ConnectionState.disconnected
         self.connection_alive = False
-        self._thread = None
         self._ws = None
         self.verify_ssl = verify_ssl
         self.connection_checker = ConnectionStateChecker(
@@ -46,9 +44,6 @@ class WebsocketTransport(BaseTransport):
         )
         self.reconnection_handler = reconnection_handler
 
-        if len(self.logger.handlers) > 0:
-            websocket.enableTrace(self.enable_trace, self.logger.handlers[0])
-    
     def is_running(self):
         return self.state != ConnectionState.disconnected
 
@@ -56,8 +51,11 @@ class WebsocketTransport(BaseTransport):
         if self.state == ConnectionState.connected:
             self.connection_checker.stop()
             self._ws.close()
-            self.state = ConnectionState.disconnected
-            self.handshake_received = False
+        self.state = ConnectionState.disconnected
+        self.handshake_received = False
+
+    def is_trace_enabled(self) -> bool:
+        return self._ws.is_trace_enabled
 
     def start(self):
         if not self.skip_negotiation:
@@ -69,39 +67,41 @@ class WebsocketTransport(BaseTransport):
 
         self.state = ConnectionState.connecting
         self.logger.debug("start url:" + self.url)
-        
-        self._ws = websocket.WebSocketApp(
+
+        self._ws = WebSocketClient(
             self.url,
-            header=self.headers,
+            headers=self.headers,
+            is_binary=type(self.protocol) is MessagePackHubProtocol,
+            verify_ssl=self.verify_ssl,
             on_message=self.on_message,
             on_error=self.on_socket_error,
             on_close=self.on_close,
             on_open=self.on_open,
+            enable_trace=self.enable_trace
             )
-            
-        self._thread = threading.Thread(
-            target=lambda: self._ws.run_forever(
-                sslopt={"cert_reqs": ssl.CERT_NONE}
-                if not self.verify_ssl else {}
-            ))
-        self._thread.daemon = True
-        self._thread.start()
+
+        # ToDo
+        # if len(self.logger.handlers) > 0:
+        #    self._ws.enableTrace(self.enable_trace, self.logger.handlers[0])
+        self._ws.connect()
         return True
 
     def negotiate(self):
         negotiate_url = Helpers.get_negotiate_url(self.url)
         self.logger.debug("Negotiate url:{0}".format(negotiate_url))
 
-        response = requests.post(
-            negotiate_url, headers=self.headers, verify=self.verify_ssl)
-        self.logger.debug(
-            "Response status code{0}".format(response.status_code))
+        status_code, data = RequestHelpers.post(
+            negotiate_url,
+            headers=self.headers,
+            proxies=self.proxies,
+            verify_ssl=self.verify_ssl)
 
-        if response.status_code != 200:
-            raise HubError(response.status_code)\
-                if response.status_code != 401 else UnAuthorizedHubError()
+        self.logger.debug(
+            "Response status code{0}".format(status_code))
 
-        data = response.json()
+        if status_code != 200:
+            raise HubError(status_code)\
+                if status_code != 401 else UnAuthorizedHubError()
 
         if "connectionId" in data.keys():
             self.url = Helpers.encode_connection_id(
@@ -117,7 +117,6 @@ class WebsocketTransport(BaseTransport):
             self.token = data["accessToken"]
             self.headers = {"Authorization": "Bearer " + self.token}
 
-
     def evaluate_handshake(self, message):
         self.logger.debug("Evaluating handshake {0}".format(message))
         msg, messages = self.protocol.decode_handshake(message)
@@ -130,25 +129,21 @@ class WebsocketTransport(BaseTransport):
                     self.connection_checker.start()
         else:
             self.logger.error(msg.error)
-            self.on_socket_error(self._ws, msg.error)
+            self.on_socket_error(msg.error)
             self.stop()
             self.state = ConnectionState.disconnected
         return messages
 
-    def on_open(self, _):
+    def on_open(self):
         self.logger.debug("-- web socket open --")
         msg = self.protocol.handshake_message()
         self.send(msg)
 
-    def on_close(self, callback, close_status_code, close_reason):
+    def on_close(self):
         self.logger.debug("-- web socket close --")
-        self.logger.debug(close_status_code)
-        self.logger.debug(close_reason)
         self.state = ConnectionState.disconnected
         if self._on_close is not None and callable(self._on_close):
             self._on_close()
-        if callback is not None and callable(callback):
-            callback()
 
     def on_reconnect(self):
         self.logger.debug("-- web socket reconnecting --")
@@ -156,11 +151,10 @@ class WebsocketTransport(BaseTransport):
         if self._on_close is not None and callable(self._on_close):
             self._on_close()
 
-    def on_socket_error(self, app, error):
+    def on_socket_error(self, error: Exception):
         """
         Args:
-            _: Required to support websocket-client version equal or greater than 0.58.0
-            error ([type]): [description]
+            error (Exception): websocket error
 
         Raises:
             HubError: [description]
@@ -171,7 +165,7 @@ class WebsocketTransport(BaseTransport):
         self.logger.error("{0} {1}".format(error, type(error)))
         self._on_close()
         self.state = ConnectionState.disconnected
-        #raise HubError(error)
+        # raise HubError(error)
 
     def on_message(self, app, raw_message):
         self.logger.debug("Message received{0}".format(raw_message))
@@ -185,7 +179,7 @@ class WebsocketTransport(BaseTransport):
                 return self._on_message(messages)
 
             return []
-        
+
         return self._on_message(
             self.protocol.parse_messages(raw_message))
 
@@ -195,14 +189,12 @@ class WebsocketTransport(BaseTransport):
             self._ws.send(
                 self.protocol.encode(message),
                 opcode=0x2
-                if type(self.protocol) == MessagePackHubProtocol else
+                if type(self.protocol) is MessagePackHubProtocol else
                 0x1)
             self.connection_checker.last_message = time.time()
             if self.reconnection_handler is not None:
                 self.reconnection_handler.reset()
-        except (
-                websocket._exceptions.WebSocketConnectionClosedException,
-                OSError) as ex:
+        except OSError as ex:
             self.handshake_received = False
             self.logger.warning("Connection closed {0}".format(ex))
             self.state = ConnectionState.disconnected
@@ -217,7 +209,8 @@ class WebsocketTransport(BaseTransport):
             raise ex
 
     def handle_reconnect(self):
-        if not self.reconnection_handler.reconnecting and self._on_reconnect is not None and \
+        if not self.reconnection_handler.reconnecting \
+                and self._on_reconnect is not None and \
                 callable(self._on_reconnect):
             self._on_reconnect()
         self.reconnection_handler.reconnecting = True
@@ -227,17 +220,15 @@ class WebsocketTransport(BaseTransport):
         except Exception as ex:
             self.logger.error(ex)
             sleep_time = self.reconnection_handler.next()
-            threading.Thread(
-                target=self.deferred_reconnect,
-                args=(sleep_time,)
-            ).start()
+            self.deferred_reconnect(sleep_time)
 
     def deferred_reconnect(self, sleep_time):
         time.sleep(sleep_time)
         try:
             if not self.connection_alive:
-                self.send(PingMessage())
+                if not self.connection_checker.running:
+                    self.send(PingMessage())
         except Exception as ex:
             self.logger.error(ex)
             self.reconnection_handler.reconnecting = False
-            self.connection_alive = False
+            self.connection_alive = False

{signalrcore-0.9.5.dist-info → signalrcore-0.9.6a2.dist-info}/METADATA

@@ -1,19 +1,23 @@
 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
 License-File: LICENSE
-Requires-Dist: requests (>=2.22.0)
-Requires-Dist: websocket-client (==1.0.0)
-Requires-Dist: msgpack (==1.0.2)
+Requires-Dist: msgpack ==1.0.2
+Provides-Extra: dev
+Requires-Dist: coverage ; extra == 'dev'
+Requires-Dist: flake8 ; extra == 'dev'
+Requires-Dist: pytest ; extra == 'dev'
+Requires-Dist: pytest-cov ; extra == 'dev'
+Requires-Dist: requests ; extra == 'dev'
 
 # SignalR core client
 [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg?logo=paypal&style=flat-square)](https://www.paypal.me/mandrewcito/1)
@@ -37,24 +41,16 @@ Requires-Dist: msgpack (==1.0.2)
 
 # 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
@@ -162,7 +158,7 @@ connection = HubConnectionBuilder()\
             })\
             .build()
 ```
-## Congfiguring skip negotiation
+## Configuring skip negotiation
 ```python
 hub_connection = HubConnectionBuilder() \
         .with_url("ws://"+server_url, options={
@@ -333,5 +329,3 @@ hub_connection.stop()
 sys.exit(0)
 
 ```
-
-

{signalrcore-0.9.5.dist-info → signalrcore-0.9.6a2.dist-info}/RECORD

@@ -1,12 +1,12 @@
 signalrcore/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-signalrcore/helpers.py,sha256=uoQCHrT1M2_7fMOYmD-Piw4za2AGz6TENYhe3vvMffw,2756
-signalrcore/hub_connection_builder.py,sha256=EBKxRIgVTtlfk3YCQq7F6MWgXqRSNazRNDsAv3lwK4s,8570
+signalrcore/helpers.py,sha256=QELTUh8v-j1qgEo3IXlcTEToR0K3lbZNwrDZpuhtJS0,4422
+signalrcore/hub_connection_builder.py,sha256=A8dtysW5R1_EAJ_GcZZHtea9NLu96dfKMsmmtuY6LRI,9161
 signalrcore/subject.py,sha256=izH-qzaVPHrK8OgN2ZJ5A_1v4Lx5QtqC_zYfq59hFp4,2112
 signalrcore/hub/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 signalrcore/hub/auth_hub_connection.py,sha256=YVsmRhGhG8CYi7egnYbFJXPB7dDiPOnwX45dQg8MhUA,964
-signalrcore/hub/base_hub_connection.py,sha256=qyVCI57w_jyoIgTcYTzq5EfEnSPLGbI1C7U8Eak4RRY,9673
-signalrcore/hub/errors.py,sha256=CxyoYj7B8-5OUBhT2QBYFcDzmOvYCdkp42MOZls8xkw,176
-signalrcore/hub/handlers.py,sha256=g85bQ6Sr2-KHzMJXHBJdYqeALGHy-Z5GyGrLVGqVSLg,1928
+signalrcore/hub/base_hub_connection.py,sha256=dj-uXjGaPNPA7lGmIscwsah_Y6BeukpbdEwKGG5_UJk,9939
+signalrcore/hub/errors.py,sha256=EDJgMT-ZpWc1VIRA--Qjahg2LBK0u0mM5V5UX7-i-XQ,180
+signalrcore/hub/handlers.py,sha256=-f6OLQ9AMwGqE7Gh-84oHf0bTgUVsSlFuRg_T0ff_T8,1914
 signalrcore/messages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 signalrcore/messages/base_message.py,sha256=AAydVr-g85U2xthOM4jm2hqHQ3ZBaOSiO0hmXlqCEpI,447
 signalrcore/messages/cancel_invocation_message.py,sha256=CLsAom4Ubf3bn8HroEOzgiye_6VI9RnjgJmxtwqshbo,647
@@ -21,28 +21,30 @@ signalrcore/messages/handshake/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5
 signalrcore/messages/handshake/request.py,sha256=zNM8PZ4m4W1OSlEnXCxjPLnlYNXPF7yrToDDPxdcb9c,152
 signalrcore/messages/handshake/response.py,sha256=ekQx_MX9ZTxHgDa7uiKAivBjky8xVMV5ljjf-Rpeo5w,103
 signalrcore/protocol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-signalrcore/protocol/base_hub_protocol.py,sha256=B2_kqssL9Um-h2Oplu2vRfo8vsOAjp-QeSidHdmX4Hw,2991
+signalrcore/protocol/base_hub_protocol.py,sha256=6eSUD84R97C7eRfNEzakYVDANg-PEnw2tJ3LhdkPK9k,3000
 signalrcore/protocol/json_hub_protocol.py,sha256=aJ5rLdhLt3ijW_G1aATtTFL-nbSa3cZFlv2yzcox3hg,1654
-signalrcore/protocol/messagepack_protocol.py,sha256=ZS-QqOyk_yPrKFBb_F4KM3rYJT1M_IAxzQTtjUMs-q0,6419
+signalrcore/protocol/messagepack_protocol.py,sha256=BS5pd5bDk8GIOcWJZptFPtlwVPU5Wp9w2F-4Sg19vpY,7054
 signalrcore/protocol/handshake/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 signalrcore/transport/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-signalrcore/transport/base_transport.py,sha256=KXPzdgQkxwcj2Unm4WRvoGMpGKao01VJZAyQ0HvegiU,1124
+signalrcore/transport/base_transport.py,sha256=1LVw5kNxU0BBAeNA5smkV2vnhGKq3uD42EoPo8iO8gU,1134
 signalrcore/transport/websockets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 signalrcore/transport/websockets/connection.py,sha256=mBaZeNxcqWjDlNOnMWk8Pp7vu3g3_wY5oQPUdIL7L3E,140
 signalrcore/transport/websockets/reconnection.py,sha256=y3SSYLl3VFXLVNDtTdojBbAvMDzHoiXJod7wu-L9D3w,2680
-signalrcore/transport/websockets/websocket_transport.py,sha256=ym7ZakkOyXoBwnBx_HC5xw5IQB1_2DlIdOoVP8b45CE,8907
+signalrcore/transport/websockets/websocket_client.py,sha256=h2Ve7r0rEjesblsa8TnzijRDA4Cp-GTqQCp0ysau_Fg,7933
+signalrcore/transport/websockets/websocket_transport.py,sha256=2uuWYfINegW01PgaS86hsEEg-1hcKBpFiikLrtGcgfQ,8425
 test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-test/base_test_case.py,sha256=k_zqhAZRmPkzKizVkVsn-A4fpWxNEqg9kJjg036OTD4,1835
-test/client_streaming_test.py,sha256=zKfle7J0kg5LzpzaL13WXdRb7xdZCILLcXHCV2GZhNw,1002
-test/configuration_test.py,sha256=OLeBfnS3CM96Jfb2q1oJ-J3xAc8rHMts53a2tbY6FP0,2164
-test/open_close_test.py,sha256=g3YlSYS-jhpj6mdLLqPoigXF1CqGlR-bFn1ThIvNCwk,1566
-test/reconnection_test.py,sha256=O7hc5NG1ou3zgK9C4I1b37vxk3Pas5T6nNL1rTrEJ5c,3992
-test/send_auth_errors_test.py,sha256=PIFmcQ_y1iZ1cMiDt-QRMhFCvindxvcNiS1RTksyA1o,1833
-test/send_auth_test.py,sha256=rTwF2sizB_DZpU4gulEqfsHAfIBOciMMN1DwzgZb2Dg,2733
-test/send_test.py,sha256=hTSmTsJmn2YjompPaVCFU0z61AF0lp32Rrp8Fywersg,5523
-test/streaming_test.py,sha256=gaNF4rd0Z4ijxsFcCwhW_8JrbHxKBdDHWpoPCNSgfzU,1977
-signalrcore-0.9.5.dist-info/LICENSE,sha256=zlgZo2qli0c9PLoPObfeGy9yEXuQOV2HF26LykBg5Ko,1101
-signalrcore-0.9.5.dist-info/METADATA,sha256=V_kY9TULRO2_1jwPErZascw9IZFo3MRiF6jeJ9Yuqno,10552
-signalrcore-0.9.5.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-signalrcore-0.9.5.dist-info/top_level.txt,sha256=I28KSOVJS0rNgMCI8E8W-13gvoCGHkmwc6z4NSrQlo0,17
-signalrcore-0.9.5.dist-info/RECORD,,
+test/base_test_case.py,sha256=HDTCbf4_xjeA0rX9vj30B3sGBetfA_u728gcQ48CTNM,1840
+test/client_streaming_test.py,sha256=qXmzj1KQkAbGXj9nls3p0-9q6PirUj78f40AQE7MIX8,836
+test/configuration_test.py,sha256=KBBObisq2RvOrDM8OW7KzQnOPgJmCyv-Ndr2ykPjS8U,2222
+test/open_close_test.py,sha256=EKedyOWS3q86LzNQCJ8KaYoXEusAi8vXCW8K2hzD5o8,1665
+test/reconnection_test.py,sha256=dvbWplOE5gU7Ve_yNb9TmmrKoUl0KgsI8ZQPN8UXsJw,4251
+test/send_auth_errors_test.py,sha256=warY87prADkdh1PL3_hmtGQt8j_wqFz1puiYj-Z2SLk,1808
+test/send_auth_test.py,sha256=R1tS6NCYdr9fmVMspQmZDmHbQpTLUrDnzukjgE-blO4,2733
+test/send_test.py,sha256=lKOt4OC84GMN4wunpfq_GU-nQQ_N5cgkGJj-Da3u1s4,5942
+test/streaming_test.py,sha256=GM7BpQwrP27Pjmhdt3vQUTAZyWyoyA2QThPymY7s3Ao,1839
+test/subscribe_test.py,sha256=fQ5W_l9kX9dp4khwo6U4-8hEDYLLD5p9FdgwTeOAhDg,505
+signalrcore-0.9.6a2.dist-info/LICENSE,sha256=zlgZo2qli0c9PLoPObfeGy9yEXuQOV2HF26LykBg5Ko,1101
+signalrcore-0.9.6a2.dist-info/METADATA,sha256=-AvuZOscKnfnrr4ZjjBcRrg7stCPbWM_hS1P-jOnXTs,10087
+signalrcore-0.9.6a2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+signalrcore-0.9.6a2.dist-info/top_level.txt,sha256=I28KSOVJS0rNgMCI8E8W-13gvoCGHkmwc6z4NSrQlo0,17
+signalrcore-0.9.6a2.dist-info/RECORD,,

{signalrcore-0.9.5.dist-info → signalrcore-0.9.6a2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: bdist_wheel (0.42.0)
 Root-Is-Purelib: true
 Tag: py3-none-any