def __init__(self,
url,
magic_phrase,
max_turns=10,
callback=None,
callback_params=1,
msg_q=False):
print('starting service')
self.start_proba = 1.0
self.magic_phrase = magic_phrase
self.url = replace_localhost(url)
self.bot = Alice()
self.max_turns = max_turns
self.sending_message = False
self._id = None
self.use_msg_q = msg_q # msg_q sets whether or not we are queueing messages
self.websocket = 'ws://%s/websocket' % self.url
self.client = MeteorClient(self.websocket)
self.client.ddp_client.ddpsocket.extra_headers = [('Bot', 'true')]
print(self.client.ddp_client.ddpsocket.handshake_headers)
self.client.connect()
self.idle_time = 3 * 60
self.thread_time = 2
self.max_retry = 3
def __init__(self,
username,
password,
api_key,
debug=False,
no_meteor=False):
self.username = username
self.encoded_password = password.encode() if password else None
if not no_meteor:
self.meteor_client = MeteorClient(SOCKET_BASE, debug=debug)
else:
self.meteor_client = None
self.http = DicecloudHTTP(API_BASE, api_key, debug=debug)
self.logged_in = False
self.debug = debug
def get_new_login(server_url, callback=None):
""" queries the server to give a new login"""
server_url = replace_localhost(server_url)
# connects to the server
websocket = 'ws://%s/websocket' % server_url
client = MeteorClient(websocket)
client.connect()
def cb(error, data):
client.close()
if callback:
callback(error, data)
# queries the method with a magicphrase
client.call('getBotUsername', magic_phrase, cb)
def __init__(self, user, password, server='demo.rocket.chat'):
self.username = user
self.password = password
self.server = server
self.debug = True
self._prefixs = []
self.client = client = MeteorClient('wss://demo.rocket.chat/websocket')
# registering internal handlers
self.client.on('connected', self._connected)
self.client.on('closed', self._closed)
self.client.on('logging_in', self._logging_in)
self.client.on('failed', self._failed)
self.client.on('added', self._added)
self.client.on('changed', self._changed)
self.client.on('unsubscribed', self._unsubscribed)
self.client.on('subscribed', self._subscribed)
def __init__(self, user, password, server):
self.username = user
self.password = password
self.server = server
self.debug = True
self._prefixs = []
self.client = client = MeteorClient(server)
# registering internal handlers (callbacks)
self.client.on('logging_in', self._logging_in)
self.client.on('connected', self._connected)
self.client.on('closed', self._closed)
self.client.on('failed', self._failed)
self.client.on('added', self._added)
self.client.on('changed', self._changed)
self.client.on('unsubscribed', self._unsubscribed)
self.client.on('subscribed', self._subscribed)
self.messages = []
import time
from MeteorClient import MeteorClient
from datetime import datetime, timedelta
from threading import Thread, Lock
from collections import namedtuple
from operator import attrgetter
USERNAME = '******'
PASSWORD = '******'
SERVER = 'ws://152.228.80.179:3000/websocket'
client = MeteorClient(SERVER)
# How do we handle changes that are close to the dispensing period?
# Keep a copy, then wipe the schedule. If the dosage is not scheduled for today... just add it
# Otherwise, check if the time has already been passed... if it has skip it
# If the time is close to the current time, check to see if it's already been/being dispensed
# if it has, then skip it
# Otherwise just add it...
class Scheduler:
def __init__(self):
# Initialize the schedule
self.schedule = []
# Start the dispensing task
Thread(target = self.dispense).start()
def refresh_schedule(self):
threadLock.acquire()
# In reality we shouldn't just naively wipe out the old schedule
# like this
self.schedule = []
import time
from MeteorClient import MeteorClient
client = MeteorClient('ws://127.0.0.1:3000/websocket', debug=True)
client.connect()
client.subscribe('SessionsList')
time.sleep(1)
sessions = client.find('sessions')
print(sessions)
time.sleep(1)
import os
import time
from MeteorClient import MeteorClient
UNAME = os.environ.get('DICECLOUD_USER', '')
PWD = os.environ.get('DICECLOUD_PWD', '').encode()
client = MeteorClient('ws://dicecloud.com/websocket', debug=True)
client.connect()
print("Connected")
while not client.connected:
time.sleep(0.1)
client.login(UNAME, PWD)
print("Logged in")
time.sleep(1) # wait until users collection has updated
USER_ID = client.find_one('users', selector={'username': UNAME}).get('_id')
print("User ID: " + USER_ID)
char_id = 'Mtx98jb3c3wWcrWPj'
def main():
# check_char()
test_id()
def test_id():
client.insert('characters', {
def serve_once(self):
"""
Run the bot until the connection is disconnected.
:return: None.
"""
# Log message
self._log_debug('# ----- serve_once -----')
# Log message
self._log_debug(('# ----- Create meteor client -----\n'
'SERVER_URI: {}').format(self._server_uri))
# Create meteor client
self._meteor_client = MeteorClient(
self._server_uri,
# Disable the meteor client's auto reconnect.
# Let `serve_forever` handle reconnect.
auto_reconnect=False,
)
# Log message
self._log_debug('# ----- Hook meteor client callbacks -----')
# 5DI82
# Hook meteor client `connected` callback
self._meteor_client.on('connected', self._meteor_connected_callback)
# 2RAYF
# Hook meteor client `changed` callback
self._meteor_client.on('changed', self._meteor_changed_callback)
# 4XIZB
# Hook meteor client `added` callback
self._meteor_client.on('added', self._meteor_added_callback)
# 2JEIK
# Hook meteor client `removed` callback
self._meteor_client.on('removed', self._meteor_removed_callback)
# 32TF2
# Hook meteor client `failed` callback
self._meteor_client.on('failed', self._meteor_failed_callback)
# 5W6RX
# Hook meteor client `reconnected` callback
self._meteor_client.on('reconnected',
self._meteor_reconnected_callback)
# 7MOJX
# Hook meteor client `closed` callback
self._meteor_client.on('closed', self._meteor_closed_callback)
# Clear the event
self._subscribing_done_event.clear()
# Clear the event
self._meteor_closed_event.clear()
# Log message
self._log_debug('# ----- Connect to meteor server -----')
try:
# Connect to meteor server.
#
# If the connecting succeeds, the meteor client's thread will call
# `self._meteor_connected_callback` hooked at 5DI82. The login,
# topic subscribing, and message handling are run in that thread.
#
# The main thread merely waits until the meteor client is closed,
# meanwhile it calls heartbeat function at interval if specified.
#
self._meteor_client.connect()
# If have error
except:
# Log message
self._log_debug('# ----- Connecting failed -----')
# Log message
self._log_debug('# ----- Unhook meteor client callbacks -----')
# Remove meteor client callbacks
self._meteor_client.remove_all_listeners()
# Remove meteor client reference
self._meteor_client = None
# The two events below should not have been set if the connecting
# failed. Just in case.
#
# Clear the event
self._subscribing_done_event.clear()
# Clear the event
self._meteor_closed_event.clear()
# Raise the error
raise
# Get whether heartbeat is enabled
heartbeat_enabled = self._get_bool_config(
CONFIG_KEYS.HEARTBEAT_ENABLED)
try:
# Wait until the topic subscribing is done in another thread at
# 5MS7A
self._subscribing_done_event.wait()
# If heartbeat is enabled
if heartbeat_enabled:
# Get heartbeat function
heartbeat_func = self._get_config(CONFIG_KEYS.HEARTBEAT_FUNC)
# Assert the function is callable
assert callable(heartbeat_func), repr(heartbeat_func)
# Get heartbeat interval
heartbeat_interval = self._get_config(
CONFIG_KEYS.HEARTBEAT_INTERVAL,
default=10,
)
# Convert heartbeat interval to float
heartbeat_interval = float(heartbeat_interval)
# 65ZNO
# Loop until the meteor client is disconnected
while self._meteor_client.connected:
# Send heartbeat
heartbeat_func(self)
# Sleep before sending next heartbeat
time.sleep(heartbeat_interval)
# 5W6XQ
# Wait until the meteor client is closed and the `closed` callback
# is called at 3DMYH
self._meteor_closed_event.wait()
# If have error
except:
# Close meteor client.
#
# This will cause `self._meteor_closed_callback` to be called,
# which will set the `self._meteor_closed_event` below.
#
self._meteor_client.close()
# See 5W6XQ
self._meteor_closed_event.wait()
# Raise the error
raise
# Always do
finally:
# Log message
self._log_debug('# ----- Unhook meteor client callbacks -----')
# Remove meteor client callbacks
self._meteor_client.remove_all_listeners()
# Remove meteor client reference.
#
# Do this before calling `callback_presence` below so that the
# plugins will not be able to access the already closed client.
#
self._meteor_client = None
# Log message
self._log_debug('# ----- Call `callback_presence` -----')
# Call `callback_presence`
self.callback_presence(
Presence(identifier=self.bot_identifier, status=OFFLINE))
# Log message
self._log_debug('# ----- Call `disconnect_callback` -----')
# Call `disconnect_callback` to unload plugins
self.disconnect_callback()
# Clear the event
self._subscribing_done_event.clear()
# Clear the event
self._meteor_closed_event.clear()
# Log message
self._log_debug('# ===== serve_once =====')
REFINER1_ID = 'refiner1id'
REFINER2_ID = 'refiner12id'
OBJS = {
# REFINER1_ID: {
# 'sensor':
# 'pin':
# },
# REFINER2_ID: {
# 'sensor':
# 'pin':
# }
}
client = MeteorClient(URL, auto_reconnect=False, auto_reconnect_timeout=10)
# def hello():
# print "hello, world"
# t = Timer(30.0, hello)
# t.start()
def temp(id):
sensor = OBJS[id]['sensor']
if sensor:
t = sensor.get_temperature(W1ThermSensor.DEGREES_F)
print 'Temp is: %.2f' % t
return t
else:
def __init__(self, debug=False):
self.meteor_client = MeteorClient(SOCKET_BASE, debug=debug)
self.http = DicecloudHTTP(API_BASE, API_KEY, debug=debug)
self.logged_in = False
def __init__(self):
Thread.__init__(self)
self.meteor = conf.get('ddp', 'meteor')
self.client = MeteorClient(self.meteor, debug=False)
self.client.on('added', self.on_added)
self.client.on('changed', self.on_changed)
self.client.on('subscribed', self.on_subscribed)
self.client.on('connected', self.on_connected)
self.client.on('removed', self.on_removed)
self.client.on('closed', self.on_closed)
self.client.on('logged_in', self.on_logged_in)
self.displayName = conf.get('ddp', 'room_name')
self.vu_min = -50
self.vu_range = 50
self.vu_data = 0
self.last_vu = None
self.ip = conf.get('ingest', 'address')
self.id = conf.get('ingest', 'hostname')
self._user = conf.get('ddp', 'user')
self._password = conf.get('ddp', 'password')
self._http_host = conf.get('ddp', 'http_host')
self._audiostream_port = conf.get('audiostream', 'port') or 31337
self.store_audio = conf.get_boolean('ddp', 'store_audio')
self.screenshot_file = conf.get('ddp', 'existing_screenshot')
self.high_quality = conf.get_boolean('ddp', 'hq_snapshot')
self.paused = False
self.recording = False
self.currentMediaPackage = None
self.currentProfile = None
self.has_disconnected = False
screen = Gdk.Screen.get_default()
self._screen_width = screen.get_width()
self._screen_height = screen.get_height()
self.cardindex = None
cam_available = conf.get('ddp', 'cam_available') or 0
if cam_available in ('True', 'true', True, '1', 1):
self.cam_available = 1
elif cam_available in ('False', 'false', False, '0', 0):
self.cam_available = 0
else:
self.cam_available = int(cam_available)
# Getting audiostream params. either using existing audiostreaming server like icecast or the audiostream plugin
if conf.get('ddp', 'existing_stream_host'):
self._stream_host = conf.get('ddp', 'existing_stream_host')
else:
self._stream_host = self.ip
if conf.get_int('ddp', 'existing_stream_port'):
self._audiostream_port = conf.get_int('ddp',
'existing_stream_port')
else:
self._audiostream_port = conf.get_int('audiostream',
'port') or 31337
if conf.get('ddp', 'existing_stream_key'):
self.stream_key = conf.get('ddp', 'existing_stream_key')
else:
self.stream_key = uuid.uuid4().get_hex()
if conf.get('ddp', 'extra_params'):
self.extra_params_list = conf.get('ddp', 'extra_params').split(';')
else:
self.extra_params_list = []
logger.info(
'audiostream URI: {}'.format('http://' + self._stream_host + ':' +
str(self._audiostream_port) + '/' +
self.stream_key))
dispatcher.connect('init', self.on_init)
dispatcher.connect('recorder-vumeter', self.vumeter)
dispatcher.connect('timer-short', self.update_vu)
dispatcher.connect('timer-short', self.heartbeat)
dispatcher.connect('recorder-started', self.on_start_recording)
dispatcher.connect('recorder-stopped', self.on_stop_recording)
dispatcher.connect('recorder-status', self.on_rec_status_update)
print collection
print fields
def changed(collection, id, fields, cleared):
print ("changed:{}".format(id) + " fields: {}".format(fields))
def connected():
print('* CONNECTED')
client.login("test", "test")
def subscription_callback(error):
if error:
print(error)
try:
client = MeteorClient('ws://rbmobility.emtmadrid.es:3333/websocket', auto_reconnect = True, auto_reconnect_timeout = 5, debug = False)
client.on('subscribed', subscribed)
client.on('unsubscribed', unsubscribed)
client.on('added', added)
client.on('connected', connected)
client.on('changed',changed)
client.connect()
# ctrl + c to kill the script
while True:
try:
time.sleep(1)
except KeyboardInterrupt:
def __init__(self):
Thread.__init__(self)
self.meteor = conf.get('ddp', 'meteor')
self.client = MeteorClient(self.meteor, debug=False)
self.client.on('added', self.on_added)
self.client.on('changed', self.on_changed)
self.client.on('subscribed', self.on_subscribed)
self.client.on('connected', self.on_connected)
self.client.on('removed', self.on_removed)
self.client.on('closed', self.on_closed)
self.client.on('logged_in', self.on_logged_in)
self.displayName = conf.get('sussexlogin', 'room_name')
self.vu_min = -70
self.vu_range = 40
self.do_vu = 0
self.last_vu = None
self.ip = socket.gethostbyname(socket.gethostname())
self.id = conf.get('ingest', 'hostname')
self._user = conf.get('ddp', 'user')
self._password = conf.get('ddp', 'password')
self._http_host = conf.get('ddp', 'http_host')
self._audiostream_port = conf.get('audiostream', 'port') or 31337
self.netreg_id = conf.get('ddp', 'netreg_id')
self.store_audio = conf.get_boolean('ddp', 'store_audio')
self.paused = False
self.recording = False
self.currentMediaPackage = None
self.currentProfile = None
self.has_disconnected = False
cam_available = conf.get('sussexlogin',
'cam_available') or cam_available
if cam_available in ('True', 'true', True, '1', 1):
self.cam_available = 1
elif cam_available in ('False', 'false', False, '0', 0):
self.cam_available = 0
else:
self.cam_available = int(cam_available)
self.audiofaders = []
faders = conf.get('ddp', 'audiofaders').split()
for fader in faders:
audiofader = {}
fader = 'audiofader-' + fader
audiofader['name'] = conf.get(fader, 'name')
audiofader['display'] = conf.get(fader, 'display')
audiofader['min'] = conf.get_int(fader, 'min')
audiofader['max'] = conf.get_int(fader, 'max')
audiofader['type'] = conf.get(fader, 'type')
audiofader['setrec'] = conf.get_boolean(fader, 'setrec')
audiofader['mute'] = conf.get_boolean(fader, 'mute')
audiofader['unmute'] = conf.get_boolean(fader, 'unmute')
audiofader['setlevel'] = conf.get_int(fader, 'setlevel')
try:
audiofader['control'] = alsaaudio.Mixer(
control=audiofader['name'])
self.audiofaders.append(audiofader)
except Exception as e:
logger.warn(e)
fd, eventmask = self.audiofaders[0]['control'].polldescriptors()[0]
self.watchid = gobject.io_add_watch(fd, eventmask, self.mixer_changed)
dispatcher.connect('galicaster-init', self.on_init)
dispatcher.connect('update-rec-vumeter', self.vumeter)
dispatcher.connect('galicaster-notify-timer-short', self.heartbeat)
dispatcher.connect('start-before', self.on_start_recording)
dispatcher.connect('restart-preview', self.on_stop_recording)
dispatcher.connect('update-rec-status', self.on_rec_status_update)
REFINER1_ID = 'refiner1id'
REFINER2_ID = 'refiner12id'
OBJS = {
# REFINER1_ID: {
# 'sensor':
# 'pin':
# },
# REFINER2_ID: {
# 'sensor':
# 'pin':
# }
}
client = MeteorClient(URL)
# def hello():
# print "hello, world"
# t = Timer(30.0, hello)
# t.start()
def temp(id):
sensor = OBJS[id]['sensor']
if sensor:
t = sensor.get_temperature(W1ThermSensor.DEGREES_F)
print 'Temp is: %.2f' % t
return t
else:
import time
from MeteorClient import MeteorClient
client = MeteorClient('ws://127.0.0.1:8000')
client.connect()
client.subscribe('kittens')
client.subscribe('a')
while True:
time.sleep(.5)
import time
from MeteorClient import MeteorClient
client = MeteorClient('ws://127.0.0.1:3000/websocket')
def subscribed(subscription):
print('* SUBSCRIBED {}'.format(subscription))
def unsubscribed(subscription):
print('* UNSUBSCRIBED {}'.format(subscription))
def added(collection, id, fields):
print('* ADDED {} {}'.format(collection, id))
for key, value in fields.items():
print(' - FIELD {} {}'.format(key, value))
# query the data each time something has been added to
# a collection to see the data `grow`
all_lists = client.find('lists', selector={})
print('Lists: {}'.format(all_lists))
print('Num lists: {}'.format(len(all_lists)))
# if collection == 'list' you could subscribe to the list here
# with something like
# client.subscribe('todos', id)
# all_todos = client.find('todos', selector={})
# print 'Todos: {}'.format(all_todos)
configuration.LED_B_PINS[0], connection)
for i in range(1, len(configuration.LED_R_PINS)):
led.addLED(configuration.LED_R_PINS[i], configuration.LED_G_PINS[i],
configuration.LED_B_PINS[i])
led.setColor(0, 0, 255)
arduino = ArduinoApi(connection=connection)
arduino.pinMode(configuration.PUMP_PIN, arduino.OUTPUT)
for pin in configuration.VALVE_PINS:
arduino.pinMode(pin, arduino.OUTPUT)
scale = Hx711(configuration.LOAD_CELL_DOUT_PIN,
configuration.LOAD_CELL_SCK_PIN, connection)
client = MeteorClient(configuration.SERVER)
def write_log(type, message):
client.call('log.insert', [type, message])
def update_callback(error, data):
if error:
write_log('error', 'Error on update: {}'.format(error))
def insert_callback(error, data):
if error:
write_log('error', 'Error on insert: {}'.format(error))
mc.subscribe("buttons", callback=mcSubscribeCallback)
mc.subscribe("screensets", callback=mcSubscribeCallback)
mc.subscribe("organisations", callback=mcSubscribeCallback)
print("{}: Subscribied".format(nicetime(time.time())))
event.set()
return True
except Exception as ex:
print(
"mcLoggedIn. Already subscribed, exception type {}, exception: {}".
format(type(ex), ex.args))
return False
if __name__ == '__main__':
meteor_websocket = "ws://staging.spur.site/websocket"
mc = MeteorClient(meteor_websocket)
mc.on('connected', mcConnected)
mc.on('logging_in', mcLoggingIn)
mc.on('logged_in', mcLoggedIn)
mc.on('logged_out', mcLoggedOut)
mc.on('failed', mcFailed)
mc.on('closed', mcClosed)
mc.on('subscribed', mcSubscribed)
mc.on('added', mcAdded)
mc.on('changed', mcChanged)
mc.on('removed', mcRemoved)
print("{}: Connecting".format(nicetime(time.time())))
event = threading.Event()
mc.connect()
subscribe()
event.wait()
def __init__(self, queue):
self.run = None
self.queue = queue
self.thread = threading.Thread(target=self.work)
self.client = MeteorClient('ws://127.0.0.1:3000/websocket')
self.client.on('connected', self.connected_event)
self.client.connect()
self.configs = {
# run
'start_run': {
'method': 'startRun',
'callback': self.handle_run_call
},
# suites
'start_suite': {'method': 'startSuite'},
'end_suite': {'method': 'endSuite'},
# tests
'start_test': {'method': 'startTest'},
'end_test': {'method': 'endTest'},
# keywords
'start_keyword': {'method': 'startKeyword'},
'end_keyword': {'method': 'endKeyword'},
# messages
'log_message': {'method': 'logMessage'}
}
