tg_pubsub package

Subpackages

• tg_pubsub.management package
  • Subpackages
    • tg_pubsub.management.commands package
      • Submodules
      • tg_pubsub.management.commands.pubsub_server module
      • Module contents
  • Module contents

Submodules

tg_pubsub.config module

tg_pubsub.config.get_extra_models()

Get extra models to mark as listenable. This is useful if one needs to listen to changes

on a model that is coming from external apps so subclassing variant is impossible.

TG_PUBSUB_EXTRA_MODELS: list(config_path, ...)

Return type:dict

tg_pubsub.config.get_hello_packets()

Get all packets to send right after doing websocket handshake

TG_PUBSUB_HELLO_PACKETS: List of import paths to callables that must return an instance of BaseMessage

Returns:

tg_pubsub.config.get_protocol_handler()

tg_pubsub.config.get_protocol_handler_klass()

tg_pubsub.config.get_pubsub_server_host()

tg_pubsub.config.get_pubsub_server_ping_delta()

tg_pubsub.config.get_pubsub_server_port()

tg_pubsub.exceptions module

exception tg_pubsub.exceptions.IgnoreMessageException

Bases: Exception

exception tg_pubsub.exceptions.InvalidMessageException

Bases: Exception

tg_pubsub.messages module

class tg_pubsub.messages.BaseMessage(channels, data)

Bases: object

MESSAGE_IDENTIFIER = 'base'

as_message()

classmethod prepare_for_send(ws, data)

publish()

Publish message to redis queue

class tg_pubsub.messages.ModelChanged(klass, action, instance)

Bases: tg_pubsub.messages.BaseMessage

MESSAGE_IDENTIFIER = 'model'

classmethod prepare_for_send(ws, data)

tg_pubsub.models module

class tg_pubsub.models.ListenableBase

Bases: object

Base mixin that declares the api for listenables

get_serializer(*args, **kwargs)

get_serializer_class()

Return the class to use for the serializer.

classmethod has_access(instance, user)

Does the given user has access to the model instance. This can be used to only send model data to specific users.

(Note: The user may be anonymous)

Parameters:

• instance – Model instance
• user – User connected via pubsub

Return type:

bool

pubsub_get_model()

classmethod pubsub_serialize(instance, serializer)

Serialize the given model instance before sending it to the users.

Parameters:

• instance – Model instance
• serializer – Drf serializer

Returns:

serializer_class = None

serializer_fields = ('pk',)

classmethod should_notify(instance, action)

Should the given instance send out a change notification. This can be used to limit publishes to only specific instances.

Parameters:

• instance – Model instance
• action – Action that triggered the notification (created, saved, deleted)

Return type:

bool

class tg_pubsub.models.ListenableModelMixin

Bases: tg_pubsub.models.ListenableBase

Mixin that will mark model as ‘listenable’. Such models will send messages to Redis queue whenever they’re updated.

class tg_pubsub.models.ModelListenConfig

Bases: tg_pubsub.models.ListenableModelMixin

Special class that can be used to mark external app models as listenable.

via: TG_PUBSUB_EXTRA_MODELS

model_path = None

pubsub_get_model()

tg_pubsub.models.is_model_listenable(cls, action, instance)

tg_pubsub.models.model_changed(cls, action, instance)

tg_pubsub.models.model_post_save_handler(sender, instance, created, **kwargs)

tg_pubsub.models.model_pre_delete_handler(sender, instance, **kwargs)

tg_pubsub.protocol module

class tg_pubsub.protocol.AnonymousUserServerProtocol(ws_handler, ws_server, *, origins=None, subprotocols=None, extra_headers=None, **kwds)

Bases: tg_pubsub.protocol.AnyUserServerProtocol

WebSocketServerProtocol implementation that only allows anonymous users

has_permissions(request)

class tg_pubsub.protocol.AnyUserServerProtocol(ws_handler, ws_server, *, origins=None, subprotocols=None, extra_headers=None, **kwds)

Bases: tg_pubsub.protocol.SessionRequiredServerProtocol

WebSocketServerProtocol implementation that allows any users (that provide a token)

get_handler_kwargs(path, get_header)

has_permissions(request)

class tg_pubsub.protocol.AuthenticatedUserServerProtocol(ws_handler, ws_server, *, origins=None, subprotocols=None, extra_headers=None, **kwds)

Bases: tg_pubsub.protocol.AnyUserServerProtocol

WebSocketServerProtocol implementation that only allows authenticated users

has_permissions(request)

class tg_pubsub.protocol.FakeRequest(path, session_key)

Bases: object

session

class tg_pubsub.protocol.RequestServerProtocol(ws_handler, ws_server, *, origins=None, subprotocols=None, extra_headers=None, **kwds)

Bases: websockets.server.WebSocketServerProtocol

WebSocketServerProtocol that gives handler a request-like object which might contain the session/user if token was provided.

TOKEN_PARAM = 'token'

get_handler_kwargs(path, get_header)

class tg_pubsub.protocol.SessionRequiredServerProtocol(ws_handler, ws_server, *, origins=None, subprotocols=None, extra_headers=None, **kwds)

Bases: tg_pubsub.protocol.RequestServerProtocol

WebSocketServerProtocol which only allows handshakes with a valid token

get_handler_kwargs(path, get_header)

class tg_pubsub.protocol.StaffUserServerProtocol(ws_handler, ws_server, *, origins=None, subprotocols=None, extra_headers=None, **kwds)

Bases: tg_pubsub.protocol.AuthenticatedUserServerProtocol

WebSocketServerProtocol implementation that only allows staff users

has_permissions(request)

class tg_pubsub.protocol.SuperUserServerProtocol(ws_handler, ws_server, *, origins=None, subprotocols=None, extra_headers=None, **kwds)

Bases: tg_pubsub.protocol.StaffUserServerProtocol

WebSocketServerProtocol implementation that only allows superusers

has_permissions(request)

tg_pubsub.pubsub module

tg_pubsub.pubsub.create_redis_connection()

tg_pubsub.pubsub.publish(channel, message)

tg_pubsub.worker module

class tg_pubsub.worker.HandlerProtocol(ws, request)

Bases: object

logging_key

open

ping()

send(data)

user

class tg_pubsub.worker.WebSocketHandler(ws, request)

Bases: object

classmethod message_valid(message)

ping()

run()

send_hello()

send_on_change()

tg_pubsub.worker.client_handler(ws, path, request=None)

tg_pubsub.worker.run_pubsub_server(host, port)

Module contents