This sample shows how to use the [SleekXMPP](http://sleekxmpp.com/index.html)

client and [Flask](http://flask.pocoo.org/) to build a simple chatbot that can

be run on [Google Compute Engine](https://cloud.google.com/compute/). The

chatbot does two things:

1. Sends messages to XMPP users via http get:

* The server is running on port 5000

* if running on virtual machine use:

`http://<MACHINE IP>:5000/send_message?recipient=<RECIPIENT ADDRESS>&message=<MSG>`

* If running locally use:

`http://localhost:5000/send_message?recipient=<RECIPIENT ADDRESS>&message=<MSG>`

2. Responds to incoming messages with a Wikipedia page on the topic:

* Send a message with a topic (e.g., 'Hawaii') to the XMPP account the

server is using

* It should respond with a Wikipedia page (when one exists)

Follow the instructions at the

[Compute Engine Quickstart Guide](https://cloud.google.com/compute/docs/quickstart-linux)

on how to create a project, create a virtual machine, and connect to your

instance via SSH. Once you have done this, you may jump to

[Installing files and dependencies](#installing-files-and-dependencies).

You should also download the [Google Cloud SDK](https://cloud.google.com/sdk/).

It will allow you to access many of the features of Google Compute Engine via

your local machine.

**IMPORTANT** You must enable tcp traffic on port 5000 to send messages to the

XMPP server. This can be done by running the following SDK commands:

gcloud config set project <YOUR PROJECT NAME>

gcloud compute firewall-rules create wikibot-server-rule --allow tcp:5000 --source-ranges=0.0.0.0/0

Or you can create a new firewall rule via the UI in the

[Networks](https://console.cloud.google.com/networking/networks/list) section of

the Google Cloud Console.

First, install the `wikibot.py` and `requirements.txt` files onto your remote

instance. See the guide on

[Transferring Files](https://cloud.google.com/compute/docs/instances/transfer-files)

for more information on how to do this using the Mac file browser, `scp`, or

the Google Cloud SDK.

Before running or deploying this application, you must install the dependencies

using [pip](http://pip.readthedocs.io/en/stable/):

pip install -r requirements.txt

You'll need to have an XMPP account prior to actually running the sample.

If you do not have one, you can easily create an account at one of the many

XMPP servers such as [Jabber.at](https://jabber.at/account/register/).

Once you have an account, run the following command:

python wikibot.py '<YOUR XMPP USERNAME>' '<PASSWORD>'

Where the username (e.g., 'bob@jabber.at') and password for the account that

you'd like to use for your chatbot are passed in as arguments.

Enter control-C to stop the server

You may also run the sample locally by simply copying `wikibot.py` to a project

directory and installing all python dependencies there.

import argparse

import getpass

import json

import logging

import threading

import urllib

from flask import Flask, request

import requests

import sleekxmpp

app = Flask(__name__)

def send_message():

recipient = request.args.get('recipient')

message = request.args.get('message')

if chat_client and recipient and message:

chat_client.send_message(mto=recipient, mbody=message)

return 'message sent to {} with body: {}'.format(recipient, message)

else:

logging.info('chat client or recipient or message does not exist!')

return 'message failed to send', 400

def run_server(host='0.0.0.0'):

app.run(threaded=False, use_reloader=False, host=host)

class WikiBot(sleekxmpp.ClientXMPP):

"""A simple SleekXMPP bot that will take messages, look up their content on

def __init__(self, jid, password):

sleekxmpp.ClientXMPP.__init__(self, jid, password)

# The session_start event will be triggered when

# the bot establishes its connection with the server

# and the XML streams are ready for use. We want to

# listen for this event so that we we can initialize

# our roster.

self.add_event_handler('session_start', self.start)

# The message event is triggered whenever a message

# stanza is received. Be aware that that includes

# MUC messages and error messages.

self.add_event_handler('message', self.message)

def start(self, event):

"""Process the session_start event.

self.send_presence()

self.get_roster()

def message(self, msg):

"""Process incoming message stanzas.

if msg['type'] in ('chat', 'normal'):

msg_body = msg['body']

logging.info('Message sent was: {}'.format(msg_body))

encoded_body = urllib.quote_plus(msg_body)

svrResponse = requests.get(

'https://en.wikipedia.org/w/api.php?'

'action=parse&prop=sections&format=json&page={}'.format(

encoded_body))

doc = json.loads(svrResponse.content)

try:

page_id = str(doc['parse']['pageid'])

defn_url = 'https://en.wikipedia.org/?curid={}'.format(page_id)

msg.reply('find out more about: "{}" here: {}'.format(

msg_body, defn_url)).send()

except KeyError as e:

logging.info('key error: {0}'.format(e))

msg.reply('I wasn\'t able to locate info on "{}" Sorry'.format(

msg_body)).send()

if __name__ == '__main__':

# Setup the command line arguments.

parser = argparse.ArgumentParser(

description=__doc__,

formatter_class=argparse.RawDescriptionHelpFormatter)

# Output verbosity options.

parser.add_argument(

'-q', '--quiet', help='set logging to ERROR', action='store_const',

dest='loglevel', const=logging.ERROR, default=logging.INFO)

parser.add_argument(

'-d', '--debug', help='set logging to DEBUG', action='store_const',

dest='loglevel', const=logging.DEBUG, default=logging.INFO)

parser.add_argument(

'-v', '--verbose', help='set logging to COMM', action='store_const',

dest='loglevel', const=5, default=logging.INFO)

# JID and password options.

parser.add_argument('-j', '--jid', help='JID to use', required=True)

parser.add_argument('-p', '--password', help='password to use')

args = parser.parse_args()

# Setup logging.

logging.basicConfig(level=args.loglevel,

format='%(levelname)-8s %(message)s')

if args.password is None:

args.password = getpass.getpass('Password: ')

# Setup the WikiBot and register plugins. Note that while plugins may

# have interdependencies, the order in which you register them does

# not matter.

xmpp = WikiBot(args.jid, args.password)

xmpp.register_plugin('xep_0030') # Service Discovery

xmpp.register_plugin('xep_0004') # Data Forms

xmpp.register_plugin('xep_0060') # PubSub

xmpp.register_plugin('xep_0199') # XMPP Ping

chat_client = xmpp # set the global variable

# start the app server and run it as a thread so that the XMPP server may

# also start

threading.Thread(target=run_server).start()

# Connect to the XMPP server and start processing XMPP stanzas.

if xmpp.connect():

xmpp.process(block=True)

print('Done')

else:

print('Unable to connect.')