Exemplos de URLRouter em Python

Exemplo n.º 1

from channels.routing import ProtocolTypeRouter, URLRouter, ChannelNameRouter
from core.auth import TokenAuthMiddlewareStack
from ws.routing import websocket_urlpatterns
from ws.consumers import NotificationConsumer, ChatConsumer

application = ProtocolTypeRouter({
    'websocket': TokenAuthMiddlewareStack(
        URLRouter(websocket_urlpatterns)
    ),
    # for worker
    'channel': ChannelNameRouter({
        'notification': NotificationConsumer,
        'chat': ChatConsumer
    })
})

Exemplo n.º 2

# Channels Imports
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack

# Local Imports
import rtshare.routing

application = ProtocolTypeRouter({
    # (http->django views is added by default)
    'websocket':
    AuthMiddlewareStack(URLRouter(rtshare.routing.websocket_urlpatterns)),
})

Exemplo n.º 3

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter

import chat.routing

application = ProtocolTypeRouter(
    {"websocket": AuthMiddlewareStack(URLRouter(chat.routing.websocket_urlpatterns)),}
)

Exemplo n.º 4

from django.conf.urls import url

from channels.routing import ProtocolTypeRouter, URLRouter
from channels.security.websocket import AllowedHostsOriginValidator

from e_logs.common.all_journals_app.ws.consumers import CommonConsumer
from e_logs.core.middleware import TokenAuthMiddleware

ASGI_APPLICATION = "config.asgi.application"

application = ProtocolTypeRouter({
    "websocket":
    AllowedHostsOriginValidator(
        TokenAuthMiddleware(URLRouter([
            url(r"^e-logs/$", CommonConsumer),
        ])))
})

Exemplo n.º 5

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter, ChannelNameRouter
from game.consumers.game import GameConsumer
import game.routing

application = ProtocolTypeRouter({
    # (http->django views is added by default)
    'websocket': AuthMiddlewareStack(
        URLRouter(
            game.routing.websocket_urlpatterns
        )
    ),
    "channel": ChannelNameRouter({
        "gamev1": GameConsumer,
    }),
})

Exemplo n.º 6

Arquivo: routing.py Projeto: akshaykalucha3/Django_Sockets

from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from graphsocket import routing as graphsocket_routing
from personalchat import routing as personalchat_routing

application = ProtocolTypeRouter({
    "websocket":
    AuthMiddlewareStack(
        URLRouter(graphsocket_routing.websocket_urlpatterns +
                  personalchat_routing.websocket_urlpatterns))
})

Exemplo n.º 7

# mysite/routing.py
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
import testapp.routing

application = ProtocolTypeRouter({
    # (http->django views is added by default)
    'websocket':
    AuthMiddlewareStack(URLRouter(testapp.routing.websocket_urlpatterns)),
})

Exemplo n.º 8

Arquivo: routing.py Projeto: Salman-Arshad/easypy

from channels.auth import AuthMiddlewareStack
from channels.security.websocket import AllowedHostsOriginValidator
from channels.routing import ProtocolTypeRouter, URLRouter
import apps.ws.routing

# noinspection SpellCheckingInspection
application = ProtocolTypeRouter({
    'websocket':
    AllowedHostsOriginValidator(
        AuthMiddlewareStack(URLRouter(apps.ws.routing.websocket_urlpatterns))),
})

Exemplo n.º 9

"""
ASGI config for deliveryapp project.

It exposes the ASGI callable as a module-level variable named ``application``.

For more information on this file, see
https://docs.djangoproject.com/en/3.1/howto/deployment/asgi/
"""

import os
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.security.websocket import AllowedHostsOriginValidator
from django.core.asgi import get_asgi_application
from django.urls import path
from pages import consumers

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'deliveryapp.settings')

application = get_asgi_application()

ws_pattern = [
    path("ws/customer", consumers.OrderStatus),
]

application = ProtocolTypeRouter({
    'websocket':
    AllowedHostsOriginValidator(AuthMiddlewareStack(URLRouter(ws_pattern)))
})

Exemplo n.º 10

Arquivo: routing.py Projeto: suyashl13/Realtime-Chat-Server

import os

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from django.core.asgi import get_asgi_application
from channeldemo import routing

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "mysite.settings")

application = ProtocolTypeRouter({
  "http": get_asgi_application(),
  "websocket": AuthMiddlewareStack(
        URLRouter(
            routing.websocket_urlpatterns
        )
    ),
})

Exemplo n.º 11

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from django.core.asgi import get_asgi_application
import chat.routing
import os

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "chatApplication.settings")

