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 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 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()
def connect_whatsapp(phone, password, encryption, reply_url):
layers = (
ServerLayer,
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer,
YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer),
)
if encryption:
logging.info("Adding encryption layer")
layers = layers + (YowAxolotlLayer, )
else:
env.CURRENT_ENV = env.S40YowsupEnv()
layers = layers + YOWSUP_CORE_LAYERS
stack = YowStack(layers)
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS,
(phone, password)) #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.setProp(ServerLayer.PROP_REPLY_URL, reply_url)
return stack
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 __init__(self, credentials, encryptionEnabled = False):
if encryptionEnabled:
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(credentials)
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 __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,
YowParallelLayer([
YowAuthenticationProtocolLayer,
YowContactsIqProtocolLayer, YowReceiptProtocolLayer,
YowAckProtocolLayer
]), YowAxolotlLayer, YowLoggerLayer, YowCoderLayer,
YowCryptLayer, YowStanzaRegulator, YowNetworkLayer)
else:
layers = (SyncLayer,
YowParallelLayer([
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 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)
def __init__(self, credentials, encryptionEnabled=False):
if encryptionEnabled:
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.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 __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 __init__(self): env.CURRENT_ENV = env.S40YowsupEnv() layers = (YowsupAppLayer, YowParallelLayer((YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer, YowIbProtocolLayer, YowIqProtocolLayer, YowNotificationsProtocolLayer, YowContactsIqProtocolLayer, YowChatstateProtocolLayer, YowCallsProtocolLayer, YowPrivacyProtocolLayer, YowProfilesProtocolLayer, YowGroupsProtocolLayer, YowPresenceProtocolLayer)), YowAxolotlLayer, YowCoderLayer, YowCryptLayer, YowStanzaRegulator, YowNetworkLayer ) self.logger = logging.getLogger(self.__class__.__name__) self.stack = YowStack(layers) self.stack.broadcastEvent( YowLayerEvent(YowsupAppLayer.EVENT_START, caller = self) )
def setUp(self):
#YowAuthenticatorLayer.__init__(self)
super(YowAuthenticationProtocolLayer, self).__init__()
dummyStack = YowStack()
self.setStack(dummyStack)
self.credentials = ("dummyusername", bytearray("password", "latin-1"))
dummyStack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, self.credentials)
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 __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 __init__(self,
imap_data,
smtp_data,
credentials,
encryptionEnabled=False):
if encryptionEnabled:
layers = (YowParallelLayer(
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer,
YowReceiptProtocolLayer, YowAckProtocolLayer,
YowMediaProtocolLayer, YowIqProtocolLayer,
YowCallsProtocolLayer), ), YowAxolotlLayer, YowLoggerLayer,
YowCoderLayer, YowCryptLayer, YowStanzaRegulator,
YowTwistedNetworkLayer)
else:
env.CURRENT_ENV = env.S40YowsupEnv()
layers = (YowParallelLayer(
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer,
YowReceiptProtocolLayer, YowAckProtocolLayer,
YowMediaProtocolLayer, YowIqProtocolLayer,
YowCallsProtocolLayer), ), YowLoggerLayer, YowCoderLayer,
YowCryptLayer, YowStanzaRegulator,
YowTwistedNetworkLayer)
if smtp_data:
layers = (YowTwistedSmtpLayer, ) + layers
if imap_data:
layers = (YowTwistedImapLayer, ) + 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())
if smtp_data:
self.stack.setProp(YowTwistedSmtpLayer.PROP_USER, smtp_data[0])
self.stack.setProp(YowTwistedSmtpLayer.PROP_PASS, smtp_data[1])
self.stack.setProp(YowTwistedSmtpLayer.PROP_ENDPOINT, smtp_data[2])
self.stack.setProp(YowTwistedSmtpLayer.PROP_DST_MAIL, smtp_data[3])
self.stack.setProp(YowTwistedSmtpLayer.PROP_REPLY_MAIL,
smtp_data[4])
if imap_data:
self.stack.setProp(YowTwistedImapLayer.PROP_USER, imap_data[0])
self.stack.setProp(YowTwistedImapLayer.PROP_PASS, imap_data[1])
self.stack.setProp(YowTwistedImapLayer.PROP_ENDPOINT, imap_data[2])
self.stack.setProp(YowTwistedImapLayer.PROP_DST_PHONE,
imap_data[3])
def __init__(self, credentials):
"""Default Yowsup setup, with the Route Layer on top"""
layers = (RouteLayer,
YowParallelLayer([YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer,
YowReceiptProtocolLayer,
YowAckProtocolLayer,
YowMediaProtocolLayer,
YowIqProtocolLayer]),
YowAxolotlLayer,
) + YOWSUP_CORE_LAYERS
self.stack = YowStack(layers)
self.stack.setCredentials(credentials)
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 __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 _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 __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 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
class YowsupDaemon(Daemon):
def run(self):
credentials = settings.get('Yowsup')
phone = credentials['phone']
password = credentials['pwd']
CREDENTIALS = (phone, password) # replace with your phone and password
logging.basicConfig(level = logging.DEBUG)
layers = (
HomeLayer,
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() #this is the program mainloop
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 __init__(self, credentials, messages, encryptionEnabled = False):
"""
:param credentials:
:param messages: list of (jid, message) tuples
:param encryptionEnabled:
:return:
"""
if encryptionEnabled:
layers = (
SendLayer,
(YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer),
YowAxolotlLayer,
YowLoggerLayer,
YowCoderLayer,
YowCryptLayer,
YowStanzaRegulator,
YowNetworkLayer
)
else:
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 __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())
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)
