def main():
global myMessenger, msgTryTimer
global extProcCall, iksResolver
global ipkSpawner
extProcCall = extprocall.ProcConduit()
iksResolver = iksresolver.IKSResolver()
ipkSpawner = ipkspawner.IPKSpawner()
PyREEM.onUserLogOn = userLogon
PyREEM.onUserLogOff = userLogoff
PyREEM.onTimer = timerActions
PyREEM.onTimerLapsed = timerLapsedActions
PyREEM.onRemoteCommand = remoteCommandActions
PyREEM.onSystemShutdown = systemShutdownActions
PyREEM.onPowerPluggedChange = powerPlugChangeActions
PyREEM.onBatteryChargeChange = batteryChargeChangeActions
PyREEM.onNodeStatusUpdate = nodeStatusUpdate
myMessenger = messenger.Messenger()
if not myMessenger.checkin():
msgTryTimer = PyREEM.addTimer( 10*60, -1, 10*60 )
PyREEM.say( constants.INTRO_TEXT )
PyREEM.setLowPowerThreshold( 20 )
def __init__(self, account, message_handler=None):
"""Reads configuration file and asks the data handler for the API info."""
self.msg = messenger.Messenger(message_handler)
# Register cleanup function when program exits
atexit.register(self._cleanup)
self._load(account)
self._init_data_handler()
def messenger_worker(username, frequency, min_bid, max_bid, offers):
# create a messenger script to communicate
# with its corresponding client
msgr = messenger.Messenger(username, frequency, min_bid, max_bid, offers)
msgr.simulate()
return
def setUp(self):
import messenger
import preferences
preferences.setVariable("starred-classes", ["help"])
preferences.setVariable("signature", "")
preferences.setVariable("hidden-classes", ["message"])
self.messenger = messenger.Messenger("ME", ":memory:")
def init_im(self):
self.m = messenger.Messenger(self.jid, self.passwd)
self.m.handler_new_message = self.OnMsgRcvd
self.m.handler_sent_message = self.OnMsgSent
self.m.set_recipient('*****@*****.**')
self.m.connect()
self.m.start()
def main():
boring_redis_bus_name = redis.StrictRedis()
# collects data from exchange
exchange_stream = messenger.Messenger(boring_redis_bus_name, products='BTC-USD')
exchange_stream.sub(target='client')
# collects data for specific tag and gets stats on it
stats_stream = messenger.Messenger(sbus=boring_redis_bus_name)
stats_stream.sub(target='schoolbus', key='gdax_btcusd_done')
stats_stream.get_stats(['moving_average'], .5, outkey='test', ma_num_msg=[10, 20, 30, 40, 50], max_size=100)
# listens for the stats under 'test' key
listener = messenger.Messenger(boring_redis_bus_name)
listener.sub(target='schoolbus', key='test')
pp = pprint.PrettyPrinter(indent=4)
[pp.pprint(stats.Stats.decode_data(msg)) for msg in listener.listen_to_stream()]
def __call_async__(self, commander):
(self.pid, self.r_pipe, self.w_pipe, self.stdin_pipe,
self.stdout_pipe, self.stderr_pipe) = create_process_cmd()
if self.pid == 0: # Child process make commands
commander._close_cmds_stdios(self)
self.msg = ms.Messenger(ms.StdIOWrapperIn(self.r_pipe),
ms.StdIOWrapperOut(self.w_pipe))
try:
self.basecmd.results = self.obj(*self.basecmd.args,
**self.basecmd.kargs)
except Exception:
err_msg = traceback.format_exc()
self.msg.write_msg(remote_interface.CmdTraceBack(err_msg))
sys.exit(-1)
finally:
self.msg.write_msg(self.basecmd.results)
self.msg.write_msg(CmdFinish())
sys.exit(0)
else: # Parent process create communication interface to child process
self.msg = ms.Messenger(ms.StdIOWrapperIn(self.r_pipe),
ms.StdIOWrapperOut(self.w_pipe))
def recover_fds(self):
"""
Helper function for reconnect to daemon/nohup process.
"""
if self.r_pipe is None:
self.recover_paths()
self.w_pipe = os.open(self.w_path, os.O_WRONLY)
self.r_pipe = os.open(self.r_path, os.O_RDONLY)
self.stdin_pipe = os.open(self.stdin_path, os.O_WRONLY)
self.stdout_pipe = os.open(self.stdout_path, os.O_RDONLY)
self.stderr_pipe = os.open(self.stderr_path, os.O_RDONLY)
self.msg = ms.Messenger(ms.StdIOWrapperIn(self.r_pipe),
ms.StdIOWrapperOut(self.w_pipe))
def __init__(self):
self.interval_log = ""
self.ip_address = ""
self.command_port = ""
self.event_port = ""
self.cgate_project = ""
self.cbus_network = ""
self.cbus_application = ""
self.cbus_project_id = ""
self.messenger = messenger.Messenger()
def main():
global myMessenger, msgTryTimer
PyNAO.onUserLogOn = userLogon
PyNAO.onUserLogOff = userLogoff
PyNAO.onBumperPressed = bumperActions
PyNAO.onTimer = timerActions
PyNAO.onTimerLapsed = timerLapsedActions
PyNAO.onRemoteCommand = remoteCommandActions
PyNAO.onChestButtonPressed = chestBtnActions
PyNAO.onSystemShutdown = systemShutdownActions
PyNAO.onPowerPluggedChange = powerPlugChangeActions
PyNAO.onBatteryChargeChange = batteryChargeChangeActions
PyNAO.say( constants.INTRO_TEXT )
myMessenger = messenger.Messenger()
if not myMessenger.checkin():
msgTryTimer = PyNAO.addTimer( 10*60, -1, 10*60 )
def _new_tube_cb(self, identifier, initiator, tube_type, service,
params, state):
logging.debug('New tube: ID=%d initator=%d type=%d service=%s '
'params=%r state=%d', identifier, initiator, tube_type,
service, params, state)
if (tube_type == telepathy.TUBE_TYPE_DBUS and
service == SERVICE):
if state == telepathy.TUBE_STATE_LOCAL_PENDING:
self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].AcceptDBusTube(
identifier)
self.tube_conn = TubeConnection(
self.conn,
self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES], identifier,
group_iface=self.text_chan[telepathy.CHANNEL_INTERFACE_GROUP])
self.messenger = messenger.Messenger(self.tube_conn,
self.initiating,
self._get_buddy, self.game)
self.game.connect('flip-card-signal', self.messenger.flip_sender)
self.game.connect('change_game_signal', self.messenger.change_game)
def __call_nohup__(self, commander):
(pid, self.r_path, self.w_path, self.stdin_path, self.stdout_path,
self.stderr_path) = daemonize(self.basecmd.cmd_hash)
if pid == 1: # Child process make commands
commander._close_cmds_stdios(self)
(self.pid, r_pipe, w_pipe, stdin_pipe,
stdout_pipe, stderr_pipe) = create_process_cmd()
if self.pid == 0: # Child process make commands
self.msg = ms.Messenger(ms.StdIOWrapperIn(r_pipe),
ms.StdIOWrapperOut(w_pipe))
try:
self.basecmd.results = self.obj(*self.basecmd.args,
**self.basecmd.kargs)
except Exception:
err_msg = traceback.format_exc()
self.msg.write_msg(remote_interface.CmdTraceBack(err_msg))
sys.exit(-1)
finally:
self.msg.write_msg(self.basecmd.results)
sys.exit(0)
else:
# helper child process open communication pipes.
# This process is able to manage problem with connection width
# main parent process. It allows start unchanged child process.
self.r_pipe = os.open(self.r_path, os.O_RDONLY)
self.w_pipe = os.open(self.w_path, os.O_WRONLY)
sys.stdout = os.fdopen(os.open(self.stdout_path, os.O_WRONLY),
"w",
0)
sys.stderr = os.fdopen(os.open(self.stderr_path, os.O_WRONLY),
"w",
0)
sys.stdin = os.fdopen(os.open(self.stdin_path, os.O_RDONLY),
"r",
0)
w_fds = [r_pipe, w_pipe, stdin_pipe, stdout_pipe, stderr_pipe]
m_fds = [self.r_pipe,
self.w_pipe,
sys.stdin.fileno(),
sys.stdout.fileno(),
sys.stderr.fileno()]
p = select.poll()
p.register(r_pipe)
p.register(w_pipe)
# p.register(stdin_pipe)
p.register(stdout_pipe)
p.register(stderr_pipe)
p.register(self.r_pipe)
# p.register(self.w_pipe)
p.register(sys.stdin.fileno())
# p.register(sys.stdout.fileno())
# p.register(sys.stderr.fileno())
io_map = {r_pipe: self.w_pipe,
self.r_pipe: w_pipe,
sys.stdin.fileno(): stdin_pipe,
stdout_pipe: sys.stdout.fileno(),
stderr_pipe: sys.stderr.fileno()}
while 1:
d = p.poll()
w_ev = [x for x in d if x[0] in w_fds]
m_ev = [x for x in d if x[0] in m_fds]
w_hup, w_read, _ = sort_fds_event(w_ev)
m_hup, m_read, _ = sort_fds_event(m_ev)
if m_hup:
time.sleep(0.1)
if w_hup: # child process finished
for r in w_read:
data = os.read(r, 16384)
os.write(io_map[r], data)
break
for r in w_read:
data = os.read(r, 16384)
os.write(io_map[r], data)
for r in m_read:
data = os.read(r, 16384)
os.write(io_map[r], data)
self.msg = ms.Messenger(ms.StdIOWrapperIn(self.r_pipe),
ms.StdIOWrapperOut(self.w_pipe))
self.msg.write_msg(CmdFinish())
exit(0)
else: # main process open communication named pipes.
self.w_pipe = os.open(self.w_path, os.O_WRONLY)
self.r_pipe = os.open(self.r_path, os.O_RDONLY)
self.stdout_pipe = os.open(self.stdout_path, os.O_RDONLY)
self.stderr_pipe = os.open(self.stderr_path, os.O_RDONLY)
self.stdin_pipe = os.open(self.stdin_path, os.O_WRONLY)
self.msg = ms.Messenger(ms.StdIOWrapperIn(self.r_pipe),
ms.StdIOWrapperOut(self.w_pipe))
forumPayload = payload.Payload(api_profile, site, api, db)
try:
pass
# Process the payload into command calls and return messages to users
forumProcessList = payloadProcessor.PayloadProcessor(
forumPayload.payload, api, db, rpc, exchange)
except Exception as e:
logger.debug(
"---PAYLOAD PROCESSING FAILED!! %s API Profile for %s site---"
% (api_profile, site))
print e
fail = True
try:
pass
# Process messages into forum posts and emails
forumMessenger = messenger.Messenger(db, bbmech, forumProcessList,
api)
except Exception as e:
import traceback, os.path
top = traceback.extract_stack()[-1]
print ', '.join(
[type(e).__name__,
os.path.basename(top[0]),
str(top[1])])
print e
logger.debug(
"---MESSAGE PROCESSING FAILED!! %s API Profile for %s site---"
% (api_profile, site))
fail = True
logger.debug("---Forum Check Script Completed---")
# Check all user addresses for deposits
def __init__(self):
self.cfg = configsetup.get()
self.s = spotify.build(self.cfg['SPOTIFY'])
self.m = messenger.Messenger(self.cfg['MESSENGER']['email'])
import requete
import messenger
from data import *
from conf import ACCESS_TOKEN, BASE_URL
# Instanciation du traitement bdd
req = requete.Requete()
# Instanciation du Bot Messenger
bot = messenger.Messenger(ACCESS_TOKEN)
class Traitement:
# ************************** OPTIONS *******************************
def __execution(self, user_id, commande):
'''
Fonction privée qui traite les differentes commandes réçu
'''
print(commande)
bot.send_persistent_menu(user_id)
bot.send_action(user_id, 'mark_seen')
req.setStatus(user_id, "")
if commande == '_GET_STARTED_':
print("Teste")
bot.send_message(
user_id, """Bienvenue 😊
Je suis ZINA🤖🔥 l'ami pour vous aider pendant ce crise sanitaire.
1️⃣ Un bot Messenger qui vous informera en temps réel sur l'évolution du COVID 19 à Madagascar🇲🇬.
2️⃣ Vous pouvez consulter une liste de tout les campagnes de vaccination et teste au covid selon votre localisation. Je vous informerai également à l'avance sur vos rappels de vaccins.
3️⃣ Télé-consultation : Décrivez-moi vos symptômes ,et je vous proposerai des indications sur les démarches à faire
def __init__(self, account, message_handler=None):
"""Reads configuration file and asks the data handler for the API info."""
self.msg = messenger.Messenger(message_handler)
self._load(account)
self._init_data_handler()
def set_message_handler(self, message_handler):
"""Changes the message handler function on the fly."""
self.msg = messenger.Messenger(message_handler)
self.data_handler.set_message_handler(self.msg)
def __init__(self):
self.dealer = player.Dealer()
self.players = []
self.msgr = messenger.Messenger()
def set_message_handler(self, message_handler):
"""Changes the data handler even after the class initialization."""
self.msg = messenger.Messenger(message_handler)
self.data_handler.set_message_handler(self.msg)