application = ProtocolTypeRouter({
    "http":
    get_asgi_application(),
    "websocket":
    AuthMiddlewareStack(URLRouter(chat.routing.websocket_urls)),
})

Exemplo n.º 12

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
import calculator.routing

# Routing the Websocket urls
application = ProtocolTypeRouter({
    'websocket':
    AuthMiddlewareStack(URLRouter(calculator.routing.websocket_urlpatterns)),
})

Exemplo n.º 13

Arquivo: routing.py Projeto: sergiogonzalezjr/django-eventstream

from django.conf.urls import url
from channels.routing import URLRouter
from channels.http import AsgiHandler
from channels.auth import AuthMiddlewareStack
import django_eventstream

urlpatterns = [
    url(r'^rooms/(?P<room_id>[^/]+)/events/',
        AuthMiddlewareStack(URLRouter(django_eventstream.routing.urlpatterns)),
        {'format-channels': ['room-{room_id}']}),

    # older endpoint allowing client to select channel. not recommended
    url(r'^events/',
        AuthMiddlewareStack(URLRouter(
            django_eventstream.routing.urlpatterns))),
    url(r'', AsgiHandler),
]

Exemplo n.º 14

'''
Created on May 18, 2018

@author: benjamin
'''
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
import butd.routing

application = ProtocolTypeRouter({
    'websocket': AuthMiddlewareStack(
        URLRouter(
            butd.routing.websocket_urlpatterns
        )
    ),
    })

Exemplo n.º 15

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
import ccapp.urls

application = ProtocolTypeRouter({
    # Empty for now (http->django views is added by default)
    'websocket':
    AuthMiddlewareStack(URLRouter(ccapp.urls.websocket_urlpatterns)),
})

Exemplo n.º 16

Arquivo: routing.py Projeto: intellineers/django-bridger

from channels.routing import ProtocolTypeRouter, URLRouter
from django.conf.urls import url
from channels.routing import URLRouter
from django.urls import path

from bridger.notifications.consumers import NotificationConsumer
from bridger.websockets.auth import JWTAuthMiddlewareStack
from bridger.websockets.consumers import AsyncAuthenticatedJsonWebsocketConsumer

websocket_urlpatterns = [
    path("ws/socket/", AsyncAuthenticatedJsonWebsocketConsumer.as_asgi()),
    path("ws/notification/", NotificationConsumer.as_asgi()),
]

application = ProtocolTypeRouter(
    {"websocket": JWTAuthMiddlewareStack(URLRouter(websocket_urlpatterns))})

Exemplo n.º 17

Arquivo: routing.py Projeto: ereadingtool/ereadingtool

from auth.producer_auth import ProducerAuthMiddleware
from channels.routing import ProtocolTypeRouter, URLRouter, ChannelNameRouter
from channels.security.websocket import AllowedHostsOriginValidator
from django.conf.urls import url

from flashcards.consumers.student import StudentFlashcardSessionConsumer

from text.consumers.student import StudentTextReaderConsumer
from text.consumers.instructor import InstructorTextReaderConsumer, ParseTextSectionForDefinitions

application = ProtocolTypeRouter({
    # web socket textreader handler
    'websocket':
    AllowedHostsOriginValidator(
        ProducerAuthMiddleware(
            URLRouter([
                # text reading
                url(r'^student/text_read/(?P<text_id>\d+)$',
                    StudentTextReaderConsumer),
                url(r'^instructor/text_read/(?P<text_id>\d+)$',
                    InstructorTextReaderConsumer),

                # flashcards
                url(r'^student/flashcards/$', StudentFlashcardSessionConsumer),
                # url(r'^instructor/flashcard/$', InstructorTextReaderConsumer),
            ]))),
    'channel':
    ChannelNameRouter({'text': ParseTextSectionForDefinitions})
})

Exemplo n.º 18

from django.conf.urls import url

from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from program.consumers import ScheduleConsumer

application = ProtocolTypeRouter({
    "websocket":
    AuthMiddlewareStack(URLRouter([url(r"^schedule/", ScheduleConsumer)]))
})

Exemplo n.º 19

import chat.routing
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter, ChannelNameRouter

application = ProtocolTypeRouter({
    # (http->django views is added by default)
    'websocket': AuthMiddlewareStack(
        URLRouter(
            chat.routing.websocket_urlpatterns
        )
    ),
    'channel': ChannelNameRouter(
        chat.routing.worker_channels
    )
})

Exemplo n.º 20

import os

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from django.core.asgi import get_asgi_application
import chat_feature.routing

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "mysite.settings")

application = ProtocolTypeRouter({
    "http":
    get_asgi_application(),
    "websocket":
    AuthMiddlewareStack(URLRouter(chat_feature.routing.websocket_urlpatterns)),
})

