SignalR Core Python Client

Warnings

• breaking Version 1.0.1 and newer of `signalrcore` require Python 3.9 or higher. Additionally, the `msgpack` dependency was updated to `1.1.2`. Users on older Python versions or with conflicting `msgpack` installations may encounter compatibility issues upon upgrading.
  Fix: Ensure your environment uses Python 3.9+ and update `msgpack` to `1.1.2` or the version specified in `signalrcore`'s `install_requires`.
• gotcha The error 'Hub is not running you cant send messages' typically occurs when attempting to send data before the SignalR connection is fully established or after it has unexpectedly closed. The connection might take a few moments to negotiate and connect, especially with automatic reconnection configured.
  Fix: Always check `hub_connection.connected` before sending messages. Implement appropriate delays or listen for the `on_open` event before initiating message sends. Review logs (configured to DEBUG level) for connection status and re-connection attempts.
• gotcha Prior to version 1.0.2, the client could experience 'fragmented messages error' when receiving large messages over WebSocket or Server-Sent Events transports. This could lead to incomplete message processing or connection instability.
  Fix: Upgrade to `signalrcore` version 1.0.2 or newer to benefit from the fix for fragmented message handling.
• gotcha SignalR hub method names invoked from the client, as well as user and group identifiers used for targeting specific clients on the server, are case-sensitive. A mismatch in casing between the client invocation and the server-side method or identifier can lead to calls silently failing or messages not being delivered.
  Fix: Ensure that the casing of method names (e.g., `hub_connection.send("SendMessage", ...)` vs. server's `SendMessage` or `sendMessage`) and user/group IDs matches exactly between your Python client and the SignalR server.

Install

• pip install signalrcore Install latest stable version

Imports

• HubConnectionBuilder

  from signalrcore.hub_connection_builder import HubConnectionBuilder

  Primary builder for synchronous/blocking connections.
• AIOHubConnectionBuilder

  from signalrcore.aio.aio_hub_connection_builder import AIOHubConnectionBuilder

  Builder for asyncio-compatible connections.

Quickstart

This example demonstrates how to establish a connection to a SignalR hub, set up event handlers for connection status, register a callback for a server-side method, and send messages. It includes basic logging configuration and automatic reconnection, and uses an environment variable for the hub URL for better configurability. Remember to replace `http://localhost:5000/hub` with your actual SignalR hub URL.

import logging
import time
import os
from signalrcore.hub_connection_builder import HubConnectionBuilder

# Configure logging for better visibility
handler = logging.StreamHandler()
handler.setLevel(logging.DEBUG)

hub_connection = HubConnectionBuilder() \
    .with_url(os.environ.get('SIGNALR_HUB_URL', 'http://localhost:5000/hub')) \
    .configure_logging(logging.DEBUG, socket_trace=True, handler_mapping={
        "httpx": logging.WARNING,
        "websocket": logging.WARNING,
        "urllib3": logging.WARNING
    }) \
    .with_automatic_reconnect({
        "type": "interval",
        "keep_alive_interval": 10,
        "intervals": [1, 2, 5, 10, 15, 30] # In seconds
    }) \
    .build()

hub_connection.on_open(lambda: print("Connection opened."))
hub_connection.on_close(lambda: print("Connection closed."))
hub_connection.on_error(lambda data: print(f"Connection error: {data.error}"))

# Define a callback for a specific method on the hub
def receive_message(args):
    print(f"Received message: {args}")

hub_connection.on("ReceiveMessage", receive_message)

print("Starting connection...")
hub_connection.start()
print("Connection started.")

# Keep the connection alive for some time and send a message
try:
    # Give some time for the connection to establish and possibly auto-reconnect
    time.sleep(5)
    if hub_connection.connected:
        print("Sending message to hub...")
        hub_connection.send("SendMessage", ["PythonClient", "Hello from Python!"])
        print("Message sent. Waiting for 30 seconds to receive messages or keep alive.")
        time.sleep(30) # Keep connection alive and listen for messages
    else:
        print("Connection not established or reconnected. Cannot send message.")

except KeyboardInterrupt:
    pass
finally:
    print("Stopping connection...")
    hub_connection.stop()
    print("Connection stopped.")