def send_message(destination, message):
''' destination is <phone number> without '+'
and with country code of type string,
message is string
e.g send_message('11133434343','hello')
'''
messages = [(destination, message)]
layers = (EchoLayer,
(YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer,
YowReceiptProtocolLayer,
YowAckProtocolLayer,
YowPresenceProtocolLayer)
) + YOWSUP_CORE_LAYERS
stack = YowStack(layers)
stack.setProp(EchoLayer.PROP_MESSAGES, messages)
stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
# Setting credentials
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, CREDENTIALS)
# WhatsApp server address
stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())
# Sending connecting signal
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
# Program main loop
stack.loop()
except AuthError as e:
print('Authentication error %s' % e.message)
sys.exit(1)
def send_message(destination, message):
''' destination is <phone number> without '+'
and with country code of type string,
message is string
e.g send_message('11133434343','hello')
'''
messages = [(destination, message)]
layers = (EchoLayer,
(YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer,
YowReceiptProtocolLayer,
YowAckProtocolLayer,
YowPresenceProtocolLayer)
) + YOWSUP_CORE_LAYERS
stack = YowStack(layers)
stack.setProp(EchoLayer.PROP_MESSAGES, messages)
stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
# Setting credentials
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, CREDENTIALS)
# WhatsApp server address
stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())
# Sending connecting signal
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
# Program main loop
stack.loop()
except AuthError as e:
print('Authentication error %s' % e.message)
sys.exit(1)
class YowsupReceiveStack(object):
def __init__(self, credentials):
layers = (ReceiveLayer,
(YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer,
YowReceiptProtocolLayer,
YowAckProtocolLayer,
YowMediaProtocolLayer),
YowAxolotlLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer)
self.stack = YowStack(layers)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
self.stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())
def start(self):
#print '-------------------------'
#print 'En el start de YowsupReceiveStack'
#print '-------------------------'
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop(count=4)
#self.stack.loop(timeout = 0.5, discrete = 0.5)
except AuthError as e:
print("Authentication Error: %s" % e.message)
class YowsupEchoStack(object):
def __init__(self, credentials, encryptionEnabled=False):
if encryptionEnabled:
from yowsup.layers.axolotl import YowAxolotlLayer
layers = (EchoLayer,
YowParallelLayer([
YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer, YowReceiptProtocolLayer,
YowAckProtocolLayer, YowMediaProtocolLayer,
YowIqProtocolLayer, YowCallsProtocolLayer
]), YowAxolotlLayer, YowLoggerLayer, YowCoderLayer,
YowCryptLayer, YowStanzaRegulator, YowNetworkLayer)
else:
layers = (EchoLayer,
YowParallelLayer([
YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer, YowReceiptProtocolLayer,
YowAckProtocolLayer, YowMediaProtocolLayer,
YowIqProtocolLayer, YowCallsProtocolLayer
]), YowLoggerLayer, YowCoderLayer, YowCryptLayer,
YowStanzaRegulator, YowNetworkLayer)
self.stack = YowStack(layers)
self.stack.setCredentials(credentials)
def start(self):
self.stack.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
logging.info("Whatsapp IS STARTING : ReceiveStack")
self.stack.loop(timeout=1, count=100)
logging.info("Stopping ... ")
except AuthError as e:
logging.info("Authentication Error: %s" % e.message)
class YowsupEchoStack(object):
def __init__(self, credentials, encryptionEnabled=False):
if encryptionEnabled:
env.CURRENT_ENV = env.S40YowsupEnv()
layers = (EchoLayer, (YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer,
YowReceiptProtocolLayer, YowAckProtocolLayer,
YowMediaProtocolLayer), YowAxolotlLayer,
YowLoggerLayer, YowCoderLayer, YowCryptLayer,
YowStanzaRegulator, YowNetworkLayer)
else:
layers = (EchoLayer, (YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer,
YowReceiptProtocolLayer, YowAckProtocolLayer,
YowMediaProtocolLayer), YowLoggerLayer,
YowCoderLayer, YowCryptLayer, YowStanzaRegulator,
YowNetworkLayer)
self.stack = YowStack(layers)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS,
credentials)
self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT,
YowConstants.ENDPOINTS[0])
self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
self.stack.setProp(YowCoderLayer.PROP_RESOURCE,
env.CURRENT_ENV.getResource())
def start(self):
self.stack.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
def run(wttQueue, ttwQueue, config):
logger.info("Starting Whatsapp Self-Bot")
keypair = KeyPair.from_bytes(
base64.b64decode(config["client_static_keypair"]))
credentials = (config["phone"], keypair)
layers = (
WhatsappLayer(wttQueue, ttwQueue),
YowParallelLayer([
YowAuthenticationProtocolLayer, YowMessagesProtocolLayer,
YowReceiptProtocolLayer, YowAckProtocolLayer, YowIqProtocolLayer,
YowGroupsProtocolLayer, YowMediaProtocolLayer
]),
AxolotlControlLayer,
YowParallelLayer((AxolotlSendLayer, AxolotlReceivelayer)),
) + YOWSUP_CORE_LAYERS
stack = YowStack(layers)
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS,
credentials) # setting credentials
stack.setProp(YowNetworkLayer.PROP_ENDPOINT,
YowConstants.ENDPOINTS[0]) # whatsapp server address
# stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
# stack.setProp(YowCoderLayer.PROP_RESOURCE, YowsupEnv.getCurrent().getResource()) #info about us as WhatsApp client
stack.broadcastEvent(YowLayerEvent(
YowNetworkLayer.EVENT_STATE_CONNECT)) # sending the connect signal
stack.loop()
class YowsupEchoStack(object):
def __init__(self, encryption_enabled = True):
if encryption_enabled:
from yowsup.layers.axolotl import YowAxolotlLayer
layers = (
EchoLayer,
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer, YowIqProtocolLayer, YowCallsProtocolLayer),
YowAxolotlLayer,
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
else:
layers = (
EchoLayer,
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer, YowIqProtocolLayer, YowCallsProtocolLayer),
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
self.stack = YowStack(layers)
self.stack.setCredentials(settings.CREDENTIALS)
def start(self):
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
def receive_message(credentials):
layers = ( EchoLayer,
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer,
YowReceiptProtocolLayer, YowAckProtocolLayer,
YowPresenceProtocolLayer)
) + YOWSUP_CORE_LAYERS
stack = YowStack(layers)
# Setting credentials
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
# WhatsApp server address
stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())
stack.setProp(EchoLayer.PROP_CREDENTIALS, credentials)
# Sending connecting signal
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
# Program main loop
stack.loop()
except AuthError as e:
print('Authentication error %s' % e.message)
sys.exit(1)
class YowsupCommandServerStack(object):
def __init__(self, credentials, allowed_users, encryptionEnabled = False):
if encryptionEnabled:
from yowsup.layers.axolotl import YowAxolotlLayer
layers = (
CommandServerLayer(allowed_users),
YowParallelLayer([YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer, YowIqProtocolLayer, YowCallsProtocolLayer]),
YowAxolotlLayer,
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
else:
layers = (
CommandServerLayer(allowed_users),
YowParallelLayer([YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer, YowIqProtocolLayer, YowCallsProtocolLayer]),
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
self.stack = YowStack(layers)
self.stack.setCredentials(credentials)
def start(self):
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
def recv_message():
layers = (
EchoLayer,
YowParallelLayer([
YowAuthenticationProtocolLayer, YowMessagesProtocolLayer,
YowReceiptProtocolLayer, YowAckProtocolLayer
]),
AxolotlControlLayer,
YowParallelLayer((AxolotlSendLayer, AxolotlReceivelayer)),
) + YOWSUP_CORE_LAYERS
stack = YowStack(layers)
# Setting credentials
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, CREDENTIALS)
# WhatsApp server address
stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
stack.setProp(YowCoderLayer.PROP_RESOURCE,
YowsupEnv.getCurrent().getResource())
# Sending connecting signal
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
# Program main loop
stack.loop()
except AuthError as e:
print('Authentication error %s' % e.message)
sys.exit(1)
class YowsupBotStack(object):
def __init__(self, credentials):
"""Default Yowsup setup, with the Route Layer on top"""
layers = (RouteLayer,
YowParallelLayer([YowAuthenticationProtocolLayer,
YowGroupsProtocolLayer,
YowMessagesProtocolLayer,
YowReceiptProtocolLayer,
YowAckProtocolLayer,
YowMediaProtocolLayer,
YowIqProtocolLayer]),
YowAxolotlLayer,
) + YOWSUP_CORE_LAYERS
self.stack = YowStack(layers)
self.stack.setCredentials(credentials)
self.credentials = credentials
def start(self):
"Starts the connection with Whatsapp servers,"
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
logging.info("#" * 50)
logging.info("Server started. Phone number: %s" % self.credentials[0])
logging.info("#" * 50)
self.stack.loop()
except AuthError as e:
logging.exception("Authentication Error: %s" % e.message)
except Exception as e:
logging.exception("Unknown Error: %s" % e.message)
raise e
class Client(object):
def __init__(self, login, password):
self.login = login
self.password = password
def _send_message(self, to, message, is_media=False):
layers = (SendLayer, ) + (
YOWSUP_PROTOCOL_LAYERS_FULL, ) + YOWSUP_CORE_LAYERS
self.stack = YowStack(layers)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS,
(self.login, self.password))
self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT,
YowConstants.ENDPOINTS[0])
self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
self.stack.setProp(YowCoderLayer.PROP_RESOURCE,
env.YowsupEnv.getCurrent().getResource())
self.stack.setProp(SendLayer.PROP_MESSAGES,
[([to, message, is_media])])
self.stack.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except KeyboardInterrupt:
pass
def send_message(self, to, message):
self._send_message(to, message)
def send_media(self, to, path):
self._send_message(to, path, is_media=True)
def run(phone, password, config):
# @TODO check phone, password is set
credentials = (phone.encode(), password.encode())
layers = (
secretary(config),
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer),
YowAxolotlLayer,
) + YOWSUP_CORE_LAYERS
stack = YowStack(layers)
# Setting credentials
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
# Whatsapp server address
stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
# Info about us as WhatsApp client
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())
# Sending the connect signal
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
stack.loop()
class Client(object):
def __init__(self, login, password):
self.login = login
self.password = password
def _send_message(self, to, message, is_media=False):
layers = (SendLayer,) + (YOWSUP_PROTOCOL_LAYERS_FULL,) + YOWSUP_CORE_LAYERS
self.stack = YowStack(layers)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, (self.login, self.password))
self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
self.stack.setProp(YowCoderLayer.PROP_RESOURCE, env.YowsupEnv.getCurrent().getResource())
self.stack.setProp(SendLayer.PROP_MESSAGES, [([to, message, is_media])])
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except KeyboardInterrupt:
pass
def send_message(self, to, message):
self._send_message(to, message)
def send_media(self, to, path):
self._send_message(to, path, is_media=True)
class YowsupSyncStack(object):
def __init__(self, credentials, contacts, encryptionEnabled=False):
"""
:param credentials:
:param contacts: list of [jid ]
:param encryptionEnabled:
:return:
"""
if encryptionEnabled:
from yowsup.layers.axolotl import YowAxolotlLayer
layers = (SyncLayer,
(YowAuthenticationProtocolLayer,
YowContactsIqProtocolLayer, YowReceiptProtocolLayer,
YowAckProtocolLayer), YowAxolotlLayer, YowLoggerLayer,
YowCoderLayer, YowCryptLayer, YowStanzaRegulator,
YowNetworkLayer)
else:
layers = (SyncLayer,
(YowAuthenticationProtocolLayer,
YowContactsIqProtocolLayer, YowReceiptProtocolLayer,
YowAckProtocolLayer), YowLoggerLayer, YowCoderLayer,
YowCryptLayer, YowStanzaRegulator, YowNetworkLayer)
self.stack = YowStack(layers)
self.stack.setProp(SyncLayer.PROP_CONTACTS, contacts)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
self.stack.setCredentials(credentials)
def start(self):
self.stack.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
class YowsupEchoStack(object):
def __init__(self, encryption_enabled=True):
if encryption_enabled:
from yowsup.layers.axolotl import YowAxolotlLayer
layers = (EchoLayer,
YowParallelLayer([
YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer, YowReceiptProtocolLayer,
YowAckProtocolLayer, YowMediaProtocolLayer,
YowIqProtocolLayer, YowCallsProtocolLayer
]), YowAxolotlLayer, YowLoggerLayer, YowCoderLayer,
YowCryptLayer, YowStanzaRegulator, YowNetworkLayer)
else:
layers = (EchoLayer,
YowParallelLayer([
YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer, YowReceiptProtocolLayer,
YowAckProtocolLayer, YowMediaProtocolLayer,
YowIqProtocolLayer, YowCallsProtocolLayer
]), YowLoggerLayer, YowCoderLayer, YowCryptLayer,
YowStanzaRegulator, YowNetworkLayer)
self.stack = YowStack(layers)
self.stack.setCredentials(settings.CREDENTIALS)
def start(self):
self.stack.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop(timeout=120)
except AuthError as e:
print("Authentication Error: %s" % e.message)
except Exception as e:
print("Another Error: %s" % str(e))
class YowsupCommandServerStack(object):
def __init__(self, credentials, allowed_users, encryptionEnabled=False):
if encryptionEnabled:
from yowsup.layers.axolotl import YowAxolotlLayer
layers = (CommandServerLayer(allowed_users),
YowParallelLayer([
YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer, YowReceiptProtocolLayer,
YowAckProtocolLayer, YowMediaProtocolLayer,
YowIqProtocolLayer, YowCallsProtocolLayer
]), YowAxolotlLayer, YowLoggerLayer, YowCoderLayer,
YowCryptLayer, YowStanzaRegulator, YowNetworkLayer)
else:
layers = (CommandServerLayer(allowed_users),
YowParallelLayer([
YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer, YowReceiptProtocolLayer,
YowAckProtocolLayer, YowMediaProtocolLayer,
YowIqProtocolLayer, YowCallsProtocolLayer
]), YowLoggerLayer, YowCoderLayer, YowCryptLayer,
YowStanzaRegulator, YowNetworkLayer)
self.stack = YowStack(layers)
self.stack.setCredentials(credentials)
def start(self):
self.stack.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
class YowsupMyStack(object):
def __init__(self, credentials):
env.CURRENT_ENV = env.S40YowsupEnv()
layers = (
MailLayer,
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer,
YowReceiptProtocolLayer, YowAckProtocolLayer,
YowMediaProtocolLayer, YowIqProtocolLayer,
YowPresenceProtocolLayer)
) + YOWSUP_CORE_LAYERS
self.stack = YowStack(layers)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS,
credentials)
self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT,
YowConstants.ENDPOINTS[0])
self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
self.stack.setProp(YowCoderLayer.PROP_RESOURCE,
env.CURRENT_ENV.getResource())
def start(self):
self.stack.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
class YowsupSendVCardStack(object):
def __init__(self, credentials, to):
"""
:param credentials:
:param to:
:param encryptionEnabled:
:return:
"""
layers = (
SendVCardLayer,
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer),
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
self.stack = YowStack(layers)
self.stack.setProp(SendVCardLayer.PROP_TO, to)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
self.stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())
def start(self):
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
class YowsupBotStack(object):
def __init__(self, credentials):
"""Default Yowsup setup, with the Route Layer on top"""
layers = (RouteLayer,
YowParallelLayer([YowAuthenticationProtocolLayer,
YowGroupsProtocolLayer,
YowMessagesProtocolLayer,
YowReceiptProtocolLayer,
YowAckProtocolLayer,
YowMediaProtocolLayer,
YowIqProtocolLayer]),
YowAxolotlLayer,
) + YOWSUP_CORE_LAYERS
self.stack = YowStack(layers)
self.stack.setCredentials(credentials)
self.credentials = credentials
def start(self):
"Starts the connection with Whatsapp servers,"
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
logging.info("#" * 50)
logging.info("Server started. Phone number: %s" % self.credentials[0])
logging.info("#" * 50)
self.stack.loop()
except AuthError as e:
logging.exception("Authentication Error: %s" % e.message)
except Exception as e:
logging.exception("Unknown Error: %s" % e.message)
raise e
class YowsupSendStack(object):
def __init__(self, credentials, messages, encryptionEnabled=False):
"""
:param credentials:
:param messages: list of (jid, message) tuples
:param encryptionEnabled:
:return:
"""
if encryptionEnabled:
env.CURRENT_ENV = env.S40YowsupEnv()
layers = (
SendLayer,
(
YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer,
YowReceiptProtocolLayer,
YowAckProtocolLayer,
),
YowAxolotlLayer,
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer,
)
else:
layers = (
SendLayer,
(
YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer,
YowReceiptProtocolLayer,
YowAckProtocolLayer,
),
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer,
)
self.stack = YowStack(layers)
self.stack.setProp(SendLayer.PROP_MESSAGES, messages)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
self.stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())
def start(self):
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
class YowsupMiddleManStack(object):
def __init__(self, credentials, groups, encryptionEnabled=False):
if encryptionEnabled:
from yowsup.layers.axolotl import YowAxolotlLayer
layers = (
MiddleManLayer,
(
YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer,
YowReceiptProtocolLayer,
YowAckProtocolLayer,
YowMediaProtocolLayer,
YowIqProtocolLayer,
YowCallsProtocolLayer,
),
YowAxolotlLayer,
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer,
)
else:
layers = (
MiddleManLayer,
(
YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer,
YowReceiptProtocolLayer,
YowAckProtocolLayer,
YowMediaProtocolLayer,
YowIqProtocolLayer,
YowCallsProtocolLayer,
),
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer,
)
self.stack = YowStack(layers)
self.stack.setProp(MiddleManLayer.PROP_GROUPS, groups[0])
self.stack.setCredentials(credentials)
def start(self):
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
def start_server():
layers = (
EchoLayer,
YowParallelLayer([YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer]),YowAxolotlLayer
) + YOWSUP_CORE_LAYERS
stack = YowStack(layers)
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, CREDENTIALS) #setting credentials
stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0]) #whatsapp server address
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
stack.setProp(YowCoderLayer.PROP_RESOURCE, YowsupEnv.getCurrent().getResource()) #info about us as WhatsApp client
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT)) #sending the connect signal
stack.loop()
class YowsupSendStack(object):
def __init__(self, credentials, messages, encryptionEnabled = False):
"""
:param credentials:
:param messages: list of (jid, message) tuples
:param encryptionEnabled:
:return:
"""
if encryptionEnabled:
from yowsup.layers.axolotl import YowAxolotlLayer
layers = (
SendLayer,
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer),
YowAxolotlLayer,
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
else:
layers = (
SendLayer,
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer),
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
self.stack = YowStack(layers)
self.stack.setProp(SendLayer.PROP_MESSAGES, messages)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
self.stack.setCredentials(credentials)
def start(self):
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except KeyboardInterrupt as e:
raise e
except AuthError as e:
print("Authentication Error: %s" % e.message)
class YowsupRobotStack(object):
def __init__(self, credentials, encryptionEnabled = False,interactionProtocol=None,url=None,flaskApp=None):
if encryptionEnabled:
from yowsup.layers.axolotl import YowAxolotlLayer
layers = (
RobotLayer,
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer, YowIqProtocolLayer, YowCallsProtocolLayer),
YowAxolotlLayer,
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
else:
layers = (
RobotLayer,
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer, YowIqProtocolLayer, YowCallsProtocolLayer),
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
self.stack = YowStack(layers)
self.stack.setCredentials(credentials)
self.stack.setProp('url',url)
self.stack.setProp('flaskApp',flaskApp)
def start(self):
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
def startThread():
try:
self.stack.loop(timeout = 0.5, discrete = 0.5)
except AuthError as e:
print("Auth Error, reason %s" % e)
except KeyboardInterrupt:
print("\nYowsdown KeyboardInterrupt")
sys.exit(0)
except Exception as e:
print("\nYowsdown General Exception")
print e
t1=threading.Thread(target=startThread)
t1.daemon=True
t1.start()
class SendMediaStack(object):
def __init__(self, credentials, messages):
layers=(SendMediaLayer,)+(YOWSUP_PROTOCOL_LAYERS_FULL,)+YOWSUP_CORE_LAYERS
self.stack=YowStack(layers)
self.stack.setProp(SendMediaLayer.PROP_MESSAGES,messages)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE,True)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS,credentials)
self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT,YowConstants.ENDPOINTS[0])
self.stack.setProp(YowCoderLayer.PROP_DOMAIN,YowConstants.DOMAIN)
self.stack.setProp(YowCoderLayer.PROP_RESOURCE,env.CURRENT_ENV.getResource())
def start(self):
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
class YowsupSyncStack(object):
def __init__(self, credentials, contacts, encryptionEnabled = False):
"""
:param credentials:
:param contacts: list of [jid ]
:param encryptionEnabled:
:return:
"""
if encryptionEnabled:
from yowsup.layers.axolotl import YowAxolotlLayer
layers = (
SyncLayer,
(YowAuthenticationProtocolLayer, YowContactsIqProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer),
YowAxolotlLayer,
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
else:
layers = (
SyncLayer,
(YowAuthenticationProtocolLayer, YowContactsIqProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer),
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
self.stack = YowStack(layers)
self.stack.setProp(SyncLayer.PROP_CONTACTS, contacts)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
self.stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())
def start(self):
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
class YowsupSyncStack(object):
def __init__(self, credentials, contacts, encryptionEnabled=False):
"""
:param credentials:
:param contacts: list of [jid ]
:param encryptionEnabled:
:return:
"""
if encryptionEnabled:
from yowsup.layers.axolotl import YowAxolotlLayer
layers = (
SyncLayer,
(YowAuthenticationProtocolLayer, YowContactsIqProtocolLayer, YowReceiptProtocolLayer,
YowAckProtocolLayer),
YowAxolotlLayer,
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
else:
layers = (
SyncLayer,
(YowAuthenticationProtocolLayer, YowContactsIqProtocolLayer, YowReceiptProtocolLayer,
YowAckProtocolLayer),
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
self.stack = YowStack(layers)
self.stack.setProp(SyncLayer.PROP_CONTACTS, contacts)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
self.stack.setCredentials(credentials)
def start(self):
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: {0}".format(e))
class YowsupSyncStack(object):
def __init__(self, credentials, contacts, encryptionEnabled = False):
"""
:param credentials:
:param contacts: list of [jid ]
:param encryptionEnabled:
:return:
"""
if encryptionEnabled:
layers = (
SyncLayer,
(YowAuthenticationProtocolLayer, YowContactsIqProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer),
YowAxolotlLayer,
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
else:
env.CURRENT_ENV = env.S40YowsupEnv()
layers = (
SyncLayer,
(YowAuthenticationProtocolLayer, YowContactsIqProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer),
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
self.stack = YowStack(layers)
self.stack.setProp(SyncLayer.PROP_CONTACTS, contacts)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
self.stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())
def start(self):
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
def run(self):
mess = None
to = None
phone = None
passw = None
with open(appPath + "/config.cfg") as f:
for line in f:
if line.find("phone number:", 0) == 0:
phone = line[13:]
phone = phone.strip()
elif line.find("password:"******"send_message_startup:", 0) == 0:
mess = line[21:-1]
mess = "'" + mess + "'"
elif line.find("allowed1:", 0) == 0:
to = line[9:-1]
CREDENTIALS = (phone, passw)
print("/send.py " + to + " " + mess)
p = subprocess.Popen(appPath + "/send.py " + to + " " + mess, stdout=subprocess.PIPE, shell=True)
(output, err) = p.communicate()
while True:
layers = (
DaemonLayer,
(
YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer,
YowReceiptProtocolLayer,
YowAckProtocolLayer,
),
) + YOWSUP_CORE_LAYERS
stack = YowStack(layers)
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, CREDENTIALS)
stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
interface = stack.getLayer(6)
interface.initialize(appPath)
try:
stack.loop()
except:
pass
class sendmediafile(object):
def __init__(self, credentials, messages):
layers = (SendMedia,) + (YOWSUP_PROTOCOL_LAYERS_FULL,) + YOWSUP_CORE_LAYERS
self.stack = YowStack(layers)
self.stack.setProp(SendMedia.PROP_MESSAGES, messages)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
self.stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())
def start(self):
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
class YowsupEchoStack(object):
def __init__(self, credentials, encryptionEnabled = False):
if encryptionEnabled:
layers = (
EchoLayer,
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer, YowIqProtocolLayer, YowCallsProtocolLayer),
YowAxolotlLayer,
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
else:
env.CURRENT_ENV = env.S40YowsupEnv()
layers = (
EchoLayer,
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer, YowIqProtocolLayer, YowCallsProtocolLayer),
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
self.stack = YowStack(layers)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
self.stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())
def start(self):
while True:
try:
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
self.stack.loop()
except AuthError as e:
break
except Exception as e:
print(e)
time.sleep(20)
class YowsupSendStack(object):
def __init__(self, credentials, messages, encryptionEnabled = False):
"""
:param credentials:
:param messages: list of (jid, message) tuples
:param encryptionEnabled:
:return:
"""
if encryptionEnabled:
from yowsup.layers.axolotl import YowAxolotlLayer
layers = (
SendLayer,
YowParallelLayer([YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer]),
YowAxolotlLayer,
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
else:
layers = (
SendLayer,
YowParallelLayer([YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer]),
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
self.stack = YowStack(layers)
self.stack.setProp(SendLayer.PROP_MESSAGES, messages)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
self.stack.setCredentials(credentials)
def start(self):
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
class YowsupSendStack(object):
def __init__(self, credentials, messages, encryptionEnabled=False):
"""
:param credentials:
:param messages: list of (jid, message) tuples
:param encryptionEnabled:
:return:
"""
if encryptionEnabled:
from yowsup.layers.axolotl import YowAxolotlLayer
layers = (SendLayer,
(YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer, YowReceiptProtocolLayer,
YowAckProtocolLayer), YowAxolotlLayer, YowLoggerLayer,
YowCoderLayer, YowCryptLayer, YowStanzaRegulator,
YowNetworkLayer)
else:
layers = (SendLayer,
(YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer, YowReceiptProtocolLayer,
YowAckProtocolLayer), YowLoggerLayer, YowCoderLayer,
YowCryptLayer, YowStanzaRegulator, YowNetworkLayer)
self.stack = YowStack(layers)
self.stack.setProp(SendLayer.PROP_MESSAGES, messages)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS,
credentials)
self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT,
YowConstants.ENDPOINTS[0])
self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
self.stack.setProp(YowCoderLayer.PROP_RESOURCE,
env.CURRENT_ENV.getResource())
def start(self):
self.stack.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
def run(self):
layers = (EchoLayer,
YowParallelLayer([
YowAuthenticationProtocolLayer, YowMessagesProtocolLayer,
YowReceiptProtocolLayer, YowAckProtocolLayer
]), YowAxolotlLayer) + YOWSUP_CORE_LAYERS
stack = YowStack(layers)
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS,
CREDENTIALS) #setting credentials
stack.setProp(YowNetworkLayer.PROP_ENDPOINT,
YowConstants.ENDPOINTS[0]) #whatsapp server address
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
stack.setProp(
YowCoderLayer.PROP_RESOURCE,
env.CURRENT_ENV.getResource()) #info about us as WhatsApp client
stack.broadcastEvent(YowLayerEvent(
YowNetworkLayer.EVENT_STATE_CONNECT)) #sending the connect signal
stack.loop() #this is the program mainloop
def main():
logging.debug("Starting up...")
layers = (
(MessageReceiver, ReceiptReceiver),
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer,
YowReceiptProtocolLayer, YowAckProtocolLayer)
) + YOWSUP_CORE_LAYERS
stack = YowStack(layers)
# setting credentials
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, CREDENTIALS)
# whatsapp server address
stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
# info about us as WhatsApp client
stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())
# sending the connect signal
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
stack.loop() # this is the program mainloop
class YowsupCliStack(object):
def __init__(self, credentials):
self.stack = YowStack(
(YowsupCliLayer,) + YOWSUP_FULL_STACK
)
self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
self.stack.setProp(YowCoderLayer.PROP_RESOURCE, YowConstants.RESOURCE)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
def start(self):
print("Yowsup Cli client\n==================\nType /help for available commands\n")
self.stack.broadcastEvent(YowLayerEvent(YowsupCliLayer.EVENT_START))
try:
self.stack.loop(timeout = 0.5, discrete = 0.5)
except AuthError as e:
print("Auth Error, reason %s" % e)
except KeyboardInterrupt:
print("\nYowsdown")
sys.exit(0)
class YowsupListenStack(object):
def __init__(self, credentials, queue, encryptionEnabled = False):
ListenLayer.setqueue(queue)
if encryptionEnabled:
layers = (
ListenLayer,
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer),
YowAxolotlLayer,
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
else:
env.CURRENT_ENV = env.S40YowsupEnv()
layers = (
ListenLayer,
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer),
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
self.stack = YowStack(layers)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
self.stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())
def start(self):
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
def main():
layers = (
EchoLayer,
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer),
YowAxolotlLayer,
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
thread = MyThread(YowStack(layers))
try:
print ("Starting "+sys.argv[1])
stack = YowStack(layers)
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, CREDENTIALS) #setting credentials
stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0]) #whatsapp server address
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource()) #info about us as WhatsApp client
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT)) #sending the connect signal
thread = MyThread(stack)
thread.start()
stack.loop(timeout = 0.5, discrete = 0.5)
print("Exit "+sys.argv[1]+"!!")
except Exception as e:
print("Error in "+sys.argv[1]+", reason %s" % e)
finally:
thread.finish()
time.sleep(5)
print("Restart "+sys.argv[1]+"!!")
#os.system("python run-Executi.py")
sys.exit(0)
def main():
layers = (EchoLayer, (YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer, YowReceiptProtocolLayer,
YowAckProtocolLayer, YowMediaProtocolLayer),
YowAxolotlLayer, YowLoggerLayer, YowCoderLayer, YowCryptLayer,
YowStanzaRegulator, YowNetworkLayer)
thread = MyThread(YowStack(layers))
try:
print("Starting " + sys.argv[1])
stack = YowStack(layers)
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS,
CREDENTIALS) #setting credentials
stack.setProp(YowNetworkLayer.PROP_ENDPOINT,
YowConstants.ENDPOINTS[0]) #whatsapp server address
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
stack.setProp(
YowCoderLayer.PROP_RESOURCE,
env.CURRENT_ENV.getResource()) #info about us as WhatsApp client
stack.broadcastEvent(YowLayerEvent(
YowNetworkLayer.EVENT_STATE_CONNECT)) #sending the connect signal
thread = MyThread(stack)
thread.start()
stack.loop(timeout=0.5, discrete=0.5)
print("Exit " + sys.argv[1] + "!!")
except Exception as e:
print("Error in " + sys.argv[1] + ", reason %s" % e)
finally:
thread.finish()
time.sleep(5)
print("Restart " + sys.argv[1] + "!!")
#os.system("python run-Executi.py")
sys.exit(0)
class YowsupCliStack(object):
def __init__(self, credentials):
self.stack = YowStack((YowsupCliLayer, ) + YOWSUP_FULL_STACK)
self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT,
YowConstants.ENDPOINTS[0])
self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
self.stack.setProp(YowCoderLayer.PROP_RESOURCE, YowConstants.RESOURCE)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS,
credentials)
def start(self):
print(
"Yowsup Cli client\n==================\nType /help for available commands\n"
)
self.stack.broadcastEvent(YowLayerEvent(YowsupCliLayer.EVENT_START))
try:
self.stack.loop(timeout=0.5, discrete=0.5)
except AuthError as e:
print("Auth Error, reason %s" % e)
except KeyboardInterrupt:
print("\nYowsdown")
sys.exit(0)
class YowsupEchoStack(object):
def __init__(self, credentials, entities):
logger = logging.StreamHandler()
logger.setLevel(logging.DEBUG)
logging.getLogger("yowsup.stacks.yowstack").addHandler(logger)
env.CURRENT_ENV = env.AndroidYowsupEnv()
#env.CURRENT_ENV = env.S40YowsupEnv()
layers = (
EchoLayer,
YowParallelLayer([YowGroupsProtocolLayer, YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer, YowPresenceProtocolLayer, YowIqProtocolLayer, YowCallsProtocolLayer, YowNotificationsProtocolLayer, YowProfilesProtocolLayer, YowChatstateProtocolLayer, YowMyGroupsProtocolLayer]),
#SniffLayer,
YowAxolotlLayer,
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
self.stack = YowStack(layers)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
self.stack.setProp(EchoLayer.PROP_SELFNUMBER, credentials[0])
self.stack.setProp(EchoLayer.PROP_ENTITYCLASSES, entities)
self.stack.setProp(EchoLayer.SELF_STACK, self.stack)
self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
self.stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())
def start(self):
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
class YowsupEchoStack(object):
def __init__(self, credentials):
layers = (
EchoLayer,
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer),
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
self.stack = YowStack(layers)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
self.stack.setProp(YowCoderLayer.PROP_RESOURCE, YowConstants.RESOURCE)
def start(self):
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
class SendStack(object):
def __init__(self, credentials, messages):
env.CURRENT_ENV = env.S40YowsupEnv()
layers = (SendLayer, (YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer,
YowReceiptProtocolLayer, YowAckProtocolLayer),
YowLoggerLayer, YowCoderLayer, YowCryptLayer,
YowStanzaRegulator, YowNetworkLayer)
self.stack = YowStack(layers)
self.stack.setProp(SendLayer.PROP_MESSAGES, messages)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS,
credentials)
self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT,
YowConstants.ENDPOINTS[0])
self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
self.stack.setProp(YowCoderLayer.PROP_RESOURCE,
env.CURRENT_ENV.getResource())
def start(self): # Throws AuthError
logging.info('Begin connection to whatsapp')
self.stack.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
self.stack.loop()
class YowsupEchoStack(object):
def __init__(self, credentials, encryptionEnabled = False):
if encryptionEnabled:
from yowsup.layers.axolotl import YowAxolotlLayer
layers = (
EchoLayer,
YowParallelLayer([YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer, YowIqProtocolLayer, YowCallsProtocolLayer]),
YowAxolotlLayer,
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
else:
layers = (
EchoLayer,
YowParallelLayer([YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer, YowIqProtocolLayer, YowCallsProtocolLayer]),
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
self.stack = YowStack(layers)
self.stack.setCredentials(credentials)
def start(self):
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
logging.info("Whatsapp IS STARTING : ReceiveStack");
self.stack.loop(timeout=1, count=100)
logging.info("Stopping ... ");
except AuthError as e:
logging.info("Authentication Error: %s" % e.message)
class YowsupEchoStack(object):
def __init__(self, credentials):
layers = (
EchoLayer,
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer),
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
self.stack = YowStack(layers)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, credentials)
self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
self.stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
self.stack.setProp(YowCoderLayer.PROP_RESOURCE, YowConstants.RESOURCE)
def start(self):
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
from yowsup.layers.protocol_messages import YowMessagesProtocolLayer
from yowsup.layers.protocol_receipts import YowReceiptProtocolLayer
from yowsup.layers.protocol_acks import YowAckProtocolLayer
from yowsup.layers.network import YowNetworkLayer
from yowsup.layers.coder import YowCoderLayer
from yowsup.stacks import YowStack
from yowsup.common import YowConstants
from yowsup.layers import YowLayerEvent
from yowsup.stacks import YowStack, YOWSUP_CORE_LAYERS
from yowsup import env
import logging
logging.basicConfig(level=logging.DEBUG)
CREDENTIALS = ("919872736838", "yWcmikNwHmDPJ6xPeXOS0bk1X14=") # replace with your phone and password
if __name__== "__main__":
layers = (
EchoLayer,
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer), YowAxolotlLayer
) + YOWSUP_CORE_LAYERS
stack = YowStack(layers)
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, CREDENTIALS) #setting credentials
stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0]) #whatsapp server address
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource()) #info about us as WhatsApp client
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT)) #sending the connect signal
stack.loop() #this is the program mainloop
from yowsup.layers.logger import YowLoggerLayer
from yowsup.layers.protocol_iq import YowIqProtocolLayer
from yowsup.layers.protocol_calls import YowCallsProtocolLayer
from yowsup.layers.axolotl import YowAxolotlLayer
from yowsup.common import YowConstants
from yowsup import env
if os.environ['DEBUG'] == '1':
logging.basicConfig(level=logging.DEBUG)
CREDENTIALS = (os.environ['PHONE'], os.environ['PASSWORD'])
if __name__ == "__main__":
layers = (ReceiveLayer,
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer,
YowReceiptProtocolLayer, YowAckProtocolLayer,
YowMediaProtocolLayer, YowIqProtocolLayer,
YowCallsProtocolLayer, YowProfilesProtocolLayer),
YowAxolotlLayer, YowLoggerLayer, YowCoderLayer, YowCryptLayer,
YowStanzaRegulator, YowNetworkLayer)
stack = YowStack(layers)
stack.setCredentials(CREDENTIALS)
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
stack.loop(timeout=0.5, discrete=0.5)
except AuthError as e:
print("Authentication Error: %s" % e.message)
def main():
''' Console script to start the bot or output default config file. '''
# Arguments
parser = argparse.ArgumentParser(
description=_('Start Tombot, a chatbot for Whatsapp'))
parser.add_argument('-v',
'--verbose',
help=_("enable debug logging"),
action='store_true')
parser.add_argument('-d',
'--dry-run',
help=_("don't actually start bot, but print config"),
action='store_true')
parser.add_argument(
'-p',
'--poke',
action='store_true',
help=_("do everything except connecting (for testing)"))
parser.add_argument('configfile',
help=_("config file location"),
nargs='?')
args = parser.parse_args()
# Set up logging
if args.verbose:
loglevel = logging.DEBUG
else:
loglevel = logging.INFO
logging.basicConfig(level=loglevel,
format='%(levelname)s - %(name)s - %(message)s')
# Read configuration
specpath = os.path.join(os.path.dirname(__file__), 'configspec.ini')
config = ConfigObj(args.configfile, configspec=specpath)
if not args.dry_run:
config.validate(Validator())
if not args.configfile:
error = _("You must specify a config file!")
generate_hint = _("Generate one using 'tombot -d > file.ini'.")
logging.critical(error)
logging.critical(generate_hint)
sys.exit(1)
# Build scheduler, will be started in the bot's layer once connected
jobstores = {
'default': SQLAlchemyJobStore(url='sqlite:///jobs.sqlite'),
}
scheduler = BackgroundScheduler(jobstores=jobstores)
# Build Yowsup stack
credentials = (config['Yowsup']['username'],
config['Yowsup']['password'])
bot = TomBotLayer(config, scheduler)
layers = (
bot,
YowParallelLayer([
YowPresenceProtocolLayer, YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer, YowIqProtocolLayer,
YowReceiptProtocolLayer, YowChatstateProtocolLayer,
YowAckProtocolLayer, YowGroupsProtocolLayer
]),
YowAxolotlLayer,
) + YOWSUP_CORE_LAYERS
stack = YowStack(layers)
# Set credentials, server address, info about us as WhatsApp client
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS,
credentials)
stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
# Send connect signal if we aren't poking at the bot
if not args.poke:
stack.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
stack.loop(timeout=0.5,
discrete=0.5) #this is the program mainloop
else:
code.interact(local=locals())
else:
# Output config file to stdout
config.filename = None
config.validate(Validator(), copy=True)
output = config.write()
for line in output:
print(line)
from yowsup.layers.protocol_receipts import YowReceiptProtocolLayer
from yowsup.layers.protocol_acks import YowAckProtocolLayer
from yowsup.layers.network import YowNetworkLayer
from yowsup.layers.coder import YowCoderLayer
from yowsup.layers.protocol_iq import YowIqProtocolLayer
from yowsup.stacks import YowStack
from yowsup.common import YowConstants
from yowsup.layers import YowLayerEvent
from yowsup.stacks import YowStack, YOWSUP_CORE_LAYERS
from yowsup.layers.axolotl import YowAxolotlLayer
from yowsup.env import YowsupEnv
CREDENTIALS = ("CC9999999999", "password-here") # replace with your phone and password
if __name__== "__main__":
layers = (
EchoLayer,
YowParallelLayer([YowAuthenticationProtocolLayer, YowIqProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer]),YowAxolotlLayer
) + YOWSUP_CORE_LAYERS
stack = YowStack(layers)
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, CREDENTIALS) #setting credentials
stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0]) #whatsapp server address
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
stack.setProp(YowCoderLayer.PROP_RESOURCE, YowsupEnv.getCurrent().getResource()) #info about us as WhatsApp client
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT)) #sending the connect signal
stack.loop() #this is the program mainloop
from yowsup.common import YowConstants
from yowsup.layers import YowLayerEvent
from yowsup.layers.axolotl import YowAxolotlLayer
from yowsup.env import YowsupEnv
CREDENTIALS = ("phone number here", "password here"
) # replace with your phone and password
if __name__ == "__main__":
layers = (Robotinic,
YowParallelLayer([
YowAuthenticationProtocolLayer, YowMessagesProtocolLayer,
YowReceiptProtocolLayer, YowAckProtocolLayer
]), YowAxolotlLayer, YowCoderLayer, YowCryptLayer,
YowStanzaRegulator, YowNetworkLayer)
stack = YowStack(layers)
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS,
CREDENTIALS) # setting credentials
stack.setProp(YowNetworkLayer.PROP_ENDPOINT,
YowConstants.ENDPOINTS[0]) # whatsapp server address
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
stack.setProp(YowCoderLayer.PROP_RESOURCE,
YowsupEnv.getCurrent().getResource()
) # info about us as WhatsApp client
stack.broadcastEvent(YowLayerEvent(
YowNetworkLayer.EVENT_STATE_CONNECT)) # sending the connect signal
stack.loop() # this is the main program loop
# YowParallelLayer([YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer, YowIqProtocolLayer, YowCallsProtocolLayer]),YowAxolotlLayer
# ) + YOWSUP_CORE_LAYERS
YowParallelLayer([
YowAuthenticationProtocolLayer, YowMessagesProtocolLayer,
YowReceiptProtocolLayer, YowAckProtocolLayer,
YowMediaProtocolLayer, YowIqProtocolLayer, YowCallsProtocolLayer
]),
YowAxolotlLayer,
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer)
stack = YowStack(layers)
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS,
CREDENTIALS) #setting credentials
stack.setProp(YowNetworkLayer.PROP_ENDPOINT,
YowConstants.ENDPOINTS[0]) #whatsapp server address
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
stack.setProp(
YowCoderLayer.PROP_RESOURCE,
env.CURRENT_ENV.getResource()) #info about us as WhatsApp client
stack.broadcastEvent(YowLayerEvent(
YowNetworkLayer.EVENT_STATE_CONNECT)) #sending the connect signal
print 'going into stack loop'
stack.loop(timeout=15, discrete=15) #this is the program mainloop
print 'stack loop finished'
from yowsup import env
from layer import EchoLayer
from yowsup.layers.auth import YowCryptLayer, YowAuthenticationProtocolLayer, AuthError
from yowsup.layers.coder import YowCoderLayer
from yowsup.layers.network import YowNetworkLayer
from yowsup.layers.protocol_messages import YowMessagesProtocolLayer
from yowsup.layers.stanzaregulator import YowStanzaRegulator
from yowsup.layers.axolotl import YowAxolotlLayer
CREDENTIALS = ("Aca su No de celular", "Su password")
if __name__== "__main__":
layers = (
EchoLayer,
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer),
YowAxolotlLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
stack = YowStack(layers)
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, CREDENTIALS) #setting credentials
stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0]) #whatsapp server address
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource()) #info about us as WhatsApp client
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT)) #sending the connect signal
stack.loop( timeout = 0.5, discrete = 0.5 )
class Whatsapp():
def __init__(self, smarthome, account, password, trusted=None, logic='Whatsapp', cli_mode='False'):
# Set Plugin Attributes
self._sh = smarthome
self._credentials = (account, password.encode('utf-8'))
self._trusted = trusted
self._logic = logic
self._run = False
if cli_mode == 'True':
self._cli_mode = True
return
else:
self._cli_mode = False
# Yowsup Layers
self._layers = (
SmarthomeLayer,
YowParallelLayer((YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowIbProtocolLayer, YowIqProtocolLayer, YowNotificationsProtocolLayer, YowPresenceProtocolLayer)),
YowCoderLayer,
# YowLoggerLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer)
# Yowsup Properties
self._stack = YowStack(self._layers)
self._stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, self._credentials)
self._stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
self._stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
self._stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())
# Connect Yowsup
self._stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
# Get SmarthomeLayer and set this Plugin
self._SmarthomeLayer = self._stack.getLayer(len(self._stack._YowStack__stack) - 1)
self._SmarthomeLayer.setPlugin(self)
def run(self):
self._run = True
if self._cli_mode == True:
return
try:
self._stack.loop(timeout = 0.5, discrete = 0.5)
except AuthError as e:
logger.info("Authentication Error!")
def stop(self):
self._run = False
if self._cli_mode == True:
return
logger.info("Shutting Down WhatsApp Client")
disconnectEvent = YowLayerEvent(YowNetworkLayer.EVENT_STATE_DISCONNECT)
self._stack.broadcastEvent(disconnectEvent)
def parse_item(self, item):
return None
def parse_logic(self, logic):
pass
def __call__(self, message, phoneNumber=None):
if phoneNumber == None:
try:
phoneNumber = self._trusted.split(' ')[0]
except AttributeError:
logger.error("Error sending Whatsapp Message")
except IndentationError:
logger.error("Error sending Whatsapp Message")
if self._cli_mode == True:
subprocess.call(['/usr/local/bin/yowsup-cli', 'demos', '-l', self._credentials[0] + ':' + self._credentials[1].decode(), '-s', phoneNumber, message])
return
self._SmarthomeLayer.sendMsg(message, phoneNumber)
def message_received(self, message, sender):
try:
self._sh.trigger(name=self._logic, value=message, source=sender.split('@')[0])
except AttributeError:
logger.error("Error receiving Whatsapp Message")
except IndentationError:
logger.error("Error receiving Whatsapp Message")
from RetransLayer import RetransLayer
from yowsup.layers import YowParallelLayer, YowLayerEvent
from yowsup.layers.protocol_receipts import YowReceiptProtocolLayer
from yowsup.layers.auth import YowAuthenticationProtocolLayer
from yowsup.layers.protocol_messages import YowMessagesProtocolLayer
from yowsup.layers.protocol_acks import YowAckProtocolLayer
from yowsup.layers.axolotl import AxolotlSendLayer, AxolotlControlLayer, AxolotlReceivelayer
from yowsup.layers.network import YowNetworkLayer
from yowsup.stacks import YowStack, YOWSUP_CORE_LAYERS
vk_credentials = (6376055, input('enter you vk login\n'),
input('enter you vk password\n'))
whatsapp_credentials = (
input('enter you phone number for whatsapp\n'),
input('enter the code you\'ve received via yowsup cli\n'))
AXOLOTL_LAYERS = (YowParallelLayer([AxolotlSendLayer,
AxolotlReceivelayer]), AxolotlControlLayer)
layers = (RetransLayer,
YowParallelLayer([
YowAuthenticationProtocolLayer, YowMessagesProtocolLayer,
YowAckProtocolLayer, YowReceiptProtocolLayer
])) + AXOLOTL_LAYERS + YOWSUP_CORE_LAYERS
stack = YowStack(layers)
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS,
whatsapp_credentials)
stack.setProp('vk_credentials', vk_credentials)
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
stack.loop()
