def __init__(self, delegate): self.delegate = delegate pubnub.set_stream_logger('pubnub', logging.DEBUG) pnconfig = PNConfiguration() pnconfig.subscribe_key = "sub-c-d5c0f6b8-f436-11e7-b8a6-46d99af2bb8c" pnconfig.publish_key = "pub-c-79775796-e891-4ba0-8e96-af4a5dd71beb" pnconfig.ssl = False self.pubnub = PubNub(pnconfig) self.pubnub.subscribe().channels("create").execute() (self.pubnub.subscribe().channels(i).execute() for i in range(NUM_CORES)) self.pubnub.add_listener(self) self.async_changed = False
async def subscripbe_for_realtime_updates(self) -> None: """Subscribes to PubNub for realtime updates.""" # make a call to vivint's userauth endpoint authuser_data = await self.vivintskyapi.get_authuser_data() pubnub.set_stream_logger("pubnub", logging.INFO) pnconfig = PNConfiguration() pnconfig.subscribe_key = PN_SUBSCRIBE_KEY pnconfig.ssl = True pnconfig.reconnect_policy = PNReconnectionPolicy.LINEAR pnconfig.heartbeat_notification_options = PNHeartbeatNotificationOptions.ALL self.__pubnub = PubNubAsyncio(pnconfig) self.__pubnub.add_listener( VivintPubNubSubscribeListener(self.handle_pubnub_message) ) pn_channel = f'{PN_CHANNEL}#{authuser_data[AuthUserAttributes.Users][AuthUserAttributes.UsersAttributes.MessageBroadcastChannel]}' # noqa self.__pubnub.subscribe().channels(pn_channel).with_presence().execute()
async def subscribe_for_realtime_updates(self, authuser_data: dict = None) -> None: """Subscribes to PubNub for realtime updates.""" # make a call to vivint's authuser endpoint to get message broadcast channel if not supplied if not authuser_data: authuser_data = await self.vivintskyapi.get_authuser_data() pubnub.set_stream_logger("pubnub", logging.INFO) pnconfig = PNConfiguration() pnconfig.subscribe_key = PN_SUBSCRIBE_KEY pnconfig.ssl = True pnconfig.reconnect_policy = PNReconnectionPolicy.LINEAR pnconfig.heartbeat_notification_options = PNHeartbeatNotificationOptions.ALL self.__pubnub = PubNubAsyncio(pnconfig) self.__pubnub.add_listener( VivintPubNubSubscribeListener(self.handle_pubnub_message) ) pn_channel = f"{PN_CHANNEL}#{authuser_data[AuthUserAttribute.USERS][AuthUserAttribute.UserAttribute.MESSAGE_BROADCAST_CHANNEL]}" self.__pubnub.subscribe().channels(pn_channel).with_presence().execute()
self.pnconfig.publish_key = conf.get("publish_key") if self.pnconfig.publish_key is None: raise PubSubError("publish key is not configured") self.pnconfig.ssl = conf.get("ssl", False) self._channels = conf.get("channels") self._pubnub = PubNub(self.pnconfig) def publish(self, data, meta=None, channels=None): # TODO: throttle or queue up messages chs = channels or self._channels if isinstance(chs, str): chs = [chs] elif chs is None: raise PubSubError("need publish channel") for ch in chs: p = self._pubnub.publish().channel(ch) p.message(data) if meta: p.meta(meta) envelope = p.sync() if envelope.status.is_error(): raise PubSubError("Error publishing to {}: {}".format( ch, envelope.status.error)) if __name__ == "__main__": pubnub.set_stream_logger('pubnub', logging.ERROR) pubsub = PubSub() pubsub.publish({"text": "just published this!"})
import unittest import logging import time import pubnub import threading from pubnub.pubnub import PubNub, SubscribeListener, NonSubscribeListener from tests import helper from tests.helper import pnconf_sub_copy pubnub.set_stream_logger('pubnub', logging.DEBUG) class TestPubNubState(unittest.TestCase): def setUp(self): self.event = threading.Event() def callback(self, response, status): self.response = response self.status = status self.event.set() def test_single_channel(self): pubnub = PubNub(pnconf_sub_copy()) ch = helper.gen_channel("wherenow-asyncio-channel") uuid = helper.gen_channel("wherenow-asyncio-uuid") pubnub.config.uuid = uuid subscribe_listener = SubscribeListener() where_now_listener = NonSubscribeListener() pubnub.add_listener(subscribe_listener)
import tornado import logging import pubnub as pn from tornado.testing import AsyncTestCase from pubnub.pubnub_tornado import PubNubTornado from tests.helper import pnconf_copy from tests.integrational.tornado.vcr_tornado_decorator import use_cassette_and_stub_time_sleep pn.set_stream_logger('pubnub', logging.DEBUG) class TestPubNubState(AsyncTestCase): def setUp(self): super(TestPubNubState, self).setUp() self.pubnub = PubNubTornado(pnconf_copy(), custom_ioloop=self.io_loop) @use_cassette_and_stub_time_sleep( 'tests/integrational/fixtures/tornado/state/single_channel.yaml', filter_query_parameters=['uuid', 'seqn', 'pnsdk'], match_on=['method', 'host', 'path', 'state_object_in_query']) @tornado.testing.gen_test def test_state_single_channel(self): ch = "state-tornado-ch" self.pubnub.config.uuid = 'state-tornado-uuid' state = {"name": "Alex", "count": 5} env = yield self.pubnub.set_state() \ .channels(ch) \ .state(state) \
# PubNub HereNow usage example import logging import os import sys d = os.path.dirname PUBNUB_ROOT = d(d(os.path.dirname(os.path.abspath(__file__)))) sys.path.append(PUBNUB_ROOT) import pubnub from examples import pnconf from pubnub.pubnub import PubNub, NonSubscribeListener pubnub.set_stream_logger('pubnub', logging.DEBUG, stream=sys.stdout) pubnub = PubNub(pnconf) listener = NonSubscribeListener() pubnub.publish() \ .channel("blah") \ .message("hey") \ .async(listener.callback) result = listener.await_result_and_reset(5) # FIX: returns None print(result) pubnub.stop()
import logging import constants import settings from logger import config_logging from vendored.lirc import Lirc import pubnub from pubnub.callbacks import SubscribeCallback from pubnub.enums import PNStatusCategory from pubnub.pnconfiguration import PNConfiguration from pubnub.pubnub import PubNub logger = config_logging(settings.LOG_LEVEL, settings.LOG_FILE) pubnub.set_stream_logger('pubnub', logging.WARNING) pnconfig = PNConfiguration() pnconfig.subscribe_key = settings.SUBSCRIBE_KEY pnconfig.publish_key = settings.PUBLISH_KEY pnconfig.ssl = True pubnub_client = PubNub(pnconfig) lirc = Lirc() class KeyPressSubscribeCallback(SubscribeCallback): def presence(self, pubnub, presence): pass # handle incoming presence data
import asyncio import pytest import logging import pubnub as pn from pubnub.models.consumer.presence import PNSetStateResult, PNGetStateResult from pubnub.pubnub_asyncio import PubNubAsyncio from tests.helper import pnconf, pnconf_copy, pnconf_sub_copy, pnconf_pam_copy from tests.integrational.vcr_asyncio_sleeper import get_sleeper, VCR599Listener from tests.integrational.vcr_helper import pn_vcr pn.set_stream_logger("pubnub", logging.DEBUG) @pn_vcr.use_cassette( "tests/integrational/fixtures/asyncio/state/single_channel.yaml", filter_query_parameters=["uuid", "pnsdk"], match_on=["method", "host", "path", "state_object_in_query"], ) @pytest.mark.asyncio def test_single_channelx(event_loop): pubnub = PubNubAsyncio(pnconf_copy(), custom_event_loop=event_loop) ch = "test-state-asyncio-ch" pubnub.config.uuid = "test-state-asyncio-uuid" state = {"name": "Alex", "count": 5} env = yield from pubnub.set_state().channels(ch).state(state).future() assert env.result.state["name"] == "Alex" assert env.result.state["count"] == 5
# get env import os # random generator import secrets, string # TUI for ask pseudo import curses from curses.textpad import Textbox # to ensure that every pseudo will be the only one # PubNub import pubnub from pubnub.pubnub import PubNub from pubnub.pnconfiguration import PNConfiguration from pubnub.enums import PNReconnectionPolicy pubnub.set_stream_logger('pubnub', level=pubnub.logging.CRITICAL) def initPubNub(stdscr): """ Ask for a pseudo if not in the path and init the pubnub.PubNub object. Parameters ---------- stdscr: :class:curses._CursesWindow the screen initialised in main.py Returns ------- :class:pubnub.PubNub with configuration
# PubNub HereNow usage example import logging import os import sys d = os.path.dirname PUBNUB_ROOT = d(d(os.path.dirname(os.path.abspath(__file__)))) sys.path.append(PUBNUB_ROOT) import pubnub from examples import pnconf from pubnub.pubnub import PubNub, NonSubscribeListener pubnub.set_stream_logger("pubnub", logging.DEBUG, stream=sys.stdout) pubnub = PubNub(pnconf) listener = NonSubscribeListener() pubnub.publish().channel("blah").message("hey").async(listener.callback) result = listener.await_result_and_reset(5) # FIX: returns None print(result) pubnub.stop()