def long_function(self, timeout, no):
self.working = True
timeout_work = threading.Thread(name="thread_name",
target=self.work_time,
args=(timeout, ))
timeout_work.setDaemon(True)
timeout_work.start()
import logging
import pubnub
from pubnub.exceptions import PubNubException
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub, SubscribeListener
import time
import os
pnconfig = PNConfiguration()
pnconfig.subscribe_key = 'sub-c-b1b31f80-179a-11e8-95aa-1eb18890f15d'
pnconfig.publish_key = ''
pubnub = PubNub(pnconfig)
n = 0
my_listener = SubscribeListener()
pubnub.subscribe().channels('Channel-706fxzjkv').execute()
folder = os.environ['SYSTEMDRIVE'] + r'\Temp'
if os.path.exists(folder):
fp = os.path.join(folder, "new.csv")
else:
os.mkdir(folder)
fp = os.path.join(folder, "new.csv")
sample = ''
for i in list_head:
if i == None:
sample = sample + "None" + ","
else:
sample = sample + i + ","
import sys
reload(sys)
sys.setdefaultencoding('utf8')
with open(fp, 'w') as f:
f.write(sample)
f.write('\n')
while True:
print "Listening..." # endless/long work
pubnub.add_listener(my_listener)
result = my_listener.wait_for_message_on('Channel-706fxzjkv')
pubnub.remove_listener(my_listener)
result = result.message
print result[0]
sample = ""
if (result[0] == KEY):
with open(fp, 'a+') as f:
for i in range(1, len(result)):
if result[i] == None:
sample = sample + "None"
else:
sample = sample + result[i]
f.write(sample)
f.write('\n')
if not self.working: # if state is working == true still working
break
self.set_state(True)
def set_pi_location():
x = request.forms.get('x')
y = request.forms.get('y')
pub = request.forms.get('pub')
sub = request.forms.get('sub')
hostname = request.forms.get('hostname')
success_msg = "<h1>Success</h1>" \
"<p>This Raspberry Pi will use new coordinates on reboot.</p>"
try:
a_lines = [
"\n",
"\n",
"# Set BLE scanner coordinates in meters\n",
"export NODE_X={}\n".format(x),
"export NODE_Y={}\n".format(y),
"\n",
"\n",
"\n",
"# Set PubNub keys\n",
"export PUB_KEY={}\n".format(pub),
"export SUB_KEY={}\n".format(sub),
"\n",
"\n",
"\n",
"# Set desired hostname\n",
"export HOSTNAME={}\n".format(hostname),
"\n",
]
e_lines = [
"NODE_X={}\n".format(x),
"NODE_Y={}\n".format(y),
"PUB_KEY={}\n".format(pub),
"SUB_KEY={}\n".format(sub),
"HOSTNAME={}\n".format(hostname),
]
with open(ACTIVATE_DIR, "a") as f:
f.writelines(a_lines)
with open(ENV_FILE, "a") as f:
f.writelines(e_lines)
except Exception as e:
return template("""
<html>
<body>
<h3>Oops</h3>
<p>{e}</p>
</body>
</html>
""".format(e=e))
try:
init_message = {
"name": os.environ["HOSTNAME"],
"coords": {
"x": x,
"y": y
}
}
env = Path(ENV_FILE)
if env.exists():
dotenv.load_dotenv(str(env.absolute()))
pnconfig = PNConfiguration()
pub_key = os.environ["PUB_KEY"]
sub_key = os.environ["SUB_KEY"]
if pub_key is not None and sub_key is not None:
pnconfig.subscribe_key = sub_key
pnconfig.publish_key = pub_key
pnconfig.ssl = False
pubnub = PubNub(pnconfig)
pubnub.publish() \
.channel('nodes') \
.message(init_message) \
.should_store(True) \
.sync()
return template("""
<html>
<body>
{}
</body>
</html>
""".format(
"<h1>Success</h1>"
"<p>This Raspberry Pi has published new coords.</p>"))
except Exception as e:
success_msg = success_msg + "<p>{}</p>".format(e)
return template("""
<html>
<body>
{success_msg}
</body>
</html>
""".format(success_msg=success_msg))
import threading
import string
import random
import six
from copy import copy
from pubnub import utils
from pubnub.crypto import PubNubCryptodome
from pubnub.pnconfiguration import PNConfiguration
try:
from mock import patch
except ImportError:
from unittest.mock import patch # noqa: F401
crypto = PubNubCryptodome(PNConfiguration())
pub_key = "pub-c-739aa0fc-3ed5-472b-af26-aca1b333ec52"
sub_key = "sub-c-33f55052-190b-11e6-bfbc-02ee2ddab7fe"
pub_key_mock = "pub-c-mock-key"
sub_key_mock = "sub-c-mock-key"
pub_key_pam = "pub-c-98863562-19a6-4760-bf0b-d537d1f5c582"
sub_key_pam = "sub-c-7ba2ac4c-4836-11e6-85a4-0619f8945a4f"
sec_key_pam = "sec-c-MGFkMjQxYjMtNTUxZC00YzE3LWFiZGYtNzUwMjdjNmM3NDhk"
pnconf = PNConfiguration()
pnconf.publish_key = pub_key
pnconf.subscribe_key = sub_key
pnconf.enable_subscribe = False
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
import keys
CHANNEL = "backend-session"
PN_CONFIG = PNConfiguration()
# Get your own keys on PubNub
PN_CONFIG.publish_key = keys.PUBLISH_KEY
PN_CONFIG.subscribe_key = keys.SUBSCRIBE_KEY
def main():
print("********************************************")
print("* Publish messages *")
print("********************************************")
your_name = input("What is your name?: ")
pubnub = PubNub(PN_CONFIG)
while True:
text = input("What do you want to say?: ")
if not text:
print("I didn't hear you...")
continue
the_message = {"sender": your_name, "text": text}
envelope = pubnub.publish().channel(CHANNEL).message(
the_message).sync()
if envelope.status.is_error():
print("[PUBLISH: fail]")
#!/usr/bin/python3
from pubnub.pnconfiguration import PNConfiguration
from pubnub.callbacks import SubscribeCallback
from pubnub.exceptions import PubNubException
from pubnub.pubnub import PubNub, SubscribeListener
import sys
pubconf = PNConfiguration()
pubconf.subscribe_key = 'sub-c-dbf66bda-16b9-11e8-8f67-36fe363f7ef0'
pubconf.publish_key = 'pub-c-14a6f403-3bab-4945-8656-7cba4ca4bb1f'
secret_key = "sec-c-Nzk1ZWE3OTItNjdkOS00ZDVlLThiZjAtODBmMWU2MjI2Y2Ji"
pubconf.ssl = False
pubnub = PubNub(pubconf)
# assign a channel
my_channel = 'pi-weather-station'
my_listener = SubscribeListener()
pubnub.add_listener(my_listener)
#
# pubnub.subscribe(my_channel)
# pubnub.start()
def disconnect_channel():
pubnub.unsubscribe().channels(my_channel).execute()
my_listener.wait_for_disconnect()
print('unsubscribed')
class Base(Configuration):
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'django_nose',
'corsheaders',
'rest_framework',
'rest_framework.authtoken',
'flocarebase.apps.FlocarebaseConfig',
'user_auth.apps.UserAuthConfig',
'phi.apps.PhiConfig',
]
TEST_RUNNER = 'django_nose.NoseTestSuiteRunner'
NOSE_ARGS = [
'--cover-erase',
]
MIDDLEWARE = [
'log_request_id.middleware.RequestIDMiddleware',
'flocarebase.middleware.DBStatsMiddleWare',
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'corsheaders.middleware.CorsMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
# Custom middleware below this
'flocarebase.middleware.UserInformationMiddleware',
]
ROOT_URLCONF = 'backend.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [os.path.join(BASE_DIR, 'templates')],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'backend.wsgi.application'
# Internationalization
# https://docs.djangoproject.com/en/2.0/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Logging related settings
LOGGING_HANDLERS = {
'console': {
'class': 'logging.StreamHandler',
'filters': ['request_id'],
'formatter': 'verbose'
},
'logfile': {
'level': 'DEBUG',
'class': 'logging.handlers.RotatingFileHandler',
'filename': os.path.dirname(BASE_DIR) + "/logs.txt",
'filters': ['request_id'],
'maxBytes': 50000,
'backupCount': 2,
'formatter': 'verbose',
}
}
LOGGING_FORMATTERS = {
'simple': {
'format': '%(levelname)s %(message)s',
},
'verbose': {
'()':
'colorlog.ColoredFormatter',
'format':
'%(log_color)s%(levelname)s (%(asctime)s)[%(request_id)s](%(module)s)(%(filename)s)(%(funcName)s)'
'(%(lineno)d) %(message)s'
}
}
# PubNub Specific Settings
pnconfig = PNConfiguration()
pnconfig.subscribe_key = "INSERT_PUBNUB_SUBSCRIBE_KEY"
pnconfig.publish_key = "INSERT_PUBNUB_PUBLISH_KEY"
pnconfig.ssl = True
PUBNUB = PubNub(pnconfig)
def MotionDetectProc(e):
HoldingInterval = 30
LastCapture = dt.datetime.now()
motionDetected = False
while not e.isSet():
if((dt.datetime.now() - LastCapture).seconds > HoldingInterval):
pir.wait_for_motion(1)
if(pir.motion_detected and (dt.datetime.now() - LastCapture).seconds > HoldingInterval):
motionDetected = True
LastCapture = dt.datetime.now()
DeviceStatus['PIR'] = 1
GPIO.output(RelayPin, GPIO.HIGH)
DeviceStatus['Relay'] = 1
print 'Motion Detected, Relay Opened!'
global CapEvent
CapEvent = threading.Event()
CaptureThread = threading.Thread(target=VideoCaptureProc, args=(CapEvent,))
CaptureThread.start()
### Sync method Publish
pnconfig = PNConfiguration()
### This is for Pubkey and subkey , Channel name
pnconfig.publish_key = 'pub-c-****'
pnconfig.subscribe_key = 'sub-c-***'
Channel = 'TestChannel'
pubnub = PubNub(pnconfig)
Happentime = dt.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
pubnub.publish()\
.channel(Channel)\
.message(['Message', 'Motion is Detected!!!, ' + Happentime])\
.should_store(True)\
.use_post(True)\
.sync()
pir.wait_for_no_motion(1)
if(pir.motion_detected == False):
DeviceStatus['PIR'] = 0
if(pir.motion_detected == False and (dt.datetime.now() - LastCapture).seconds > HoldingInterval)):
GPIO.output(RelayPin, GPIO.LOW)
DeviceStatus['Relay'] = 0
########
DetectEvent = threading.Event()
DetectThread = threading.Thread(target=MotionDetectProc, args=(DetectEvent,))
DetectThread.start()
CapEvent = threading.Event()
# Web serveice proces routines
@app.route("/")
def Index():
templateData = {
'title' : starttime,
'DeviceStatus' : DeviceStatus
}
return render_template("index.html", **templateData)
def setup_pubnub(self):
pnconfig = PNConfiguration()
pnconfig.subscribe_key = self.pubnub_subscribe_key
pnconfig.ssl = False
self.pubnub = PubNub(pnconfig)
self.pubnub.add_listener(self.listener)
def pnconf():
pnconf = PNConfiguration()
pnconf.publish_key = 'demo'
pnconf.subscribe_key = 'demo'
pnconf.enable_subscribe = False
return pnconf
def __init__(self, channels):
self.channels = channels
pnc = PNConfiguration()
pnc.subscribe_key = 'sub-c-52a9ab50-291b-11e5-baaa-0619f8945a4f'
pnc.reconnect_policy = PNReconnectionPolicy.LINEAR
self.pubnub = PubNubTornado(pnc)
def __init__(self):
self.pnconfig = PNConfiguration()
self.CHANNEL = ''
self.pubnub = object
self.status = False
def main():
pnconfig = PNConfiguration()
pnconfig.subscribe_key = 'sub-c-52a9ab50-291b-11e5-baaa-0619f8945a4f'
pubnub = PubNub(pnconfig)
pubnub.add_listener(MySubscribeCallback())
pubnub.subscribe().channels('lightning_executions_BTC_JPY').execute()
try:
from mock import patch
except ImportError:
from unittest.mock import patch # noqa: F401
crypto = PubNubCryptodome()
pub_key = "pub-c-739aa0fc-3ed5-472b-af26-aca1b333ec52"
sub_key = "sub-c-33f55052-190b-11e6-bfbc-02ee2ddab7fe"
pub_key_pam = "pub-c-98863562-19a6-4760-bf0b-d537d1f5c582"
sub_key_pam = "sub-c-7ba2ac4c-4836-11e6-85a4-0619f8945a4f"
sec_key_pam = "sec-c-MGFkMjQxYjMtNTUxZC00YzE3LWFiZGYtNzUwMjdjNmM3NDhk"
pnconf = PNConfiguration()
pnconf.publish_key = pub_key
pnconf.subscribe_key = sub_key
pnconf.enable_subscribe = False
pnconf_sub = PNConfiguration()
pnconf_sub.publish_key = pub_key
pnconf_sub.subscribe_key = sub_key
pnconf_enc = PNConfiguration()
pnconf_enc.publish_key = pub_key
pnconf_enc.subscribe_key = sub_key
pnconf_enc.cipher_key = "testKey"
pnconf_enc.enable_subscribe = False
pnconf_enc_sub = PNConfiguration()
def __init__(self):
self.pnconfig = PNConfiguration()
self.pnconfig.subscribe_key = os.getenv('pbi_subscribe_key')
self.pnconfig.publish_key = os.getenv('pbi_publish_key')
self.pnconfig.ssl = False
self.pubnub = PubNub(self.pnconfig)
try:
from mock import patch
except ImportError:
from unittest.mock import patch # noqa: F401
crypto = PubNubCryptodome()
pub_key = "pub-c-739aa0fc-3ed5-472b-af26-aca1b333ec52"
sub_key = "sub-c-33f55052-190b-11e6-bfbc-02ee2ddab7fe"
pub_key_pam = "pub-c-98863562-19a6-4760-bf0b-d537d1f5c582"
sub_key_pam = "sub-c-7ba2ac4c-4836-11e6-85a4-0619f8945a4f"
sec_key_pam = "sec-c-MGFkMjQxYjMtNTUxZC00YzE3LWFiZGYtNzUwMjdjNmM3NDhk"
pnconf = PNConfiguration()
pnconf.publish_key = pub_key
pnconf.subscribe_key = sub_key
pnconf.enable_subscribe = False
pnconf_sub = PNConfiguration()
pnconf_sub.publish_key = pub_key
pnconf_sub.subscribe_key = sub_key
pnconf_enc = PNConfiguration()
pnconf_enc.publish_key = pub_key
pnconf_enc.subscribe_key = sub_key
pnconf_enc.cipher_key = "testKey"
pnconf_enc.enable_subscribe = False
pnconf_enc_sub = PNConfiguration()
def __init__(self, channel):
pnconfig = PNConfiguration()
pnconfig.subscribe_key = "sub-c-52a9ab50-291b-11e5-baaa-0619f8945a4f"
self.pubnub = PubNub(pnconfig)
self.listener = SubscribeListener()
self.channel = channel
def initialization_config():
pnconfig = PNConfiguration()
pnconfig.subscribe_key = "sub-c-52a9ab50-291b-11e5-baaa-0619f8945a4f"#Bitflyerのsubscribe_key
pnconfig.ssl = False
pubnub = PubNub(pnconfig)
return pubnub
import os import numpy as np from nltk.tokenize import word_tokenize from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.metrics import accuracy_score from nltk.stem.porter import PorterStemmer from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer as VS from keras.utils import np_utils from keras.models import Sequential from keras.layers.core import Dense, Dropout, Activation from textstat.textstat import * from keras.models import load_model import json from keras.models import model_from_json pn_twitter_config = PNConfiguration() pn_twitter_config.subscribe_key = 'sub-c-78806dd4-42a6-11e4-aed8-02ee2ddab7fe' pn_twitter_config.reconnect_policy = PNReconnectionPolicy.EXPONENTIAL pubnub_twitter = PubNub(pn_twitter_config) pn_config = PNConfiguration() pn_config.subscribe_key = 'sub-c-93679206-1202-11e8-bb84-266dd58d78d1' pn_config.publish_key = 'pub-c-44842793-32df-4b69-b576-4495abcf64ec' pubnub_personal = PubNub(pn_config) #TF hack os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' #Change Folder Path here raw_data_path = "/Users/ritiztambi/repos/Twitter-RealtimeAnalysis-Pubnub" os.chdir(raw_data_path)
def long_function(self, timeout, no):
self.working = True
timeout_work = threading.Thread(name="thread_name",
target=self.work_time,
args=(timeout, ))
timeout_work.setDaemon(True)
timeout_work.start()
import logging
import pubnub
from pubnub.exceptions import PubNubException
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub, SubscribeListener
import time
import os
pnconfig = PNConfiguration()
pnconfig.subscribe_key = 'sub-c-5dec13b4-1c6f-11e8-9e0d-86843e43dc8b'
pnconfig.publish_key = ''
pubnub = PubNub(pnconfig)
n = 0
my_listener = SubscribeListener()
pubnub.subscribe().channels('Channel-82ldwdilv').execute()
fp = os.path.join(os.environ['ProgramData'], "new.csv")
header = []
header.append('COMPUTER NAME')
header.append('IP ADDRESS')
for i in range(0, len(fnl_nf) - 3):
header.append('APPLICATION ' + str(i + 1))
with open(fp, 'w+') as f:
f.write(
"\t\t\t\tFIND THE SPECIFIC APPLICATION REPORT FOR ALL DEVICES\t\t\t\t\n"
)
for i in range(0, len(header)):
f.write(str(header[i]) + ',')
f.write('\n')
import sys
reload(sys)
sys.setdefaultencoding('utf8')
while True:
print "Listening..." # endless/long work
pubnub.add_listener(my_listener)
result = my_listener.wait_for_message_on('Channel-82ldwdilv')
n = result.message
pubnub.remove_listener(my_listener)
if (n[0] == key):
with open(fp, 'a') as f:
for i in range(1, len(n)):
f.write(n[i] + ',')
f.write('\n')
if not self.working: # if state is working == true still working
break
self.set_state(True)
import time
import RPi.GPIO as GPIO
from pubnub.callbacks import SubscribeCallback
from pubnub.enums import PNStatusCategory
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
pubnubConf = PNConfiguration()
pubnubConf.subscribe_key = 'sub-c-1aa69146-117c-11e7-9faf-0619f8945a4f'
pubnubConf.publish_key = 'pub-c-a2c67d8e-1b26-4e00-878b-8b74a6ef3393'
pubnubConf.ssl = False
pubnub = PubNub(pubnubConf)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(16, GPIO.OUT)
GPIO.setwarnings(False)
def my_publish_callback(result, status):
# Check whether request successfully completed or not
if not status.is_error():
pass # Message successfully published to specified channel.
print(result)
else:
print(status.original_response)
pass # Handle message publish error. Check 'category' property to find out possible issue
# because of which request did fail.
# Request can be resent using: [status retry];
def setup_pubnub(subscriber_key):
# setup config
pnconfig = PNConfiguration()
pnconfig.subscribe_key = subscriber_key
pnconfig.ssl = False
return PubNub(pnconfig)
class brandlogin(BaseModel):
id = IntegerField(primary_key=True)
BRANDNAME = CharField(max_length=50, unique=True)
BRANDPASSWORD = CharField(max_length=50)
class twitterkey(BaseModel):
id = IntegerField(primary_key=True)
CONSUMERKEY = CharField(max_length=150)
CONSUMERSECRET = CharField(max_length=150)
ACCESSTOKEN = CharField(max_length=150)
ACCESSTOKENSECRET = CharField(max_length=150)
pn_config = PNConfiguration()
pn_config.subscribe_key = 'sub-c-8a88390c-241c-11e8-a8f3-22fca5d72012'
pn_config.publish_key = 'pub-c-61a6bc46-301d-484c-887d-566b4bb5ff3d'
pubnub = PubNub(pn_config)
@app.route('/', methods=['GET', 'POST'])
def home():
if session.get('logged_in'):
session['feel_value'] = ""
return redirect(url_for('result'))
else:
return render_template('login.html')
from pubnub.callbacks import SubscribeCallback
from pubnub.enums import PNStatusCategory
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
from random import randint
import time
pnConfig = PNConfiguration()
pnConfig.subscribe_key = "demo"
pnConfig.publish_key = "demo"
pubnub = PubNub(pnConfig)
def my_publish_callback(envelope, status):
if not status.is_error():
print("publish success")
else:
print("publish fail")
counter = 0
while True:
try:
message = "hello" + str(counter)
pubnub.publish().channel("awesomeChannel").message(message).sync()
time.sleep(1)
counter += 1
except KeyboardInterrupt:
break
from pubnub.callbacks import SubscribeCallback
from pubnub.enums import PNStatusCategory
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
from geolocation.main import GoogleMaps
from time import sleep
google_maps = GoogleMaps(api_key='Your_Google_API_Key')
# Configure Twitter subscribe key
pnconfigTwitter = PNConfiguration()
pnconfigTwitter.subscribe_key = 'sub-c-78806dd4-42a6-11e4-aed8-02ee2ddab7fe'
pubnubTwitter = PubNub(pnconfigTwitter)
# Configure personal subscribe and publish key
pnconfigPersonal = PNConfiguration()
pnconfigPersonal.subscribe_key = 'Your_PubNub_App_Subscribe_Key'
pnconfigPersonal.publish_key = 'Your_PubNub_App_Publish_Key'
pubnubPersonal = PubNub(pnconfigPersonal)
# Callback for any publish
def my_publish_callback(envelope, status):
# Check whether request successfully completed or not
if not status.is_error():
print("Published")
pass # Message successfully published to specified channel.
from pubnub.callbacks import SubscribeCallback
from pubnub.enums import PNStatusCategory
from pubnub.pnconfiguration import PNConfiguration
from pubnub.exceptions import PubNubException
from pubnub.pubnub import PubNub
from random import *
import time
pnconfig = PNConfiguration()
pnconfig.subscribe_key = 'sub-c-cb6369c0-0fdf-11e8-91c1-eac6831c625c'
pnconfig.publish_key = 'pub-c-50d55c74-1141-477e-9456-36f1126859c1'
pubnub = PubNub(pnconfig)
#Set default variables
light = 'green'
vel = 50
temp = 21.2
status = 'OK'
#Traffic lights changes manager
def lights (light):
if (light == 'green'):
light = 'yellow'
return light
if (light == 'yellow'):
light = 'red'
return light
if (light == 'red'):
light = 'green'
class TemperatureMonitor(threading.Thread):
pnconfig = PNConfiguration()
pnconfig.subscribe_key = keys.pubnunb_subscribe_key
pnconfig.publish_key = keys.pubnub_publish_key
pnconfig.ssl = False
pubnub = PubNub(pnconfig)
sense = SenseHat()
class SACListener(SubscribeCallback):
sac_temp = 20
def message(self, pubnub, message):
channel = message.channel
message = message.message
if (channel == 'Temperature_Command_Channel'):
req = message['Request']
print(message)
if (req == 'Get_Data_Load'):
TemperatureMonitor().publish_data(
self.sac_temp, 'Temperature_Data_Load_Channel')
if (req == 'Get_Data_Real_Time'):
TemperatureMonitor().publish_data(
self.sac_temp, 'Temperature_Real_Time_Channel')
if (req == 'Get_Data_Storage'):
TemperatureMonitor().publish_data(
self.sac_temp, 'Temperature_Storage_Channel')
if (req == 'Change_Temp'):
new_temp = message['Temperature']
self.update_temperature(new_temp)
TemperatureMonitor().publish_data(
self.sac_temp, 'Temperature_Data_Load_Channel')
def presence(self, pubnub, presence):
pass
def update_temperature(self, new_temp):
self.sac_temp = new_temp
def publish_callback(self, result, status):
pass
def publish_data(self, sac_temp, channel_name):
dataCollector = DataCollector()
temp = dataCollector.get_temp()
humid = dataCollector.get_humidity()
message = {
'temperature': temp,
'humidity': humid,
'sac_temperature': sac_temp
}
if (channel_name == 'Temperature_Real_Time_Channel'):
message = {
'eon': {
'temperature': temp,
'humidity': humid,
'sac_temperature': sac_temp
}
}
self.pubnub.publish().channel(channel_name).message(message). async (
self.publish_callback)
def listen(self):
listener = self.SACListener()
self.pubnub.add_listener(listener)
self.pubnub.subscribe().channels(
'Temperature_Command_Channel').execute()
def run(self):
self.listen()