Exemplo n.º 21

Arquivo: routing.py Projeto: lex-c/longing_realtime_emotion_detection

from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
import main.routing as rout

application = ProtocolTypeRouter(
    {'websocket': AuthMiddlewareStack(URLRouter(rout.websocket_urlpatterns))})

Exemplo n.º 22

Arquivo: routing.py Projeto: eitansobel/IDR

from django.urls import path

from channels.routing import ProtocolTypeRouter, URLRouter

from notifications.consumers import DoctorNotificationConsumer
from notifications.web_socket_middleware import CustomAuthMiddlewareStack

application = ProtocolTypeRouter({
    "websocket":
    CustomAuthMiddlewareStack(
        URLRouter([
            path(r'notification/', DoctorNotificationConsumer),
        ]), ),
})

Exemplo n.º 23

Arquivo: routing.py Projeto: tanyabonilla/webproject

from django.urls import re_path
#distinguish users
from django.conf.urls import url
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack

from . import consumers

websocket_urlpatterns = [
    re_path(r'ws/chat/(?P<room_name>\w+)/$', consumers.ChatConsumer),
]

application = ProtocolTypeRouter({
    "websocket":
    AuthMiddlewareStack(
        URLRouter([
            url(r'ws/chat/(?P<room_name>\w+)/$', consumers.ChatConsumer),
        ])),
})

Exemplo n.º 24

Arquivo: asgi.py Projeto: shahid-ullah/bokshi-chat-dev

# chat/asgi.py
import os

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter

from core import routing as core_routing

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "chat.settings")

application = ProtocolTypeRouter({
    "websocket":
    AuthMiddlewareStack(URLRouter(core_routing.websocket_urlpatterns)),
})

Exemplo n.º 25

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from live.jwt_token_auth import JwtTokenAuthMiddleware
import live.routing

application = ProtocolTypeRouter({
    # (http->django views is added by default)
    'websocket': JwtTokenAuthMiddleware(
        URLRouter(
            live.routing.websocket_urlpatterns
        )
    ),
})

Exemplo n.º 26

from quickchat.consumers import ChatConsumer as CC

# for private chat consumer
from privatechat.consumers import ChatConsumer as PCC

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "converse.settings")

# asgi application for routing of web sockets
application = ProtocolTypeRouter({
    # to handle traditional http request
    "http":
    get_asgi_application(),

    # web socket chat handler
    "websocket":
    AuthMiddlewareStack(
        URLRouter(
            [
                url(r'ws/room/(?P<room_name>\w+)/$', ChatConsumer.as_asgi()),
                url(r'ws/quickchat/(?P<room_name>\w+)/(?P<user_handle>\w+)/$',
                    CC.as_asgi()),

                # trying to connect private websocket from here
                url(r'ws/privatechat/(?P<room_id>\w+)/$', PCC.as_asgi()),
            ]

            # room.routing.websocket_urlpatterns,
            # does not with different routing
            # quickchat.routing.websocket_urlpatterns
        )),
})

Exemplo n.º 27

from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
import drowsiness.routing

application = ProtocolTypeRouter({
    #(http->django views is added by default)
    'websocket':
    AuthMiddlewareStack(URLRouter(drowsiness.routing.websocket_urlpatterns))
})

Exemplo n.º 28

Arquivo: routing.py Projeto: elkcarc/EBChess

from channels.routing import ProtocolTypeRouter , URLRouter
from django.conf.urls import url
from channels.auth import AuthMiddlewareStack
from channels.security.websocket import OriginValidator
from main.consumers import ChessBoardConsumer

application = ProtocolTypeRouter({
    'websocket':  AuthMiddlewareStack(
        URLRouter(
            [
                url(r"^active/(?P<active_slug>[\w.@+-]+)/$", ChessBoardConsumer),
                url(r"^game/(?P<game_slug>[\w.@+-]+)/$", ChessBoardConsumer),
            ]
        )
    )
})

Exemplo n.º 29

from channels.routing import ProtocolTypeRouter, URLRouter
from django.urls import path

from adminapp.consumer import NoseyConsumer

application = ProtocolTypeRouter(
    {"websocket": URLRouter([
        path("notifications/", NoseyConsumer),
    ])})

Exemplo n.º 30

from channels.auth import AuthMiddlewareStack
from channels.routing import URLRouter, ProtocolTypeRouter
from django.urls import path

from .consumers import EchoConsumer, NoPasswordConsumer

application = ProtocolTypeRouter({
    "websocket": AuthMiddlewareStack(
        URLRouter([
            path(r"ws/", EchoConsumer),
            path(r"no_password/", NoPasswordConsumer),
        ])
    )
})