def start(self, config):
yowsupConfig = config["Yowsup"]
credentials = (yowsupConfig["Username"], yowsupConfig["Password"]) # replace with your phone and password
sendQueue = queue.Queue()
stackBuilder = YowStackBuilder()
self.stack = stackBuilder.pushDefaultLayers(True).push(QueueLayer(sendQueue)).build()
beanstalkdConfig = config["Beanstalkd"]
beanstalkdStack = BeanstalkStack()
beanstalkdStack.setConnectParams(beanstalkdConfig["Host"], beanstalkdConfig["Port"], sendQueue, self.stack)
beanstalkdStack.daemon = True
beanstalkdStack.start()
self.stack.setCredentials(credentials)
connectEvent = YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT)
self.stack.broadcastEvent(connectEvent)
while 1:
try:
# self.stack.loop(timeout = 0.5, discrete = 0.5)
self.stack.loop(timeout=0.5)
except AuthError as e:
print("Auth Error, reason %s" % e)
# Bugfix for : https://github.com/tgalal/yowsup/issues/978
except DuplicateMessageException as e:
print("Please delete .yowsup/<yournumber>/axolotl.db")
break
pass
def __init__(self, credentials, encryptionEnabled = False):
stackBuilder = YowStackBuilder()
self.stack = stackBuilder.pushDefaultLayers(encryptionEnabled).push(SendLayer).build()
# self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
self.stack.setCredentials(credentials)
def setup_stack(credentials, target_dir):
stack_builder = YowStackBuilder()
stack = stack_builder.pushDefaultLayers(
axolotl=True).push(LogLayer).build()
stack.setCredentials(credentials)
stack.setProp(LogLayer.PROP_TARGET, target_dir)
return stack
def prepare_stack(self, credentials, messages):
stackBuilder = YowStackBuilder()
stack = stackBuilder.pushDefaultLayers(True).push(EchoLayer).build()
stack.setProp("messages", messages)
stack.setCredentials(credentials)
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
return stack
def workerwhatsapp():
stackBuilder = YowStackBuilder()
stack = stackBuilder.pushDefaultLayers(True).push(laye).build()
stack.setCredentials(CREDENTIALS)
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
stack.setProp(YowCoderLayer.PROP_RESOURCE,
YowsupEnv.getCurrent().getResource())
stack.loop(timeout=0.5, discrete=0.5)
def prepare_stack(self, credentials, messages):
stackBuilder = YowStackBuilder()
stack = stackBuilder.pushDefaultLayers(True).push(EchoLayer).build()
stack.setProp("messages", messages)
stack.setCredentials(credentials)
stack.broadcastEvent(YowLayerEvent(
YowNetworkLayer.EVENT_STATE_CONNECT))
return stack
def __init__(self, credentials):
"Creates the stacks of the Yowsup Server,"
self.credentials = credentials
stack_builder = YowStackBuilder().pushDefaultLayers(True)
# on the top stack, the two layers that controls the bot and respond to messages and notifications
# see both of classes for more documentation
stack_builder.push(YowParallelLayer([EchoLayer]))
## stack_builder.push(YowParallelLayer([RouteLayer, NotificationsLayer]))
self.stack = stack_builder.build()
self.stack.setCredentials(credentials)
def __init__(self, credentials):
"Creates the stacks of the Yowsup Server,"
self.credentials = credentials
stack_builder = YowStackBuilder().pushDefaultLayers(True)
# on the top stack, the two layers that controls the bot and respond to messages and notifications
# see both of classes for more documentation
stack_builder.push(YowParallelLayer([EchoLayer]))
## stack_builder.push(YowParallelLayer([RouteLayer, NotificationsLayer]))
self.stack = stack_builder.build()
self.stack.setCredentials(credentials)
def __init__(self,
credentials,
date,
encryptionEnabled=True,
verbose=False):
stackBuilder = YowStackBuilder()
self.stack = stackBuilder.pushDefaultLayers(encryptionEnabled).push(
YowsupNewsbotLayer(date, verbose)).build()
self.stack.setCredentials(credentials)
self.stack.setProp(PROP_IDENTITY_AUTOTRUST, True)
def loop(self):
# set the yowsup environment - not supported in fork
# YowsupEnv.setEnv(self.yowsup_env)
stackBuilder = YowStackBuilder()
# Create the default stack (a pile of layers) and add the Ongair Layer to the top of the stack
stack = stackBuilder.pushDefaultLayers(True).push(OngairLayer).build()
ping_interval = int(get_env('ping_interval'))
# Set the phone number as a property that can be read by other layers
stack.setProp(YowIqProtocolLayer.PROP_PING_INTERVAL, ping_interval)
stack.setProp('ongair.account', self.phone_number)
stack.setProp(YowNetworkLayer.PROP_ENDPOINT,
YowConstants.ENDPOINTS[0]) # whatsapp server address
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
# Broadcast the login event. This gets handled by the OngairLayer
stack.broadcastEvent(YowLayerEvent(OngairLayer.EVENT_LOGIN))
try:
# Run the asyncore loop
stack.loop(timeout=0.5,
discrete=0.5) # this is the program mainloop
except AttributeError:
# for now this is a proxy for ProtocolException i.e. where yowsup has tried to read an
# attribute that does not exist
self.logger.exception("Attribute error")
rollbar.report_exc_info()
sys.exit(0)
except AssertionError:
# this is a proxy for a wrong expected attribute
self.logger.exception("Assertion error")
rollbar.report_exc_info()
sys.exit(0)
except KeyboardInterrupt:
# manually stopped. more a development debugging issue
self.logger.info("Manually interupted")
sys.exit(2)
except PingTimeoutError:
self.logger.info("Ping timeout error")
sys.exit(2)
except RequestedDisconnectError:
self.logger.info("We requested to disconnect")
sys.exit(2)
except ConnectionClosedError:
self.logger.info("Disconnected")
sys.exit(2)
except:
self.logger.exception("Unknown error")
rollbar.report_exc_info()
# do not restart as we are not sure what the problem is
sys.exit(0)
def loop(self):
# set the yowsup environment - not supported in fork
# YowsupEnv.setEnv(self.yowsup_env)
stackBuilder = YowStackBuilder()
# Create the default stack (a pile of layers) and add the Ongair Layer to the top of the stack
stack = stackBuilder.pushDefaultLayers(True).push(OngairLayer).build()
ping_interval = int(get_env('ping_interval'))
# Set the phone number as a property that can be read by other layers
stack.setProp(YowIqProtocolLayer.PROP_PING_INTERVAL, ping_interval)
stack.setProp('ongair.account', self.phone_number)
stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0]) # whatsapp server address
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
# Broadcast the login event. This gets handled by the OngairLayer
stack.broadcastEvent(YowLayerEvent(OngairLayer.EVENT_LOGIN))
try:
# Run the asyncore loop
stack.loop(timeout=0.5, discrete=0.5) # this is the program mainloop
except AttributeError:
# for now this is a proxy for ProtocolException i.e. where yowsup has tried to read an
# attribute that does not exist
self.logger.exception("Attribute error")
rollbar.report_exc_info()
sys.exit(0)
except AssertionError:
# this is a proxy for a wrong expected attribute
self.logger.exception("Assertion error")
rollbar.report_exc_info()
sys.exit(0)
except KeyboardInterrupt:
# manually stopped. more a development debugging issue
self.logger.info("Manually interupted")
sys.exit(2)
except PingTimeoutError:
self.logger.info("Ping timeout error")
sys.exit(2)
except RequestedDisconnectError:
self.logger.info("We requested to disconnect")
sys.exit(2)
except ConnectionClosedError:
self.logger.info("Disconnected")
sys.exit(2)
except:
self.logger.exception("Unknown error")
rollbar.report_exc_info()
# do not restart as we are not sure what the problem is
sys.exit(0)
def run(phone, password):
# credentials = (phone.encode(), password.encode())
stackBuilder = YowStackBuilder()
stack = stackBuilder.pushDefaultLayers(True).push(BotLayer()).build()
# Setting credentials
stack.setCredentials((phone, password))
# Whatsapp server address
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
stack.loop()
def start(self, incoming, outgoing):
# TODO: Is encryption possible with groups?
use_encryption = False
self.incoming = incoming
stackBuilder = YowStackBuilder()
self.stack = stackBuilder \
.pushDefaultLayers(use_encryption) \
.push(MsgCenterLayer) \
.build()
self.stack.setCredentials(self.credentials)
self.stack.setProp(MsgCenterLayer.PROP_OUTGOING, outgoing)
self.stack.setProp(MsgCenterLayer.PROP_BACKEND_NAME, self.name)
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
# TODO:Use multiprocessing. There seems to be a problem with yowsup:
# https://github.com/tgalal/yowsup/issues/717
p = Thread(target=self.wait_incoming_msgs)
p.start()
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e)
def start(self,config):
yowsupConfig = config['Yowsup']
credentials = (yowsupConfig["Username"], yowsupConfig["Password"]) # replace with your phone and password
sendQueue = queue.Queue()
stackBuilder = YowStackBuilder()
self.stack = stackBuilder \
.pushDefaultLayers(True) \
.push(QueueLayer(sendQueue)) \
.push(YowMediaProtocolLayer) \
.build()
beanstalkdConfig = config['Beanstalkd']
beanstalkdStack = BeanstalkStack()
beanstalkdStack.setConnectParams(beanstalkdConfig["Host"], beanstalkdConfig["Port"], sendQueue, self.stack)
beanstalkdStack.daemon = True
beanstalkdStack.start()
self.stack.setCredentials(credentials)
connectEvent = YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT)
self.stack.broadcastEvent(connectEvent)
while 1:
try:
#self.stack.loop(timeout = 0.5, discrete = 0.5)
self.stack.loop(timeout = 0.5)
except AuthError as e:
print("Auth Error, reason %s" % e)
# Bugfix for : https://github.com/tgalal/yowsup/issues/978
except DuplicateMessageException as e:
print('Please delete .yowsup/<yournumber>/axolotl.db')
break
pass
def __init__(self, encryptionEnabled=True):
stackBuilder = YowStackBuilder()
self.stack = stackBuilder\
.pushDefaultLayers(encryptionEnabled)\
.push(YowsupWebLayer)\
.build()
self.stack.setProp(PROP_IDENTITY_AUTOTRUST, True)
def __init__(self, credentials=None, encryptionEnabled=True):
stackBuilder = YowStackBuilder()
self.stack = stackBuilder\
.pushDefaultLayers(encryptionEnabled)\
.push(layer.Insulter)\
.build()
self.stack.setCredentials(CREDENTIALS)
def __init__(self, profile, storage_dir=None):
stackBuilder = YowStackBuilder()
self._stack = stackBuilder\
.pushDefaultLayers()\
.push(MediaSinkLayer)\
.build()
self._stack.setProp(MediaSinkLayer.PROP_STORAGE_DIR, storage_dir)
self._stack.setProfile(profile)
def __init__(self, profile):
stackBuilder = YowStackBuilder()
self._stack = stackBuilder\
.pushDefaultLayers()\
.push(EchoLayer)\
.build()
self._stack.setProfile(profile)
def __init__(self, profile):
stackBuilder = YowStackBuilder()
self._stack = (stackBuilder
.pushDefaultLayers()
.push(SendLayer)
.build())
self._stack.setProfile(profile)
def __init__(self, credentials, encryptionEnabled=True):
stackBuilder = YowStackBuilder()
self.stack = stackBuilder\
.pushDefaultLayers(encryptionEnabled)\
.push(IncomingLayer)\
.push(OutgoingLayer)\
.build()
self.stack.setCredentials(credentials)
self.stack.setProp(YowAxolotlLayer.PROP_IDENTITY_AUTOTRUST, True)
def __init__(self, credentials, encryptionEnabled=True):
stackBuilder = YowStackBuilder()
self.stack = stackBuilder\
.pushDefaultLayers(encryptionEnabled)\
.push(BridgeLayer)\
.build()
self.stack.setCredentials(credentials)
def __init__(self, credentials):
stackBuilder = YowStackBuilder()
self._stack = stackBuilder\
.pushDefaultLayers()\
.push(EchoLayer)\
.build()
self._stack.setCredentials(credentials)
def __init__(self, profile):
stackBuilder = YowStackBuilder()
self._stack = stackBuilder\
.pushDefaultLayers()\
.push(EchoLayer)\
.build()
print(dir(self._stack))
self._stack.setCredentials(profile, )
def __init__(self, credentials, messages, encryptionEnabled=True):
stackBuilder = YowStackBuilder()
self.stack = stackBuilder\
.pushDefaultLayers(encryptionEnabled)\
.push(SendMediaLayer)\
.build()
self.stack.setProp(SendMediaLayer.PROP_MESSAGES, messages)
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
self.stack.setCredentials(credentials)
def __init__(self, credentials, encryptionEnabled=True):
stackBuilder = YowStackBuilder()
self.stack = stackBuilder\
.pushDefaultLayers(encryptionEnabled)\
.push(WhatsAppGatewayLayer)\
.build()
# Set the credentials set in the config/creds.py
self.stack.setCredentials(credentials)
def __init__(self, profile):
stackBuilder = YowStackBuilder()
self._stack = stackBuilder\
.pushDefaultLayers()\
.push(YowsupCliLayer)\
.build()
self._stack.setProfile(profile)
self._stack.setProp(PROP_IDENTITY_AUTOTRUST, True)
def __init__(self):
builder = YowStackBuilder()
self.stack = builder \
.pushDefaultLayers() \
.push(MacLayer) \
.build()
self.stack.setCredentials(credentials)
self.stack.setProp(MacLayer.PROP_CONTACTS, list(config.contacts.keys()))
self.stack.setProp(PROP_IDENTITY_AUTOTRUST, True)
def __init__(self, encryptionEnabled = True):
CREDENTIALS = credentials.get_credentials()
stackBuilder = YowStackBuilder()
self.stack = stackBuilder\
.pushDefaultLayers(encryptionEnabled)\
.push(EchoLayer)\
.build()
self.stack.setCredentials(CREDENTIALS)
def __init__(self, credentials):
stackBuilder = YowStackBuilder()
self._stack = stackBuilder\
.pushDefaultLayers()\
.push(YowsupCliLayer)\
.build()
self._stack.setCredentials(credentials)
self._stack.setProp(PROP_IDENTITY_AUTOTRUST, True)
def __init__(self, credentials, image_path, encryptionEnabled=True):
stackBuilder = YowStackBuilder()
self.stack = stackBuilder\
.pushDefaultLayers(encryptionEnabled)\
.push(WhatsappImageSendLayer)\
.build()
self.stack.setCredentials(credentials)
self.stack.setProp(PROP_IDENTITY_AUTOTRUST, True)
def __init__(self, credentials, encryptionEnabled = True):
stackBuilder = YowStackBuilder()
self.stack = stackBuilder\
.pushDefaultLayers(encryptionEnabled)\
.push(WhaLayer)\
.build()
self.stack.setCredentials(credentials)
self.stack.setProp(PROP_IDENTITY_AUTOTRUST, True) #not in jlguardi
self.wantReconnect = True
self.abortReconnectWait = queue.Queue()
def __init__(self, credentials, number, path, encryptionEnabled=True):
stackBuilder = YowStackBuilder()
self.stack = stackBuilder\
.pushDefaultLayers(encryptionEnabled)\
.push(YowsupCliLayer)\
.build()
myLayer = self.stack.getLayer(7)
myLayer.queueCmd('/login %s %s' % credentials)
myLayer.queueCmd('/image send %s %s' % (number, path))
self.stack.setCredentials(credentials)
def __init__(self):
builder = YowStackBuilder()
self.stack = builder\
.pushDefaultLayers(encryption)\
.push(BotLayer)\
.build()
self.stack.setCredentials(credentials)
self.stack.setProp(BotLayer.PROP_CONTACTS, contacts_numbers)
self.stack.setProp(PROP_IDENTITY_AUTOTRUST, True)
def __init__(self):
stackBuilder = YowStackBuilder()
self.profile = os.environ['phone_number']
self._stack = stackBuilder\
.pushDefaultLayers()\
.push(MainStrongFastSuperBot)\
.build()
self._stack.setProfile(self.profile)
self._stack.setProp(PROP_IDENTITY_AUTOTRUST, True)
def __init__(self, credentials):
"""
layers = (ReceiveLayer,
(YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer,
YowReceiptProtocolLayer,
YowAckProtocolLayer,
YowMediaProtocolLayer),
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)
"""
stackBuilder = YowStackBuilder()
self.stack = stackBuilder.pushDefaultLayers(True).push(EchoLayer).build()
self.stack.setCredentials(credentials)
class YowsupMyStack(object):
def __init__(self, credentials):
self.layer = MailLayer()
self.stack = YowStackBuilder().pushDefaultLayers(axolotl = True) \
.push(MailLayer) \
.build()
self.stack.setCredentials(credentials)
def startInputThread(self):
print "Starting input thread"
confinc = config['ingoing']
if confinc['with'] == "LMTP":
sockpath = confinc['socket']
self.server = YoLMTPServer(self.layer, self.stack, sockpath, None)
atexit.register(clean_lmtp)
elif confinc['with'] == "SMTP":
host = confinc['host']
port = confinc['port']
self.server = YoSMTPServer(self.layer, self.stack,(host, port), None)
elif confinc['with'] == "POP3":
self.server = Pop3Client(self.layer, self.stack, confinc)
elif confinc['with'] == "IMAP":
self.server = ImapClient(self.layer, self.stack, confinc)
else:
raise Exception("Unknown ingoing type")
def start(self):
self.startInputThread()
self.server.start()
self.stack.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
while True:
# FIXME: polling for IMAP and POP3, use async instead
if args.debug:
print "== WhatsApp loop"
self.stack.loop(timeout = 10, count = 1)
if args.debug:
print "== Server loop"
self.server.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
except Exception as e:
content = "Exception: %s\n\n%s" % (str(e), traceback.format_exc())
self.layer.sendEmailRaw(content, subject="WhatsApp crashed")
raise
from yowsup.stacks import YowStackBuilder
from layer import SendLayer
from yowsup.layers.auth import AuthError
from yowsup.layers import YowLayerEvent
from yowsup.layers.auth import YowAuthenticationProtocolLayer
from yowsup.layers.network import YowNetworkLayer
CREDENTIALS = ("917639905993", "RvA9EAe0Io3eUU+A2bJ19KxsYkA=") # replace with your phone and password
if __name__== "__main__":
stackBuilder = YowStackBuilder()
stack = stackBuilder.pushDefaultLayers(True).push(SendLayer).build()
messages = [
("*****@*****.**" , "Hello yo albin"),
]
stack.setProp(SendLayer.PROP_MESSAGES, messages)
stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, CREDENTIALS)
# stack.setCredentials(credentials)
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT)) #sending the connect signal
stack.loop() #this is the program mainloop
from yowsup.common.tools import StorageTools
from yowsup_ext.layers.cleverbot.layer import YowCleverBotLayer
from yowsup_ext.layers.store import YowStorageLayer
import sys
import logging
logging.basicConfig(level = logging.DEBUG)
logger = logging.getLogger(__name__)
if __name__ == "__main__":
if len(sys.argv) < 3:
print("Usage: run.py username password")
sys.exit(1)
credentials = (sys.argv[1], sys.argv[2])
stackBuilder = YowStackBuilder()
phoneStorage = StorageTools.getStorageForPhone(credentials[0])
stackBuilder.setProp(YowStorageLayer.PROP_DB_PATH, StorageTools.constructPath(phoneStorage, "yowstore.db"))
stack = stackBuilder\
.pushDefaultLayers(True)\
.push(YowStorageLayer)\
.push(YowCleverBotLayer)\
.build()
stack.setCredentials(credentials)
logger.info("Starting")
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
stack.loop(timeout = 0.5, discrete = 0.5)
except AuthError as e:
from yowsup.layers.network import YowNetworkLayer
from yowsup.layers import YowLayerEvent
from yowsup.stacks import YowStackBuilder
from palayer import PictureArchiverLayer
from config import CREDENTIALS
if __name__== "__main__":
stackbuilder = YowStackBuilder()
stack = stackbuilder.pushDefaultLayers(True).push(PictureArchiverLayer).build()
stack.setCredentials(CREDENTIALS)
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
stack.loop()
def __init__(self, credentials):
self.layer = MailLayer()
self.stack = YowStackBuilder().pushDefaultLayers(axolotl = True) \
.push(MailLayer) \
.build()
self.stack.setCredentials(credentials)
if demotepromote:
if person[1] != 'admin':
self.YOWCLI.group_promote(group.address, person[0])
else:
if person[1] == 'admin':
self.YOWCLI.group_demote(group.address, person[0])
if __name__== "__main__":
#if credentials are unavailable, launch auth window.
if len(CREDENTIALS[0]) < 2:
#print(CREDENTIALS[0])
auth_w = auth_window()
#initialize yowsup stack, with the layers we need.
StackBuilder = YowStackBuilder()
stack = StackBuilder.getDefaultStack(layer=YowsupCliLayer, axolotl=True)
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
for i in range(9):
#print(str(i)+" = "+str(stack.getLayer(i)))
if str(stack.getLayer(i)) == "CLI Interface Layer":
X = stack.getLayer(i)
break
