def handle_realtime_connect(keyword):
print('received keyword: ' + keyword)
# emit('data_transfer', "json.dumps(data)", broadcast=True)
pubsub = redis.pubsub()
pubsub.subscribe('tweets_processed')
tweets = pubsub.listen()
while True:
try:
message = tweets.next()
processed_tweet = message.get('data')
if not processed_tweet:
continue
try:
data = pickle.loads(processed_tweet)
except TypeError, e:
continue
if not isinstance(data, dict):
continue
if data["text"] and data["lon"] and data["lat"]:
if keyword in data["text"]:
emit('data_transfer', json.dumps(data))
except Exception, e:
emit('die1', e, broadcast=True)
pubsub.unsubscribe('tweets_processed')
print e
return
def handle_realtime_connect(keyword):
print ("received keyword: " + keyword)
pubsub = redis.pubsub()
pubsub.subscribe("sentiment-tweet")
tweets = pubsub.listen()
while True:
try:
message = tweets.next()
raw_tweet = message.get("data")
if not raw_tweet:
continue
tweet = None
if str(raw_tweet)[0] == '"' or str(raw_tweet)[0] == '"': # sns message has backslash in it
tweet = json.loads(str(raw_tweet.decode("string_escape"))[1:-1])
else:
tweet = json.loads(str(raw_tweet))
if not isinstance(tweet, dict):
continue
text = tweet.get("text")
lon = tweet.get("lon")
lat = tweet.get("lat")
sentiment_score = tweet.get("sentiment_score")
data = {"text": text, "lon": lon, "lat": lat, "sentiment_score": sentiment_score}
if text and lon and lat and data:
if keyword in text:
emit("data_transfer", json.dumps(data))
except Exception, e:
emit("die", e, broadcast=True)
pubsub.unsubscribe("twitter_raw")
print e
return
def event_stream(item_id=None):
channel = 'list_view' if item_id is None else 'list_view_{0}'.format(item_id)
pubsub = redis.pubsub()
pubsub.subscribe(channel)
for itm in pubsub.listen():
yield itm
def __init__(self):
self.clients = list()
self.pubsub = redis.pubsub()
self.pubsub.subscribe(REDIS_CHAN)
redis_url = urlparse.urlparse(REDIS_URL)
redisco.connection_setup(
host=redis_url.hostname, port=redis_url.port, password=redis_url.password)
def callback():
global xref
#r = redis.client.StrictRedis()
sub = redis.pubsub()
sub.subscribe(fromRedisIn)
while True:
for m in sub.listen():
xref = float (m['data']) #'Recieved: {0}'.format(m['data'])
print "xref: ", xref
def receiveInformations():
import redis
redis = redis.StrictRedis()
pubsub = redis.pubsub()
pubsub.psubscribe('stats.*')
for message in pubsub.listen():
if message['type'] == 'pmessage':
statistics = json.loads(message['data'])
def getWordCount(msg):
pubsub = redis.pubsub()
pubsub.subscribe('word_count')
message = pubsub.listen()
while True:
try:
count = message.next().get('data')
emit('wordcount_s2c', count)
# print count
except Exception, e:
emit('die2', e, broadcast=True)
pubsub.unsubscribe('word_count')
print e
return
def receiveInformations():
import redis
redis = redis.StrictRedis()
pubsub = redis.pubsub()
pubsub.psubscribe('extra.lookupinfos')
for message in pubsub.listen():
if message['type'] == 'pmessage':
user = json.loads(message['data'])
user_id = user['id_str']
screen_name = user['screen_name']
print "Adding information for %s => %s (STREAM)" % (user_id, screen_name)
database['user:%s' % user_id] = message['data']
def test():
pubsub = redis.pubsub()
pubsub.subscribe('tweets_processed')
tweets = pubsub.listen()
num=0
while True:
print "test:",num
num+=1
message = tweets.next()
processed_tweet = message.get('data')
if not processed_tweet:
continue
try:
processed_tweet_dict = pickle.loads(processed_tweet)
except TypeError, e:
continue
if not isinstance(processed_tweet_dict, dict):
continue
# print processed_tweet_dict['id']
data_filter(processed_tweet_dict)
def main():
"""
main entry point for the program
The return value will be the returncode for the program
"""
_initialize_stderr_logging()
log = logging.getLogger("main")
log.info("program starts")
args = _parse_commandline()
redis = _create_redis_connection()
subscriber = redis.pubsub()
subscriber.subscribe(args.notification_channel)
for message in subscriber.listen():
if message["type"] == "subscribe":
log.info("subscribed to {0}".format(message["channel"]))
elif message["type"] == "message":
_process_message(args, redis, message)
else:
log.error("Unknown message {0}".format(message))
log.info("program completes return code = 0")
return 0
def __init__(self):
self.clients = list()
self.pubsub = redis.pubsub()
self.pubsub.subscribe(REDIS_CHAN)
def __init__(self):
self.clients = list()
self.broadcaster = redis.pubsub()
self.broadcaster.subscribe(DATABASE_BROADCASTER)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import redis
from socketIO_client import SocketIO
REDIS_CONFIG = {
'host': 'localhost',
'port': 6379,
'db': 0,
}
redis = redis.StrictRedis(**REDIS_CONFIG)
pubsub = redis.pubsub(ignore_subscribe_messages=True)
pubsub.subscribe('temperature.value')
socket = SocketIO('localhost', 5000)
for notification in pubsub.listen():
print notification['channel']
print notification['data']
socket.emit('temperature', {'data': notification['data']})
import redis
import time
import json
#run this on python 3.6 pod
# just a simple subscribe to see if things are working as expected
config = json.load(open('./config.json'))
REDIS_HOST = config['redis_host']
REDIS_HOST_PORT = config['redis_host_port']
redis = redis.Redis(host=REDIS_HOST, port=REDIS_HOST_PORT)
tweetstream = redis.pubsub()
tweetstream.subscribe("stream")
if __name__ == '__main__':
while True:
message = tweetstream.get_message()
if message:
print("Tweets published")
print(message["data"])
def __init__(self, redis, request_channel):
self.r = redis
self.p = redis.pubsub(ignore_subscribe_messages=True)
self.request_channel = request_channel
def __init__(self):
self.ps_obj = redis.pubsub()
self.ps_obj.subscribe(commHMI)
def __init__(self, redis_chan):
self.clients = list()
self.pubsub = redis.pubsub()
self.pubsub.subscribe(redis_chan)
def __init__(self, channel):
self.clients = list()
self.pubsub = redis.pubsub()
self.pubsub.subscribe(channel)
#!/usr/bin/env python
import redis
import time
import os
import json
redis = redis.StrictRedis(host='localhost', port=6379, db=0)
channel = redis.pubsub()
queue = os.environ.get('REDIS_ANIMATION_QUEUE')
process = {}
process['moduleName'] = 'mario.py'
# process['moduleName'] = 'scanning-pixel.py'
redis.publish(queue, json.dumps(process))
def __init__(self):
self.clients = {}
self.pubsub = redis.pubsub()
self.pubsub.subscribe(settings.REDIS_CHAN)
def valuebyHour(date):
daydata = sortbyDay(date)
count = 0
hourvalue = []
sendervalue = {}
recvervalue = {}
if daydata is not None:
count = daydata['count']
hourdata = daydata['data']
for h in hourdata:
hourvalue.append(len(h['rockets']))
sender = 'sender_id'
recver = 'recver_id'
rocket = h['rockets']
if len(rocket) != 0:
sendervalue = sortNames(rocket, sender, sendervalue)
recvervalue = sortNames(rocket, recver, recvervalue)
return (count, hourvalue, sendervalue, recvervalue)
else:
return None
# 用于获取弹幕信息和火箭信息的redis 订阅频道
redis = redis.StrictRedis(password='******')
chatcast = redis.pubsub()
chatcast.subscribe('chatinfo')
rocketcast = redis.pubsub()
rocketcast.subscribe('rocketinfo')
def __init__(self):
self.clients = []
self.pubsub = redis.pubsub()
self.pubsub.subscribe('chat')
#!/usr/bin/env python
from real_datas_test import fake_planes
from libPyAirwaves.structs import AdsbType
import time
import config as cfg
import redis
import json
DELAY_MESSAGES = 2 # second
redis = redis.from_url(cfg.REDIS_URL)
pubsub = redis.pubsub()
pubsub.subscribe("room:vehicles")
print("Sending messages...")
try:
sample = "MSG,3,1,1,field_4,1,2019/02/25,20:49:58.331,2019/02/25,20:49:58.361,,field_11,,,field_14,field_15,,field_17,0,,0,0"
foo = sample.split(",")
# "addr": "000000", "idInfo": "LOLK293", "alt": 23000, "aSquawk": "1337"
for coords in fake_planes["planeA"]["path"]:
msg = foo
msg[4] = fake_planes["planeA"]["idInfo"]
msg[11] = str(fake_planes["planeA"]["alt"])
msg[14] = str(coords[1])
msg[15] = str(coords[0])
msg[17] = fake_planes["planeA"]["aSquawk"]
adsb_msg = AdsbType()
def __init__(self):
self.clients = []
self.pubsub = redis.pubsub()
self.pubsub.subscribe('chat')
global current_uuid, player
if player is not None and player.filename is None:
uuid = current_uuid
current_uuid = None
return uuid
else:
return False
def control_callback(message):
global player
if player is not None and player.filename is not None:
playback_pause()
p = redis.pubsub(ignore_subscribe_messages=True)
p.subscribe(musicacontrol=control_callback)
def status_update():
global player
if player is None:
return
redis.set(
"musicastatus",
json.dumps({
"paused": player.paused,
"time": player.time_pos or 0,
"length": player.length or 0
}))
#!/usr/bin/env python
import redis
import time
import os
import json
redis = redis.StrictRedis(host='localhost', port=6379, db=0)
channel = redis.pubsub()
queue = os.environ.get('REDIS_ANIMATION_QUEUE')
process = {}
process['moduleName'] = 'kit.py'
# process['moduleName'] = 'gol-block-switch.py'
# process['moduleName'] = 'gol-acorn.py'
# process['moduleName'] = 'gol-pent.py'
# process['moduleName'] = 'gol-gosper-gun.py'
redis.publish(queue, json.dumps(process))
def __init__(self):
self.clients = list()
self.pubsub = redis.pubsub()
self.pubsub.subscribe(REDIS_CHAN)
self.firebase = firebasin.Firebase("https://gamim.firebaseio.com/")
def __init__(self, rchan):
self.clients = []
self.pubsub = redis.pubsub()
self.pubsub.subscribe(rchan)
if not raw_tweet:
continue
tweet = json.loads(raw_tweet)
# Sometimes we just get back spurious data, like integers and stuff
if not isinstance(tweet, dict):
continue
# Data extraction
tweet_body = tweet.get('text')
user = tweet.get('user', {})
username = user.get('screen_name')
name = user.get('name')
# Data presentation
if tweet_body and name and username:
log_tweet(username, name, tweet_body)
if __name__ == '__main__':
try:
redis = redis.StrictRedis(host='localhost', port=6379, db=0)
pubsub = redis.pubsub()
pubsub.subscribe('twitter_raw')
tweets = pubsub.listen()
consume_subscription(tweets)
except KeyboardInterrupt:
print "\nBye!"
def __init__(self):
self.clients = list()
self.pubsub = redis.pubsub()
self.pubsub.subscribe(REDIS_CHAN)
def __init__(self):
self.tables = dict()
self.pubsub = redis.pubsub()
self.pubsub.subscribe(REDIS_CHAN)
