Medien Wiki - User contributions [en]

GMU:Bots 'n' Plots/Sebastian Stang

2015-10-24T09:20:41Z

SebastianStang:

https://twitter.com/pfftbot

removes phase information from images

[[Image:CSEhtXUXIAAuFvM.png]]
[[Image:CSEgxHFWUAA32HG.png]]
[[Image:CSEhNiDWwAAJtnb.png]]

<nowiki>#</nowiki>pfft

GMU:Bots 'n' Plots/Sebastian Stang

2015-10-24T09:20:28Z

SebastianStang:

https://twitter.com/pfftbot

removes phase information from an image

[[Image:CSEhtXUXIAAuFvM.png]]
[[Image:CSEgxHFWUAA32HG.png]]
[[Image:CSEhNiDWwAAJtnb.png]]

<nowiki>#</nowiki>pfft

GMU:Bots 'n' Plots/Sebastian Stang

2015-10-24T09:16:04Z

SebastianStang:

https://twitter.com/pfftbot

<nowiki>#</nowiki>pfft

[[Image:CSEhtXUXIAAuFvM.png]]
[[Image:CSEgxHFWUAA32HG.png]]
[[Image:CSEhNiDWwAAJtnb.png]]

File:CSEhtXUXIAAuFvM.png

2015-10-24T09:15:50Z

SebastianStang:

== Summary ==

== Copyright status: ==

== Source: ==

GMU:Bots 'n' Plots/Sebastian Stang

2015-10-24T09:15:27Z

SebastianStang:

https://twitter.com/pfftbot

<nowiki>#</nowiki>pfft

[[Image:CSEgxHFWUAA32HG.png]]
[[Image:CSEhNiDWwAAJtnb.png]]

File:CSEhNiDWwAAJtnb.png

2015-10-24T09:14:48Z

SebastianStang:

== Summary ==

== Copyright status: ==

== Source: ==

GMU:Bots 'n' Plots/Sebastian Stang

2015-10-24T09:14:35Z

SebastianStang:

https://twitter.com/pfftbot

<nowiki>#</nowiki>pfft

[[Image:CSEgxHFWUAA32HG.png]]

File:CSEgxHFWUAA32HG.png

2015-10-24T09:12:38Z

SebastianStang:

== Summary ==

== Copyright status: ==

== Source: ==

GMU:Bots 'n' Plots/Sebastian Stang

2015-10-24T09:11:20Z

SebastianStang:

<nowiki>#</nowiki>pfft

GMU:Bots 'n' Plots/Sebastian Stang

2015-10-24T09:10:06Z

SebastianStang: Replaced content with "( ) ( ) (>•.•<) <nowiki> (") (")</nowiki>"

( ) ( ) 
(>•.•<) 
<nowiki> (") (")</nowiki>

GMU:Bots 'n' Plots/Sebastian Stang

2015-06-17T16:07:42Z

SebastianStang:

( ) ( ) 
(>•.•<) 
<nowiki> (") (")</nowiki>

== @_pil_bot_ ==

compiles and runs code

https://twitter.com/_pil_bot_

[[File:Pilbot1.png|480px|thumb|left]]

[[File:Pilbot2.png|480px|thumb|left]]

<hr style="clear:both" />

=== pilbot.py ===

<source lang="python">
# -*- coding: utf-8 -*- #

from twitterbot import TwitterBot
import keys

from PIL import Image
from sys import argv
from random import random

from pileval import PILEval

class PilBot(TwitterBot):

def __init__(self):
TwitterBot.__init__(self)
self.pillermann = PILEval()

def bot_init(self):
""" Initialize and configure the bot """

############################
# REQUIRED: LOGIN DETAILS! #
############################
self.config['api_key'] = keys.consumer_key
self.config['api_secret'] = keys.consumer_secret
self.config['access_key'] = keys.access_token
self.config['access_secret'] = keys.access_token_secret

######################################
# SEMI-OPTIONAL: OTHER CONFIG STUFF! #
######################################

# how often to tweet, in seconds
self.config['tweet_interval'] = 1 * 5 # default: 1 minutes

# use this to define a (min, max) random range of how often to tweet
# e.g., self.config['tweet_interval_range'] = (5*60, 10*60) # tweets every 5-10 minutes
self.config['tweet_interval_range'] = None

# only reply to tweets that specifically mention the bot
self.config['reply_direct_mention_only'] = True

# only include bot followers (and original tweeter) in @-replies
self.config['reply_followers_only'] = False

# fav any tweets that mention this bot?
self.config['autofav_mentions'] = False

# fav any tweets containing these keywords?
self.config['autofav_keywords'] = []

# follow back all followers?
self.config['autofollow'] = False

def on_scheduled_tweet(self):
""" Make a public tweet to the bot's own timeline. """
# We might take senteces from somewhere and tweet them on a regular basis ...
pass # don't do anything here ...

def on_mention(self, tweet, prefix):
""" Actions to take when a mention is received. """
text = tweet.text.split()[1]
self.action(text)

def on_timeline(self, tweet, prefix):
""" Actions to take on a timeline tweet. """
pass

def action(self, code):
result = self.pillermann.eval(code)

if result: # post the image
self.post_tweet(code, media="img.png", file=self.pillermann.get_file())
else: # post the error
self.post_tweet(self.pillermann.last_error)

if __name__ == '__main__':

bot = PilBot()

if len(argv) == 1:
bot.run()
else:
tweet_text = "text((300, 400), 'botsNplots', fill='#ff0')"
bot.action(tweet_text)

</source>

=== pileval.py ===

<source lang="python">
from PIL import Image, ImageDraw

from os import path
from io import BytesIO

class PILEval():

def __init__(self, filename='test.png'):
self.filename = filename
try:
self.image = Image.open(filename)
except FileNotFoundError as e:
self.image = Image.new("RGBA", (640, 480), 'white')
self.last_error = ''

def __repr__(self):
return "<PILEval: %s>" % self.filename

def eval(self, code):
draw = ImageDraw.Draw(self.image, "RGBA")
code = "draw.%s" % code

try:
code_obj = compile(code, '<string>', 'exec')
exec(code_obj)
except Exception as e:
self.last_error = str(e)
return False

self.image.save(self.filename)

return True

def get_file(self):
img = Image.open(self.filename)
file = BytesIO()
img.save(file, format='PNG')
return file

if __name__ == '__main__':
# some q'n'dirty tests
print("main")
pillermann = PILEval()

# will work
# result = pillermann.eval("rectangle([20, 10, 120, 200], fill='#f00')")
# if result:
# print('good')

# will also work
# result = pillermann.eval("ellipse([200, 50, 500, 500], fill='#def')")
# result = pillermann.eval("point((123, 234), fill='#345')")
# result = pillermann.eval("line([23, 34, 345, 456], fill='#eca', width=10)")
# result = pillermann.eval("arc([500, 10, 600, 440], 10, 95, fill='#3f9')")
# result = pillermann.eval("text((22, 202), '_pil_bot_!', fill='#a4f')")

result = pillermann.eval("text((100, 100), text=code, fill='#000')")
if result:
print("ok")
else:
print(pillermann.last_error)
# will yield a compiler error
# result = pillermann.eval("rectangle([20, 10, 120, 200], fill='#f00'")
# if not result:
# print("error result: %s" % pillermann.last_error)

# f = pillermann.get_file()
# print(f)

</source>

=== twitterbot/bot.py ===

adapts thricedotted's (http://lczzz.me) twitterbot for python 3

<source lang="python">

import os
import codecs
import json
import logging
import tweepy
import time
import re
import random
import pickle

def ignore(method):
"""
Use the @ignore decorator on TwitterBot methods you wish to leave
unimplemented, such as on_timeline and on_mention.
"""
method.not_implemented = True
return method

class TwitterBot:

def __init__(self):
self.config = {}

self.custom_handlers = []

self.config['reply_direct_mention_only'] = False
self.config['reply_followers_only'] = True

self.config['autofav_mentions'] = False
self.config['autofav_keywords'] = []

self.config['autofollow'] = False

self.config['tweet_interval'] = 30 * 60
self.config['tweet_interval_range'] = None

self.config['reply_interval'] = 10
self.config['reply_interval_range'] = None

self.config['ignore_timeline_mentions'] = True

self.config['logging_level'] = logging.DEBUG
self.config['storage'] = FileStorage()

self.state = {}

# call the custom initialization
self.bot_init()

auth = tweepy.OAuthHandler(self.config['api_key'], self.config['api_secret'])
auth.set_access_token(self.config['access_key'], self.config['access_secret'])
self.api = tweepy.API(auth)

self.id = self.api.me().id
self.screen_name = self.api.me().screen_name

logging.basicConfig(format='%(asctime)s | %(levelname)s: %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p',
filename=self.screen_name + '.log',
level=self.config['logging_level'])

logging.info('Initializing bot...')

try:
with self.config['storage'].read(self.screen_name) as f:
self.state = pickle.load(f)

except IOError:
self.state['last_timeline_id'] = 1
self.state['last_mention_id'] = 1

self.state['last_timeline_time'] = 0
self.state['last_mention_time'] = 0

self.state['last_tweet_id'] = 1
self.state['last_tweet_time'] = 1

self.state['last_reply_id'] = 0
self.state['last_reply_time'] = 0

self.state['recent_timeline'] = []
self.state['mention_queue'] = []

self.state['friends'] = self.api.friends_ids(self.id)
self.state['followers'] = self.api.followers_ids(self.id)
self.state['new_followers'] = []
self.state['last_follow_check'] = 0

logging.info('Bot initialized!')

def bot_init(self):
"""
Initialize custom state values for your bot.
"""
raise NotImplementedError("You MUST have bot_init() implemented in your bot! What have you DONE!")

def log(self, message, level=logging.INFO):
if level == logging.ERROR:
logging.error(message)
else:
logging.info(message)

def _log_tweepy_error(self, message, e):
try:
e_message = e.message[0]['message']
code = e.message[0]['code']
self.log("{}: {} ({})".format(message, e_message, code), level=logging.ERROR)
except:
self.log(message, e)

def _tweet_url(self, tweet):
return "http://twitter.com/" + tweet.author.screen_name + "/status/" + str(tweet.id)

def _save_state(self):
with self.config['storage'].write(self.screen_name) as f:
pickle.dump(self.state, f)
self.log('Bot state saved')

def on_scheduled_tweet(self):
"""
Post a general tweet to own timeline.
"""
#self.post_tweet(text)
raise NotImplementedError("You need to implement this to tweet to timeline (or pass if you don't want to)!")

def on_mention(self, tweet, prefix):
"""
Perform some action upon receiving a mention.
"""
#self.post_tweet(text)
raise NotImplementedError("You need to implement this to reply to/fav mentions (or pass if you don't want to)!")

def on_timeline(self, tweet, prefix):
"""
Perform some action on a tweet on the timeline.
"""
#self.post_tweet(text)
raise NotImplementedError("You need to implement this to reply to/fav timeline tweets (or pass if you don't want to)!")

def on_follow(self, f_id):
"""
Perform some action when followed.
"""
if self.config['autofollow']:
try:
self.api.create_friendship(f_id, follow=True)
self.state['friends'].append(f_id)
logging.info('Followed user id {}'.format(f_id))
except tweepy.TweepError as e:
self._log_tweepy_error('Unable to follow user', e)

time.sleep(3)

self.state['followers'].append(f_id)

def post_tweet(self, text, reply_to=None, media=None, file=None):
"""
Post a tweet containing the text.
If you provide a filename the file will be added to the tweet.
You can also provide the filedata, for example when using dynamically created images.
"""

kwargs = { "status": text }
args = []

if media is not None:
cmd = self.api.update_with_media
args.insert(0, media)

if file is not None:
kwargs["file"] = file
else:
cmd = self.api.update_status

try:
self.log('Tweeting "{}"'.format(text))
if reply_to:
self.log("-- Responding to status {}".format(self._tweet_url(reply_to)))
kwargs['in_reply_to_status_id'] = reply_to.id
else:
self.log("-- Posting to own timeline")

tweet = cmd(*args, **kwargs)
self.log('Status posted at {}'.format(self._tweet_url(tweet)))
return True

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t post status', e)
return False

def favorite_tweet(self, tweet):
try:
logging.info('Faving ' + self._tweet_url(tweet))
self.api.create_favorite(tweet.id)

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t fav status', e)

def _ignore_method(self, method):
return hasattr(method, 'not_implemented') and method.not_implemented

def _handle_timeline(self):
"""
Reads the latest tweets in the bots timeline and perform some action.
self.recent_timeline
"""
for tweet in self.state['recent_timeline']:
prefix = self.get_mention_prefix(tweet)
self.on_timeline(tweet, prefix)

words = tweet.text.lower().split()
if any(w in words for w in self.config['autofav_keywords']):
self.favorite_tweet(tweet)

#time.sleep(self.config['reply_interval'])

def _handle_mentions(self):
"""
Performs some action on the mentions in self.mention_queue
"""
# TODO: only handle a certain number of mentions at a time?
for mention in iter(self.state['mention_queue']):
prefix = self.get_mention_prefix(mention)
self.on_mention(mention, prefix)
self.state['mention_queue'].remove(mention)

if self.config['autofav_mentions']:
self.favorite_tweet(mention)

#time.sleep(self.config['reply_interval'])

def get_mention_prefix(self, tweet):
"""
Returns a string of users to @-mention when responding to a tweet.
"""
mention_back = ['@' + tweet.author.screen_name]
mention_back += [s for s in re.split('[^@\w]', tweet.text) if len(s) > 2 and s[0] == '@' and s[1:] != self.screen_name]

if self.config['reply_followers_only']:
mention_back = [s for s in mention_back if s[1:] in self.state['followers'] or s == '@' + tweet.author.screen_name]

return ' '.join(mention_back)

def _check_mentions(self):
"""
Checks mentions and loads most recent tweets into the mention queue
"""
if self._ignore_method(self.on_mention):
logging.debug('Ignoring mentions')
return

try:
current_mentions = self.api.mentions_timeline(since_id=self.state['last_mention_id'], count=100)

# direct mentions only?
if self.config['reply_direct_mention_only']:
current_mentions = [t for t in current_mentions if re.split('[^@\w]', t.text)[0] == '@' + self.screen_name]

if len(current_mentions) != 0:
self.state['last_mention_id'] = current_mentions[0].id

self.state['last_mention_time'] = time.time()

self.state['mention_queue'] += reversed(current_mentions)

logging.info('Mentions updated ({} retrieved, {} total in queue)'.format(len(current_mentions), len(self.state['mention_queue'])))

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t retrieve mentions', e)

except IncompleteRead as e:
self.log('Incomplete read error -- skipping mentions update')

def _check_timeline(self):
"""
Checks timeline and loads most recent tweets into recent timeline
"""
if self._ignore_method(self.on_timeline):
logging.debug('Ignoring timeline')
return

try:
current_timeline = self.api.home_timeline(count=200, since_id=self.state['last_timeline_id'])

# remove my tweets
current_timeline = [t for t in current_timeline if t.author.screen_name.lower() != self.screen_name.lower()]

# remove all tweets mentioning me
current_timeline = [t for t in current_timeline if not re.search('@'+self.screen_name, t.text, flags=re.IGNORECASE)]

if self.config['ignore_timeline_mentions']:
# remove all tweets with mentions (heuristically)
current_timeline = [t for t in current_timeline if '@' not in t.text]

if len(current_timeline) != 0:
self.state['last_timeline_id'] = current_timeline[0].id

self.state['last_timeline_time'] = time.time()

self.state['recent_timeline'] = list(reversed(current_timeline))

logging.info('Timeline updated ({} retrieved)'.format(len(current_timeline)))

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t retrieve timeline', e)

except IncompleteRead as e:
self.log('Incomplete read error -- skipping timeline update')

def _check_followers(self):
"""
Checks followers.
"""
logging.info("Checking for new followers...")

try:
self.state['new_followers'] = [f_id for f_id in self.api.followers_ids(self.id) if f_id not in self.state['followers']]

self.config['last_follow_check'] = time.time()

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t update followers', e)

except IncompleteRead as e:
self.log('Incomplete read error -- skipping followers update')

def _handle_followers(self):
"""
Handles new followers.
"""
for f_id in self.state['new_followers']:
self.on_follow(f_id)

def register_custom_handler(self, action, interval):
"""
Register a custom action to run at some interval.
"""
handler = {}

handler['action'] = action
handler['interval'] = interval
handler['last_run'] = 0

self.custom_handlers.append(handler)

def run(self):
"""
Runs the bot! This probably shouldn't be in a "while True" lol.
"""
while True:

# check followers every 15 minutes
#if self.autofollow and (time.time() - self.last_follow_check) > (15 * 60):
if self.state['last_follow_check'] > (15 * 60):
self._check_followers()
self._handle_followers()

# check mentions every minute-ish
#if self.reply_to_mentions and (time.time() - self.last_mention_time) > 60:
if (time.time() - self.state['last_mention_time']) > 60:
self._check_mentions()
self._handle_mentions()

# tweet to timeline
#if self.reply_to_timeline and (time.time() - self.last_mention_time) > 60:
if (time.time() - self.state['last_timeline_time']) > 60:
self._check_timeline()
self._handle_timeline()

# tweet to timeline on the correct interval
if (time.time() - self.state['last_tweet_time']) > self.config['tweet_interval']:
self.on_scheduled_tweet()

# TODO: maybe this should only run if the above is successful...
if self.config['tweet_interval_range'] is not None:
self.config['tweet_interval'] = random.randint(*self.config['tweet_interval_range'])

self.log("Next tweet in {} seconds".format(self.config['tweet_interval']))
self.state['last_tweet_time'] = time.time()

# run custom action
for handler in self.custom_handlers:
if (time.time() - handler['last_run']) > handler['interval']:
handler['action']()
handler['last_run'] = time.time()

# save current state
self._save_state()

logging.info("Sleeping for a bit...")
time.sleep(30)

class FileStorage(object):
"""
Default storage adapter.

Adapters must implement two methods: read(name) and write(name).
"""

def read(self, name):
"""
Return an IO-like object that will produce binary data when read from.
If nothing is stored under the given name, raise IOError.
"""
filename = self._get_filename(name)
if os.path.exists(filename):
logging.debug("Reading from {}".format(filename))
else:
logging.debug("{} doesn't exist".format(filename))
return open(filename, 'rb')

def write(self, name):
"""
Return an IO-like object that will store binary data written to it.
"""
filename = self._get_filename(name)
if os.path.exists(filename):
logging.debug("Overwriting {}".format(filename))
else:
logging.debug("Creating {}".format(filename))
return open(filename, 'wb')

def _get_filename(self, name):
return '{}_state.pkl'.format(name)

</source>

GMU:Bots 'n' Plots/Sebastian Stang

2015-06-17T16:05:59Z

SebastianStang:

( ) ( ) 
(>•.•<) 
<nowiki> (") (")</nowiki>

== @_pil_bot_ ==

https://twitter.com/_pil_bot_

[[File:Pilbot1.png|480px|thumb|left]]

[[File:Pilbot2.png|480px|thumb|left]]

<hr style="clear:both" />

=== pilbot.py ===

<source lang="python">
# -*- coding: utf-8 -*- #

from twitterbot import TwitterBot
import keys

from PIL import Image
from sys import argv
from random import random

from pileval import PILEval

class PilBot(TwitterBot):

def __init__(self):
TwitterBot.__init__(self)
self.pillermann = PILEval()

def bot_init(self):
""" Initialize and configure the bot """

############################
# REQUIRED: LOGIN DETAILS! #
############################
self.config['api_key'] = keys.consumer_key
self.config['api_secret'] = keys.consumer_secret
self.config['access_key'] = keys.access_token
self.config['access_secret'] = keys.access_token_secret

######################################
# SEMI-OPTIONAL: OTHER CONFIG STUFF! #
######################################

# how often to tweet, in seconds
self.config['tweet_interval'] = 1 * 5 # default: 1 minutes

# use this to define a (min, max) random range of how often to tweet
# e.g., self.config['tweet_interval_range'] = (5*60, 10*60) # tweets every 5-10 minutes
self.config['tweet_interval_range'] = None

# only reply to tweets that specifically mention the bot
self.config['reply_direct_mention_only'] = True

# only include bot followers (and original tweeter) in @-replies
self.config['reply_followers_only'] = False

# fav any tweets that mention this bot?
self.config['autofav_mentions'] = False

# fav any tweets containing these keywords?
self.config['autofav_keywords'] = []

# follow back all followers?
self.config['autofollow'] = False

def on_scheduled_tweet(self):
""" Make a public tweet to the bot's own timeline. """
# We might take senteces from somewhere and tweet them on a regular basis ...
pass # don't do anything here ...

def on_mention(self, tweet, prefix):
""" Actions to take when a mention is received. """
text = tweet.text.split()[1]
self.action(text)

def on_timeline(self, tweet, prefix):
""" Actions to take on a timeline tweet. """
pass

def action(self, code):
result = self.pillermann.eval(code)

if result: # post the image
self.post_tweet(code, media="img.png", file=self.pillermann.get_file())
else: # post the error
self.post_tweet(self.pillermann.last_error)

if __name__ == '__main__':

bot = PilBot()

if len(argv) == 1:
bot.run()
else:
tweet_text = "text((300, 400), 'botsNplots', fill='#ff0')"
bot.action(tweet_text)

</source>

=== pileval.py ===

<source lang="python">
from PIL import Image, ImageDraw

from os import path
from io import BytesIO

class PILEval():

def __init__(self, filename='test.png'):
self.filename = filename
try:
self.image = Image.open(filename)
except FileNotFoundError as e:
self.image = Image.new("RGBA", (640, 480), 'white')
self.last_error = ''

def __repr__(self):
return "<PILEval: %s>" % self.filename

def eval(self, code):
draw = ImageDraw.Draw(self.image, "RGBA")
code = "draw.%s" % code

try:
code_obj = compile(code, '<string>', 'exec')
exec(code_obj)
except Exception as e:
self.last_error = str(e)
return False

self.image.save(self.filename)

return True

def get_file(self):
img = Image.open(self.filename)
file = BytesIO()
img.save(file, format='PNG')
return file

if __name__ == '__main__':
# some q'n'dirty tests
print("main")
pillermann = PILEval()

# will work
# result = pillermann.eval("rectangle([20, 10, 120, 200], fill='#f00')")
# if result:
# print('good')

# will also work
# result = pillermann.eval("ellipse([200, 50, 500, 500], fill='#def')")
# result = pillermann.eval("point((123, 234), fill='#345')")
# result = pillermann.eval("line([23, 34, 345, 456], fill='#eca', width=10)")
# result = pillermann.eval("arc([500, 10, 600, 440], 10, 95, fill='#3f9')")
# result = pillermann.eval("text((22, 202), '_pil_bot_!', fill='#a4f')")

result = pillermann.eval("text((100, 100), text=code, fill='#000')")
if result:
print("ok")
else:
print(pillermann.last_error)
# will yield a compiler error
# result = pillermann.eval("rectangle([20, 10, 120, 200], fill='#f00'")
# if not result:
# print("error result: %s" % pillermann.last_error)

# f = pillermann.get_file()
# print(f)

</source>

=== twitterbot/bot.py ===

adapts thricedotted's (http://lczzz.me) twitterbot for python 3

<source lang="python">

import os
import codecs
import json
import logging
import tweepy
import time
import re
import random
import pickle

def ignore(method):
"""
Use the @ignore decorator on TwitterBot methods you wish to leave
unimplemented, such as on_timeline and on_mention.
"""
method.not_implemented = True
return method

class TwitterBot:

def __init__(self):
self.config = {}

self.custom_handlers = []

self.config['reply_direct_mention_only'] = False
self.config['reply_followers_only'] = True

self.config['autofav_mentions'] = False
self.config['autofav_keywords'] = []

self.config['autofollow'] = False

self.config['tweet_interval'] = 30 * 60
self.config['tweet_interval_range'] = None

self.config['reply_interval'] = 10
self.config['reply_interval_range'] = None

self.config['ignore_timeline_mentions'] = True

self.config['logging_level'] = logging.DEBUG
self.config['storage'] = FileStorage()

self.state = {}

# call the custom initialization
self.bot_init()

auth = tweepy.OAuthHandler(self.config['api_key'], self.config['api_secret'])
auth.set_access_token(self.config['access_key'], self.config['access_secret'])
self.api = tweepy.API(auth)

self.id = self.api.me().id
self.screen_name = self.api.me().screen_name

logging.basicConfig(format='%(asctime)s | %(levelname)s: %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p',
filename=self.screen_name + '.log',
level=self.config['logging_level'])

logging.info('Initializing bot...')

try:
with self.config['storage'].read(self.screen_name) as f:
self.state = pickle.load(f)

except IOError:
self.state['last_timeline_id'] = 1
self.state['last_mention_id'] = 1

self.state['last_timeline_time'] = 0
self.state['last_mention_time'] = 0

self.state['last_tweet_id'] = 1
self.state['last_tweet_time'] = 1

self.state['last_reply_id'] = 0
self.state['last_reply_time'] = 0

self.state['recent_timeline'] = []
self.state['mention_queue'] = []

self.state['friends'] = self.api.friends_ids(self.id)
self.state['followers'] = self.api.followers_ids(self.id)
self.state['new_followers'] = []
self.state['last_follow_check'] = 0

logging.info('Bot initialized!')

def bot_init(self):
"""
Initialize custom state values for your bot.
"""
raise NotImplementedError("You MUST have bot_init() implemented in your bot! What have you DONE!")

def log(self, message, level=logging.INFO):
if level == logging.ERROR:
logging.error(message)
else:
logging.info(message)

def _log_tweepy_error(self, message, e):
try:
e_message = e.message[0]['message']
code = e.message[0]['code']
self.log("{}: {} ({})".format(message, e_message, code), level=logging.ERROR)
except:
self.log(message, e)

def _tweet_url(self, tweet):
return "http://twitter.com/" + tweet.author.screen_name + "/status/" + str(tweet.id)

def _save_state(self):
with self.config['storage'].write(self.screen_name) as f:
pickle.dump(self.state, f)
self.log('Bot state saved')

def on_scheduled_tweet(self):
"""
Post a general tweet to own timeline.
"""
#self.post_tweet(text)
raise NotImplementedError("You need to implement this to tweet to timeline (or pass if you don't want to)!")

def on_mention(self, tweet, prefix):
"""
Perform some action upon receiving a mention.
"""
#self.post_tweet(text)
raise NotImplementedError("You need to implement this to reply to/fav mentions (or pass if you don't want to)!")

def on_timeline(self, tweet, prefix):
"""
Perform some action on a tweet on the timeline.
"""
#self.post_tweet(text)
raise NotImplementedError("You need to implement this to reply to/fav timeline tweets (or pass if you don't want to)!")

def on_follow(self, f_id):
"""
Perform some action when followed.
"""
if self.config['autofollow']:
try:
self.api.create_friendship(f_id, follow=True)
self.state['friends'].append(f_id)
logging.info('Followed user id {}'.format(f_id))
except tweepy.TweepError as e:
self._log_tweepy_error('Unable to follow user', e)

time.sleep(3)

self.state['followers'].append(f_id)

def post_tweet(self, text, reply_to=None, media=None, file=None):
"""
Post a tweet containing the text.
If you provide a filename the file will be added to the tweet.
You can also provide the filedata, for example when using dynamically created images.
"""

kwargs = { "status": text }
args = []

if media is not None:
cmd = self.api.update_with_media
args.insert(0, media)

if file is not None:
kwargs["file"] = file
else:
cmd = self.api.update_status

try:
self.log('Tweeting "{}"'.format(text))
if reply_to:
self.log("-- Responding to status {}".format(self._tweet_url(reply_to)))
kwargs['in_reply_to_status_id'] = reply_to.id
else:
self.log("-- Posting to own timeline")

tweet = cmd(*args, **kwargs)
self.log('Status posted at {}'.format(self._tweet_url(tweet)))
return True

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t post status', e)
return False

def favorite_tweet(self, tweet):
try:
logging.info('Faving ' + self._tweet_url(tweet))
self.api.create_favorite(tweet.id)

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t fav status', e)

def _ignore_method(self, method):
return hasattr(method, 'not_implemented') and method.not_implemented

def _handle_timeline(self):
"""
Reads the latest tweets in the bots timeline and perform some action.
self.recent_timeline
"""
for tweet in self.state['recent_timeline']:
prefix = self.get_mention_prefix(tweet)
self.on_timeline(tweet, prefix)

words = tweet.text.lower().split()
if any(w in words for w in self.config['autofav_keywords']):
self.favorite_tweet(tweet)

#time.sleep(self.config['reply_interval'])

def _handle_mentions(self):
"""
Performs some action on the mentions in self.mention_queue
"""
# TODO: only handle a certain number of mentions at a time?
for mention in iter(self.state['mention_queue']):
prefix = self.get_mention_prefix(mention)
self.on_mention(mention, prefix)
self.state['mention_queue'].remove(mention)

if self.config['autofav_mentions']:
self.favorite_tweet(mention)

#time.sleep(self.config['reply_interval'])

def get_mention_prefix(self, tweet):
"""
Returns a string of users to @-mention when responding to a tweet.
"""
mention_back = ['@' + tweet.author.screen_name]
mention_back += [s for s in re.split('[^@\w]', tweet.text) if len(s) > 2 and s[0] == '@' and s[1:] != self.screen_name]

if self.config['reply_followers_only']:
mention_back = [s for s in mention_back if s[1:] in self.state['followers'] or s == '@' + tweet.author.screen_name]

return ' '.join(mention_back)

def _check_mentions(self):
"""
Checks mentions and loads most recent tweets into the mention queue
"""
if self._ignore_method(self.on_mention):
logging.debug('Ignoring mentions')
return

try:
current_mentions = self.api.mentions_timeline(since_id=self.state['last_mention_id'], count=100)

# direct mentions only?
if self.config['reply_direct_mention_only']:
current_mentions = [t for t in current_mentions if re.split('[^@\w]', t.text)[0] == '@' + self.screen_name]

if len(current_mentions) != 0:
self.state['last_mention_id'] = current_mentions[0].id

self.state['last_mention_time'] = time.time()

self.state['mention_queue'] += reversed(current_mentions)

logging.info('Mentions updated ({} retrieved, {} total in queue)'.format(len(current_mentions), len(self.state['mention_queue'])))

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t retrieve mentions', e)

except IncompleteRead as e:
self.log('Incomplete read error -- skipping mentions update')

def _check_timeline(self):
"""
Checks timeline and loads most recent tweets into recent timeline
"""
if self._ignore_method(self.on_timeline):
logging.debug('Ignoring timeline')
return

try:
current_timeline = self.api.home_timeline(count=200, since_id=self.state['last_timeline_id'])

# remove my tweets
current_timeline = [t for t in current_timeline if t.author.screen_name.lower() != self.screen_name.lower()]

# remove all tweets mentioning me
current_timeline = [t for t in current_timeline if not re.search('@'+self.screen_name, t.text, flags=re.IGNORECASE)]

if self.config['ignore_timeline_mentions']:
# remove all tweets with mentions (heuristically)
current_timeline = [t for t in current_timeline if '@' not in t.text]

if len(current_timeline) != 0:
self.state['last_timeline_id'] = current_timeline[0].id

self.state['last_timeline_time'] = time.time()

self.state['recent_timeline'] = list(reversed(current_timeline))

logging.info('Timeline updated ({} retrieved)'.format(len(current_timeline)))

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t retrieve timeline', e)

except IncompleteRead as e:
self.log('Incomplete read error -- skipping timeline update')

def _check_followers(self):
"""
Checks followers.
"""
logging.info("Checking for new followers...")

try:
self.state['new_followers'] = [f_id for f_id in self.api.followers_ids(self.id) if f_id not in self.state['followers']]

self.config['last_follow_check'] = time.time()

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t update followers', e)

except IncompleteRead as e:
self.log('Incomplete read error -- skipping followers update')

def _handle_followers(self):
"""
Handles new followers.
"""
for f_id in self.state['new_followers']:
self.on_follow(f_id)

def register_custom_handler(self, action, interval):
"""
Register a custom action to run at some interval.
"""
handler = {}

handler['action'] = action
handler['interval'] = interval
handler['last_run'] = 0

self.custom_handlers.append(handler)

def run(self):
"""
Runs the bot! This probably shouldn't be in a "while True" lol.
"""
while True:

# check followers every 15 minutes
#if self.autofollow and (time.time() - self.last_follow_check) > (15 * 60):
if self.state['last_follow_check'] > (15 * 60):
self._check_followers()
self._handle_followers()

# check mentions every minute-ish
#if self.reply_to_mentions and (time.time() - self.last_mention_time) > 60:
if (time.time() - self.state['last_mention_time']) > 60:
self._check_mentions()
self._handle_mentions()

# tweet to timeline
#if self.reply_to_timeline and (time.time() - self.last_mention_time) > 60:
if (time.time() - self.state['last_timeline_time']) > 60:
self._check_timeline()
self._handle_timeline()

# tweet to timeline on the correct interval
if (time.time() - self.state['last_tweet_time']) > self.config['tweet_interval']:
self.on_scheduled_tweet()

# TODO: maybe this should only run if the above is successful...
if self.config['tweet_interval_range'] is not None:
self.config['tweet_interval'] = random.randint(*self.config['tweet_interval_range'])

self.log("Next tweet in {} seconds".format(self.config['tweet_interval']))
self.state['last_tweet_time'] = time.time()

# run custom action
for handler in self.custom_handlers:
if (time.time() - handler['last_run']) > handler['interval']:
handler['action']()
handler['last_run'] = time.time()

# save current state
self._save_state()

logging.info("Sleeping for a bit...")
time.sleep(30)

class FileStorage(object):
"""
Default storage adapter.

Adapters must implement two methods: read(name) and write(name).
"""

def read(self, name):
"""
Return an IO-like object that will produce binary data when read from.
If nothing is stored under the given name, raise IOError.
"""
filename = self._get_filename(name)
if os.path.exists(filename):
logging.debug("Reading from {}".format(filename))
else:
logging.debug("{} doesn't exist".format(filename))
return open(filename, 'rb')

def write(self, name):
"""
Return an IO-like object that will store binary data written to it.
"""
filename = self._get_filename(name)
if os.path.exists(filename):
logging.debug("Overwriting {}".format(filename))
else:
logging.debug("Creating {}".format(filename))
return open(filename, 'wb')

def _get_filename(self, name):
return '{}_state.pkl'.format(name)

</source>

GMU:Bots 'n' Plots/Sebastian Stang

2015-06-17T16:04:39Z

SebastianStang:

( ) ( ) 
(>•.•<) 
<nowiki> (") (")</nowiki>

== @_pil_bot_ ==

[[File:Pilbot1.png|480px|thumb|left]]

[[File:Pilbot2.png|480px|thumb|left]]

<hr style="clear:both" />

=== pilbot.py ===

<source lang="python">
# -*- coding: utf-8 -*- #

from twitterbot import TwitterBot
import keys

from PIL import Image
from sys import argv
from random import random

from pileval import PILEval

class PilBot(TwitterBot):

def __init__(self):
TwitterBot.__init__(self)
self.pillermann = PILEval()

def bot_init(self):
""" Initialize and configure the bot """

############################
# REQUIRED: LOGIN DETAILS! #
############################
self.config['api_key'] = keys.consumer_key
self.config['api_secret'] = keys.consumer_secret
self.config['access_key'] = keys.access_token
self.config['access_secret'] = keys.access_token_secret

######################################
# SEMI-OPTIONAL: OTHER CONFIG STUFF! #
######################################

# how often to tweet, in seconds
self.config['tweet_interval'] = 1 * 5 # default: 1 minutes

# use this to define a (min, max) random range of how often to tweet
# e.g., self.config['tweet_interval_range'] = (5*60, 10*60) # tweets every 5-10 minutes
self.config['tweet_interval_range'] = None

# only reply to tweets that specifically mention the bot
self.config['reply_direct_mention_only'] = True

# only include bot followers (and original tweeter) in @-replies
self.config['reply_followers_only'] = False

# fav any tweets that mention this bot?
self.config['autofav_mentions'] = False

# fav any tweets containing these keywords?
self.config['autofav_keywords'] = []

# follow back all followers?
self.config['autofollow'] = False

def on_scheduled_tweet(self):
""" Make a public tweet to the bot's own timeline. """
# We might take senteces from somewhere and tweet them on a regular basis ...
pass # don't do anything here ...

def on_mention(self, tweet, prefix):
""" Actions to take when a mention is received. """
text = tweet.text.split()[1]
self.action(text)

def on_timeline(self, tweet, prefix):
""" Actions to take on a timeline tweet. """
pass

def action(self, code):
result = self.pillermann.eval(code)

if result: # post the image
self.post_tweet(code, media="img.png", file=self.pillermann.get_file())
else: # post the error
self.post_tweet(self.pillermann.last_error)

if __name__ == '__main__':

bot = PilBot()

if len(argv) == 1:
bot.run()
else:
tweet_text = "text((300, 400), 'botsNplots', fill='#ff0')"
bot.action(tweet_text)

</source>

=== pileval.py ===

<source lang="python">
from PIL import Image, ImageDraw

from os import path
from io import BytesIO

class PILEval():

def __init__(self, filename='test.png'):
self.filename = filename
try:
self.image = Image.open(filename)
except FileNotFoundError as e:
self.image = Image.new("RGBA", (640, 480), 'white')
self.last_error = ''

def __repr__(self):
return "<PILEval: %s>" % self.filename

def eval(self, code):
draw = ImageDraw.Draw(self.image, "RGBA")
code = "draw.%s" % code

try:
code_obj = compile(code, '<string>', 'exec')
exec(code_obj)
except Exception as e:
self.last_error = str(e)
return False

self.image.save(self.filename)

return True

def get_file(self):
img = Image.open(self.filename)
file = BytesIO()
img.save(file, format='PNG')
return file

if __name__ == '__main__':
# some q'n'dirty tests
print("main")
pillermann = PILEval()

# will work
# result = pillermann.eval("rectangle([20, 10, 120, 200], fill='#f00')")
# if result:
# print('good')

# will also work
# result = pillermann.eval("ellipse([200, 50, 500, 500], fill='#def')")
# result = pillermann.eval("point((123, 234), fill='#345')")
# result = pillermann.eval("line([23, 34, 345, 456], fill='#eca', width=10)")
# result = pillermann.eval("arc([500, 10, 600, 440], 10, 95, fill='#3f9')")
# result = pillermann.eval("text((22, 202), '_pil_bot_!', fill='#a4f')")

result = pillermann.eval("text((100, 100), text=code, fill='#000')")
if result:
print("ok")
else:
print(pillermann.last_error)
# will yield a compiler error
# result = pillermann.eval("rectangle([20, 10, 120, 200], fill='#f00'")
# if not result:
# print("error result: %s" % pillermann.last_error)

# f = pillermann.get_file()
# print(f)

</source>

=== twitterbot/bot.py ===

adapts thricedotted's (http://lczzz.me) twitterbot for python 3

<source lang="python">

import os
import codecs
import json
import logging
import tweepy
import time
import re
import random
import pickle

def ignore(method):
"""
Use the @ignore decorator on TwitterBot methods you wish to leave
unimplemented, such as on_timeline and on_mention.
"""
method.not_implemented = True
return method

class TwitterBot:

def __init__(self):
self.config = {}

self.custom_handlers = []

self.config['reply_direct_mention_only'] = False
self.config['reply_followers_only'] = True

self.config['autofav_mentions'] = False
self.config['autofav_keywords'] = []

self.config['autofollow'] = False

self.config['tweet_interval'] = 30 * 60
self.config['tweet_interval_range'] = None

self.config['reply_interval'] = 10
self.config['reply_interval_range'] = None

self.config['ignore_timeline_mentions'] = True

self.config['logging_level'] = logging.DEBUG
self.config['storage'] = FileStorage()

self.state = {}

# call the custom initialization
self.bot_init()

auth = tweepy.OAuthHandler(self.config['api_key'], self.config['api_secret'])
auth.set_access_token(self.config['access_key'], self.config['access_secret'])
self.api = tweepy.API(auth)

self.id = self.api.me().id
self.screen_name = self.api.me().screen_name

logging.basicConfig(format='%(asctime)s | %(levelname)s: %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p',
filename=self.screen_name + '.log',
level=self.config['logging_level'])

logging.info('Initializing bot...')

try:
with self.config['storage'].read(self.screen_name) as f:
self.state = pickle.load(f)

except IOError:
self.state['last_timeline_id'] = 1
self.state['last_mention_id'] = 1

self.state['last_timeline_time'] = 0
self.state['last_mention_time'] = 0

self.state['last_tweet_id'] = 1
self.state['last_tweet_time'] = 1

self.state['last_reply_id'] = 0
self.state['last_reply_time'] = 0

self.state['recent_timeline'] = []
self.state['mention_queue'] = []

self.state['friends'] = self.api.friends_ids(self.id)
self.state['followers'] = self.api.followers_ids(self.id)
self.state['new_followers'] = []
self.state['last_follow_check'] = 0

logging.info('Bot initialized!')

def bot_init(self):
"""
Initialize custom state values for your bot.
"""
raise NotImplementedError("You MUST have bot_init() implemented in your bot! What have you DONE!")

def log(self, message, level=logging.INFO):
if level == logging.ERROR:
logging.error(message)
else:
logging.info(message)

def _log_tweepy_error(self, message, e):
try:
e_message = e.message[0]['message']
code = e.message[0]['code']
self.log("{}: {} ({})".format(message, e_message, code), level=logging.ERROR)
except:
self.log(message, e)

def _tweet_url(self, tweet):
return "http://twitter.com/" + tweet.author.screen_name + "/status/" + str(tweet.id)

def _save_state(self):
with self.config['storage'].write(self.screen_name) as f:
pickle.dump(self.state, f)
self.log('Bot state saved')

def on_scheduled_tweet(self):
"""
Post a general tweet to own timeline.
"""
#self.post_tweet(text)
raise NotImplementedError("You need to implement this to tweet to timeline (or pass if you don't want to)!")

def on_mention(self, tweet, prefix):
"""
Perform some action upon receiving a mention.
"""
#self.post_tweet(text)
raise NotImplementedError("You need to implement this to reply to/fav mentions (or pass if you don't want to)!")

def on_timeline(self, tweet, prefix):
"""
Perform some action on a tweet on the timeline.
"""
#self.post_tweet(text)
raise NotImplementedError("You need to implement this to reply to/fav timeline tweets (or pass if you don't want to)!")

def on_follow(self, f_id):
"""
Perform some action when followed.
"""
if self.config['autofollow']:
try:
self.api.create_friendship(f_id, follow=True)
self.state['friends'].append(f_id)
logging.info('Followed user id {}'.format(f_id))
except tweepy.TweepError as e:
self._log_tweepy_error('Unable to follow user', e)

time.sleep(3)

self.state['followers'].append(f_id)

def post_tweet(self, text, reply_to=None, media=None, file=None):
"""
Post a tweet containing the text.
If you provide a filename the file will be added to the tweet.
You can also provide the filedata, for example when using dynamically created images.
"""

kwargs = { "status": text }
args = []

if media is not None:
cmd = self.api.update_with_media
args.insert(0, media)

if file is not None:
kwargs["file"] = file
else:
cmd = self.api.update_status

try:
self.log('Tweeting "{}"'.format(text))
if reply_to:
self.log("-- Responding to status {}".format(self._tweet_url(reply_to)))
kwargs['in_reply_to_status_id'] = reply_to.id
else:
self.log("-- Posting to own timeline")

tweet = cmd(*args, **kwargs)
self.log('Status posted at {}'.format(self._tweet_url(tweet)))
return True

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t post status', e)
return False

def favorite_tweet(self, tweet):
try:
logging.info('Faving ' + self._tweet_url(tweet))
self.api.create_favorite(tweet.id)

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t fav status', e)

def _ignore_method(self, method):
return hasattr(method, 'not_implemented') and method.not_implemented

def _handle_timeline(self):
"""
Reads the latest tweets in the bots timeline and perform some action.
self.recent_timeline
"""
for tweet in self.state['recent_timeline']:
prefix = self.get_mention_prefix(tweet)
self.on_timeline(tweet, prefix)

words = tweet.text.lower().split()
if any(w in words for w in self.config['autofav_keywords']):
self.favorite_tweet(tweet)

#time.sleep(self.config['reply_interval'])

def _handle_mentions(self):
"""
Performs some action on the mentions in self.mention_queue
"""
# TODO: only handle a certain number of mentions at a time?
for mention in iter(self.state['mention_queue']):
prefix = self.get_mention_prefix(mention)
self.on_mention(mention, prefix)
self.state['mention_queue'].remove(mention)

if self.config['autofav_mentions']:
self.favorite_tweet(mention)

#time.sleep(self.config['reply_interval'])

def get_mention_prefix(self, tweet):
"""
Returns a string of users to @-mention when responding to a tweet.
"""
mention_back = ['@' + tweet.author.screen_name]
mention_back += [s for s in re.split('[^@\w]', tweet.text) if len(s) > 2 and s[0] == '@' and s[1:] != self.screen_name]

if self.config['reply_followers_only']:
mention_back = [s for s in mention_back if s[1:] in self.state['followers'] or s == '@' + tweet.author.screen_name]

return ' '.join(mention_back)

def _check_mentions(self):
"""
Checks mentions and loads most recent tweets into the mention queue
"""
if self._ignore_method(self.on_mention):
logging.debug('Ignoring mentions')
return

try:
current_mentions = self.api.mentions_timeline(since_id=self.state['last_mention_id'], count=100)

# direct mentions only?
if self.config['reply_direct_mention_only']:
current_mentions = [t for t in current_mentions if re.split('[^@\w]', t.text)[0] == '@' + self.screen_name]

if len(current_mentions) != 0:
self.state['last_mention_id'] = current_mentions[0].id

self.state['last_mention_time'] = time.time()

self.state['mention_queue'] += reversed(current_mentions)

logging.info('Mentions updated ({} retrieved, {} total in queue)'.format(len(current_mentions), len(self.state['mention_queue'])))

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t retrieve mentions', e)

except IncompleteRead as e:
self.log('Incomplete read error -- skipping mentions update')

def _check_timeline(self):
"""
Checks timeline and loads most recent tweets into recent timeline
"""
if self._ignore_method(self.on_timeline):
logging.debug('Ignoring timeline')
return

try:
current_timeline = self.api.home_timeline(count=200, since_id=self.state['last_timeline_id'])

# remove my tweets
current_timeline = [t for t in current_timeline if t.author.screen_name.lower() != self.screen_name.lower()]

# remove all tweets mentioning me
current_timeline = [t for t in current_timeline if not re.search('@'+self.screen_name, t.text, flags=re.IGNORECASE)]

if self.config['ignore_timeline_mentions']:
# remove all tweets with mentions (heuristically)
current_timeline = [t for t in current_timeline if '@' not in t.text]

if len(current_timeline) != 0:
self.state['last_timeline_id'] = current_timeline[0].id

self.state['last_timeline_time'] = time.time()

self.state['recent_timeline'] = list(reversed(current_timeline))

logging.info('Timeline updated ({} retrieved)'.format(len(current_timeline)))

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t retrieve timeline', e)

except IncompleteRead as e:
self.log('Incomplete read error -- skipping timeline update')

def _check_followers(self):
"""
Checks followers.
"""
logging.info("Checking for new followers...")

try:
self.state['new_followers'] = [f_id for f_id in self.api.followers_ids(self.id) if f_id not in self.state['followers']]

self.config['last_follow_check'] = time.time()

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t update followers', e)

except IncompleteRead as e:
self.log('Incomplete read error -- skipping followers update')

def _handle_followers(self):
"""
Handles new followers.
"""
for f_id in self.state['new_followers']:
self.on_follow(f_id)

def register_custom_handler(self, action, interval):
"""
Register a custom action to run at some interval.
"""
handler = {}

handler['action'] = action
handler['interval'] = interval
handler['last_run'] = 0

self.custom_handlers.append(handler)

def run(self):
"""
Runs the bot! This probably shouldn't be in a "while True" lol.
"""
while True:

# check followers every 15 minutes
#if self.autofollow and (time.time() - self.last_follow_check) > (15 * 60):
if self.state['last_follow_check'] > (15 * 60):
self._check_followers()
self._handle_followers()

# check mentions every minute-ish
#if self.reply_to_mentions and (time.time() - self.last_mention_time) > 60:
if (time.time() - self.state['last_mention_time']) > 60:
self._check_mentions()
self._handle_mentions()

# tweet to timeline
#if self.reply_to_timeline and (time.time() - self.last_mention_time) > 60:
if (time.time() - self.state['last_timeline_time']) > 60:
self._check_timeline()
self._handle_timeline()

# tweet to timeline on the correct interval
if (time.time() - self.state['last_tweet_time']) > self.config['tweet_interval']:
self.on_scheduled_tweet()

# TODO: maybe this should only run if the above is successful...
if self.config['tweet_interval_range'] is not None:
self.config['tweet_interval'] = random.randint(*self.config['tweet_interval_range'])

self.log("Next tweet in {} seconds".format(self.config['tweet_interval']))
self.state['last_tweet_time'] = time.time()

# run custom action
for handler in self.custom_handlers:
if (time.time() - handler['last_run']) > handler['interval']:
handler['action']()
handler['last_run'] = time.time()

# save current state
self._save_state()

logging.info("Sleeping for a bit...")
time.sleep(30)

class FileStorage(object):
"""
Default storage adapter.

Adapters must implement two methods: read(name) and write(name).
"""

def read(self, name):
"""
Return an IO-like object that will produce binary data when read from.
If nothing is stored under the given name, raise IOError.
"""
filename = self._get_filename(name)
if os.path.exists(filename):
logging.debug("Reading from {}".format(filename))
else:
logging.debug("{} doesn't exist".format(filename))
return open(filename, 'rb')

def write(self, name):
"""
Return an IO-like object that will store binary data written to it.
"""
filename = self._get_filename(name)
if os.path.exists(filename):
logging.debug("Overwriting {}".format(filename))
else:
logging.debug("Creating {}".format(filename))
return open(filename, 'wb')

def _get_filename(self, name):
return '{}_state.pkl'.format(name)

</source>

File:Pilbot2.png

2015-06-17T16:01:08Z

SebastianStang:

== Summary ==

== Copyright status: ==

== Source: ==

File:Pilbot1.png

2015-06-17T16:00:47Z

SebastianStang:

== Summary ==

== Copyright status: ==

== Source: ==

GMU:Bots 'n' Plots/Sebastian Stang

2015-06-17T15:58:01Z

SebastianStang:

( ) ( ) 
(>•.•<) 
<nowiki> (") (")</nowiki>

== @_pil_bot_ ==

[[File:pil__bot.png|500px|thumb|left]]

=== pilbot.py ===

<source lang="python">
# -*- coding: utf-8 -*- #

from twitterbot import TwitterBot
import keys

from PIL import Image
from sys import argv
from random import random

from pileval import PILEval

class PilBot(TwitterBot):

def __init__(self):
TwitterBot.__init__(self)
self.pillermann = PILEval()

def bot_init(self):
""" Initialize and configure the bot """

############################
# REQUIRED: LOGIN DETAILS! #
############################
self.config['api_key'] = keys.consumer_key
self.config['api_secret'] = keys.consumer_secret
self.config['access_key'] = keys.access_token
self.config['access_secret'] = keys.access_token_secret

######################################
# SEMI-OPTIONAL: OTHER CONFIG STUFF! #
######################################

# how often to tweet, in seconds
self.config['tweet_interval'] = 1 * 5 # default: 1 minutes

# use this to define a (min, max) random range of how often to tweet
# e.g., self.config['tweet_interval_range'] = (5*60, 10*60) # tweets every 5-10 minutes
self.config['tweet_interval_range'] = None

# only reply to tweets that specifically mention the bot
self.config['reply_direct_mention_only'] = True

# only include bot followers (and original tweeter) in @-replies
self.config['reply_followers_only'] = False

# fav any tweets that mention this bot?
self.config['autofav_mentions'] = False

# fav any tweets containing these keywords?
self.config['autofav_keywords'] = []

# follow back all followers?
self.config['autofollow'] = False

def on_scheduled_tweet(self):
""" Make a public tweet to the bot's own timeline. """
# We might take senteces from somewhere and tweet them on a regular basis ...
pass # don't do anything here ...

def on_mention(self, tweet, prefix):
""" Actions to take when a mention is received. """
text = tweet.text.split()[1]
self.action(text)

def on_timeline(self, tweet, prefix):
""" Actions to take on a timeline tweet. """
pass

def action(self, code):
result = self.pillermann.eval(code)

if result: # post the image
self.post_tweet(code, media="img.png", file=self.pillermann.get_file())
else: # post the error
self.post_tweet(self.pillermann.last_error)

if __name__ == '__main__':

bot = PilBot()

if len(argv) == 1:
bot.run()
else:
tweet_text = "text((300, 400), 'botsNplots', fill='#ff0')"
bot.action(tweet_text)

</source>

=== pileval.py ===

<source lang="python">
from PIL import Image, ImageDraw

from os import path
from io import BytesIO

class PILEval():

def __init__(self, filename='test.png'):
self.filename = filename
try:
self.image = Image.open(filename)
except FileNotFoundError as e:
self.image = Image.new("RGBA", (640, 480), 'white')
self.last_error = ''

def __repr__(self):
return "<PILEval: %s>" % self.filename

def eval(self, code):
draw = ImageDraw.Draw(self.image, "RGBA")
code = "draw.%s" % code

try:
code_obj = compile(code, '<string>', 'exec')
exec(code_obj)
except Exception as e:
self.last_error = str(e)
return False

self.image.save(self.filename)

return True

def get_file(self):
img = Image.open(self.filename)
file = BytesIO()
img.save(file, format='PNG')
return file

if __name__ == '__main__':
# some q'n'dirty tests
print("main")
pillermann = PILEval()

# will work
# result = pillermann.eval("rectangle([20, 10, 120, 200], fill='#f00')")
# if result:
# print('good')

# will also work
# result = pillermann.eval("ellipse([200, 50, 500, 500], fill='#def')")
# result = pillermann.eval("point((123, 234), fill='#345')")
# result = pillermann.eval("line([23, 34, 345, 456], fill='#eca', width=10)")
# result = pillermann.eval("arc([500, 10, 600, 440], 10, 95, fill='#3f9')")
# result = pillermann.eval("text((22, 202), '_pil_bot_!', fill='#a4f')")

result = pillermann.eval("text((100, 100), text=code, fill='#000')")
if result:
print("ok")
else:
print(pillermann.last_error)
# will yield a compiler error
# result = pillermann.eval("rectangle([20, 10, 120, 200], fill='#f00'")
# if not result:
# print("error result: %s" % pillermann.last_error)

# f = pillermann.get_file()
# print(f)

</source>

=== twitterbot/bot.py ===

adapts thricedotted's (http://lczzz.me) twitterbot for python 3

<source lang="python">

import os
import codecs
import json
import logging
import tweepy
import time
import re
import random
import pickle

def ignore(method):
"""
Use the @ignore decorator on TwitterBot methods you wish to leave
unimplemented, such as on_timeline and on_mention.
"""
method.not_implemented = True
return method

class TwitterBot:

def __init__(self):
self.config = {}

self.custom_handlers = []

self.config['reply_direct_mention_only'] = False
self.config['reply_followers_only'] = True

self.config['autofav_mentions'] = False
self.config['autofav_keywords'] = []

self.config['autofollow'] = False

self.config['tweet_interval'] = 30 * 60
self.config['tweet_interval_range'] = None

self.config['reply_interval'] = 10
self.config['reply_interval_range'] = None

self.config['ignore_timeline_mentions'] = True

self.config['logging_level'] = logging.DEBUG
self.config['storage'] = FileStorage()

self.state = {}

# call the custom initialization
self.bot_init()

auth = tweepy.OAuthHandler(self.config['api_key'], self.config['api_secret'])
auth.set_access_token(self.config['access_key'], self.config['access_secret'])
self.api = tweepy.API(auth)

self.id = self.api.me().id
self.screen_name = self.api.me().screen_name

logging.basicConfig(format='%(asctime)s | %(levelname)s: %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p',
filename=self.screen_name + '.log',
level=self.config['logging_level'])

logging.info('Initializing bot...')

try:
with self.config['storage'].read(self.screen_name) as f:
self.state = pickle.load(f)

except IOError:
self.state['last_timeline_id'] = 1
self.state['last_mention_id'] = 1

self.state['last_timeline_time'] = 0
self.state['last_mention_time'] = 0

self.state['last_tweet_id'] = 1
self.state['last_tweet_time'] = 1

self.state['last_reply_id'] = 0
self.state['last_reply_time'] = 0

self.state['recent_timeline'] = []
self.state['mention_queue'] = []

self.state['friends'] = self.api.friends_ids(self.id)
self.state['followers'] = self.api.followers_ids(self.id)
self.state['new_followers'] = []
self.state['last_follow_check'] = 0

logging.info('Bot initialized!')

def bot_init(self):
"""
Initialize custom state values for your bot.
"""
raise NotImplementedError("You MUST have bot_init() implemented in your bot! What have you DONE!")

def log(self, message, level=logging.INFO):
if level == logging.ERROR:
logging.error(message)
else:
logging.info(message)

def _log_tweepy_error(self, message, e):
try:
e_message = e.message[0]['message']
code = e.message[0]['code']
self.log("{}: {} ({})".format(message, e_message, code), level=logging.ERROR)
except:
self.log(message, e)

def _tweet_url(self, tweet):
return "http://twitter.com/" + tweet.author.screen_name + "/status/" + str(tweet.id)

def _save_state(self):
with self.config['storage'].write(self.screen_name) as f:
pickle.dump(self.state, f)
self.log('Bot state saved')

def on_scheduled_tweet(self):
"""
Post a general tweet to own timeline.
"""
#self.post_tweet(text)
raise NotImplementedError("You need to implement this to tweet to timeline (or pass if you don't want to)!")

def on_mention(self, tweet, prefix):
"""
Perform some action upon receiving a mention.
"""
#self.post_tweet(text)
raise NotImplementedError("You need to implement this to reply to/fav mentions (or pass if you don't want to)!")

def on_timeline(self, tweet, prefix):
"""
Perform some action on a tweet on the timeline.
"""
#self.post_tweet(text)
raise NotImplementedError("You need to implement this to reply to/fav timeline tweets (or pass if you don't want to)!")

def on_follow(self, f_id):
"""
Perform some action when followed.
"""
if self.config['autofollow']:
try:
self.api.create_friendship(f_id, follow=True)
self.state['friends'].append(f_id)
logging.info('Followed user id {}'.format(f_id))
except tweepy.TweepError as e:
self._log_tweepy_error('Unable to follow user', e)

time.sleep(3)

self.state['followers'].append(f_id)

def post_tweet(self, text, reply_to=None, media=None, file=None):
"""
Post a tweet containing the text.
If you provide a filename the file will be added to the tweet.
You can also provide the filedata, for example when using dynamically created images.
"""

kwargs = { "status": text }
args = []

if media is not None:
cmd = self.api.update_with_media
args.insert(0, media)

if file is not None:
kwargs["file"] = file
else:
cmd = self.api.update_status

try:
self.log('Tweeting "{}"'.format(text))
if reply_to:
self.log("-- Responding to status {}".format(self._tweet_url(reply_to)))
kwargs['in_reply_to_status_id'] = reply_to.id
else:
self.log("-- Posting to own timeline")

tweet = cmd(*args, **kwargs)
self.log('Status posted at {}'.format(self._tweet_url(tweet)))
return True

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t post status', e)
return False

def favorite_tweet(self, tweet):
try:
logging.info('Faving ' + self._tweet_url(tweet))
self.api.create_favorite(tweet.id)

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t fav status', e)

def _ignore_method(self, method):
return hasattr(method, 'not_implemented') and method.not_implemented

def _handle_timeline(self):
"""
Reads the latest tweets in the bots timeline and perform some action.
self.recent_timeline
"""
for tweet in self.state['recent_timeline']:
prefix = self.get_mention_prefix(tweet)
self.on_timeline(tweet, prefix)

words = tweet.text.lower().split()
if any(w in words for w in self.config['autofav_keywords']):
self.favorite_tweet(tweet)

#time.sleep(self.config['reply_interval'])

def _handle_mentions(self):
"""
Performs some action on the mentions in self.mention_queue
"""
# TODO: only handle a certain number of mentions at a time?
for mention in iter(self.state['mention_queue']):
prefix = self.get_mention_prefix(mention)
self.on_mention(mention, prefix)
self.state['mention_queue'].remove(mention)

if self.config['autofav_mentions']:
self.favorite_tweet(mention)

#time.sleep(self.config['reply_interval'])

def get_mention_prefix(self, tweet):
"""
Returns a string of users to @-mention when responding to a tweet.
"""
mention_back = ['@' + tweet.author.screen_name]
mention_back += [s for s in re.split('[^@\w]', tweet.text) if len(s) > 2 and s[0] == '@' and s[1:] != self.screen_name]

if self.config['reply_followers_only']:
mention_back = [s for s in mention_back if s[1:] in self.state['followers'] or s == '@' + tweet.author.screen_name]

return ' '.join(mention_back)

def _check_mentions(self):
"""
Checks mentions and loads most recent tweets into the mention queue
"""
if self._ignore_method(self.on_mention):
logging.debug('Ignoring mentions')
return

try:
current_mentions = self.api.mentions_timeline(since_id=self.state['last_mention_id'], count=100)

# direct mentions only?
if self.config['reply_direct_mention_only']:
current_mentions = [t for t in current_mentions if re.split('[^@\w]', t.text)[0] == '@' + self.screen_name]

if len(current_mentions) != 0:
self.state['last_mention_id'] = current_mentions[0].id

self.state['last_mention_time'] = time.time()

self.state['mention_queue'] += reversed(current_mentions)

logging.info('Mentions updated ({} retrieved, {} total in queue)'.format(len(current_mentions), len(self.state['mention_queue'])))

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t retrieve mentions', e)

except IncompleteRead as e:
self.log('Incomplete read error -- skipping mentions update')

def _check_timeline(self):
"""
Checks timeline and loads most recent tweets into recent timeline
"""
if self._ignore_method(self.on_timeline):
logging.debug('Ignoring timeline')
return

try:
current_timeline = self.api.home_timeline(count=200, since_id=self.state['last_timeline_id'])

# remove my tweets
current_timeline = [t for t in current_timeline if t.author.screen_name.lower() != self.screen_name.lower()]

# remove all tweets mentioning me
current_timeline = [t for t in current_timeline if not re.search('@'+self.screen_name, t.text, flags=re.IGNORECASE)]

if self.config['ignore_timeline_mentions']:
# remove all tweets with mentions (heuristically)
current_timeline = [t for t in current_timeline if '@' not in t.text]

if len(current_timeline) != 0:
self.state['last_timeline_id'] = current_timeline[0].id

self.state['last_timeline_time'] = time.time()

self.state['recent_timeline'] = list(reversed(current_timeline))

logging.info('Timeline updated ({} retrieved)'.format(len(current_timeline)))

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t retrieve timeline', e)

except IncompleteRead as e:
self.log('Incomplete read error -- skipping timeline update')

def _check_followers(self):
"""
Checks followers.
"""
logging.info("Checking for new followers...")

try:
self.state['new_followers'] = [f_id for f_id in self.api.followers_ids(self.id) if f_id not in self.state['followers']]

self.config['last_follow_check'] = time.time()

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t update followers', e)

except IncompleteRead as e:
self.log('Incomplete read error -- skipping followers update')

def _handle_followers(self):
"""
Handles new followers.
"""
for f_id in self.state['new_followers']:
self.on_follow(f_id)

def register_custom_handler(self, action, interval):
"""
Register a custom action to run at some interval.
"""
handler = {}

handler['action'] = action
handler['interval'] = interval
handler['last_run'] = 0

self.custom_handlers.append(handler)

def run(self):
"""
Runs the bot! This probably shouldn't be in a "while True" lol.
"""
while True:

# check followers every 15 minutes
#if self.autofollow and (time.time() - self.last_follow_check) > (15 * 60):
if self.state['last_follow_check'] > (15 * 60):
self._check_followers()
self._handle_followers()

# check mentions every minute-ish
#if self.reply_to_mentions and (time.time() - self.last_mention_time) > 60:
if (time.time() - self.state['last_mention_time']) > 60:
self._check_mentions()
self._handle_mentions()

# tweet to timeline
#if self.reply_to_timeline and (time.time() - self.last_mention_time) > 60:
if (time.time() - self.state['last_timeline_time']) > 60:
self._check_timeline()
self._handle_timeline()

# tweet to timeline on the correct interval
if (time.time() - self.state['last_tweet_time']) > self.config['tweet_interval']:
self.on_scheduled_tweet()

# TODO: maybe this should only run if the above is successful...
if self.config['tweet_interval_range'] is not None:
self.config['tweet_interval'] = random.randint(*self.config['tweet_interval_range'])

self.log("Next tweet in {} seconds".format(self.config['tweet_interval']))
self.state['last_tweet_time'] = time.time()

# run custom action
for handler in self.custom_handlers:
if (time.time() - handler['last_run']) > handler['interval']:
handler['action']()
handler['last_run'] = time.time()

# save current state
self._save_state()

logging.info("Sleeping for a bit...")
time.sleep(30)

class FileStorage(object):
"""
Default storage adapter.

Adapters must implement two methods: read(name) and write(name).
"""

def read(self, name):
"""
Return an IO-like object that will produce binary data when read from.
If nothing is stored under the given name, raise IOError.
"""
filename = self._get_filename(name)
if os.path.exists(filename):
logging.debug("Reading from {}".format(filename))
else:
logging.debug("{} doesn't exist".format(filename))
return open(filename, 'rb')

def write(self, name):
"""
Return an IO-like object that will store binary data written to it.
"""
filename = self._get_filename(name)
if os.path.exists(filename):
logging.debug("Overwriting {}".format(filename))
else:
logging.debug("Creating {}".format(filename))
return open(filename, 'wb')

def _get_filename(self, name):
return '{}_state.pkl'.format(name)

</source>

GMU:Bots 'n' Plots/Sebastian Stang

2015-06-17T15:53:53Z

SebastianStang:

( ) ( ) 
(>•.•<) 
<nowiki> (") (")</nowiki>

== @_pil_bot_ ==

=== pilbot.py ===

<source lang="python">
# -*- coding: utf-8 -*- #

from twitterbot import TwitterBot
import keys

from PIL import Image
from sys import argv
from random import random

from pileval import PILEval

class PilBot(TwitterBot):

def __init__(self):
TwitterBot.__init__(self)
self.pillermann = PILEval()

def bot_init(self):
""" Initialize and configure the bot """

############################
# REQUIRED: LOGIN DETAILS! #
############################
self.config['api_key'] = keys.consumer_key
self.config['api_secret'] = keys.consumer_secret
self.config['access_key'] = keys.access_token
self.config['access_secret'] = keys.access_token_secret

######################################
# SEMI-OPTIONAL: OTHER CONFIG STUFF! #
######################################

# how often to tweet, in seconds
self.config['tweet_interval'] = 1 * 5 # default: 1 minutes

# use this to define a (min, max) random range of how often to tweet
# e.g., self.config['tweet_interval_range'] = (5*60, 10*60) # tweets every 5-10 minutes
self.config['tweet_interval_range'] = None

# only reply to tweets that specifically mention the bot
self.config['reply_direct_mention_only'] = True

# only include bot followers (and original tweeter) in @-replies
self.config['reply_followers_only'] = False

# fav any tweets that mention this bot?
self.config['autofav_mentions'] = False

# fav any tweets containing these keywords?
self.config['autofav_keywords'] = []

# follow back all followers?
self.config['autofollow'] = False

def on_scheduled_tweet(self):
""" Make a public tweet to the bot's own timeline. """
# We might take senteces from somewhere and tweet them on a regular basis ...
pass # don't do anything here ...

def on_mention(self, tweet, prefix):
""" Actions to take when a mention is received. """
text = tweet.text.split()[1]
self.action(text)

def on_timeline(self, tweet, prefix):
""" Actions to take on a timeline tweet. """
pass

def action(self, code):
result = self.pillermann.eval(code)

if result: # post the image
self.post_tweet(code, media="img.png", file=self.pillermann.get_file())
else: # post the error
self.post_tweet(self.pillermann.last_error)

if __name__ == '__main__':

bot = PilBot()

if len(argv) == 1:
bot.run()
else:
tweet_text = "text((300, 400), 'botsNplots', fill='#ff0')"
bot.action(tweet_text)

</source>

=== pileval.py ===

<source lang="python">
from PIL import Image, ImageDraw

from os import path
from io import BytesIO

class PILEval():

def __init__(self, filename='test.png'):
self.filename = filename
try:
self.image = Image.open(filename)
except FileNotFoundError as e:
self.image = Image.new("RGBA", (640, 480), 'white')
self.last_error = ''

def __repr__(self):
return "<PILEval: %s>" % self.filename

def eval(self, code):
draw = ImageDraw.Draw(self.image, "RGBA")
code = "draw.%s" % code

try:
code_obj = compile(code, '<string>', 'exec')
exec(code_obj)
except Exception as e:
self.last_error = str(e)
return False

self.image.save(self.filename)

return True

def get_file(self):
img = Image.open(self.filename)
file = BytesIO()
img.save(file, format='PNG')
return file

if __name__ == '__main__':
# some q'n'dirty tests
print("main")
pillermann = PILEval()

# will work
# result = pillermann.eval("rectangle([20, 10, 120, 200], fill='#f00')")
# if result:
# print('good')

# will also work
# result = pillermann.eval("ellipse([200, 50, 500, 500], fill='#def')")
# result = pillermann.eval("point((123, 234), fill='#345')")
# result = pillermann.eval("line([23, 34, 345, 456], fill='#eca', width=10)")
# result = pillermann.eval("arc([500, 10, 600, 440], 10, 95, fill='#3f9')")
# result = pillermann.eval("text((22, 202), '_pil_bot_!', fill='#a4f')")

result = pillermann.eval("text((100, 100), text=code, fill='#000')")
if result:
print("ok")
else:
print(pillermann.last_error)
# will yield a compiler error
# result = pillermann.eval("rectangle([20, 10, 120, 200], fill='#f00'")
# if not result:
# print("error result: %s" % pillermann.last_error)

# f = pillermann.get_file()
# print(f)

</source>

=== twitterbot/bot.py ===

adapts thricedotted's (http://lczzz.me) twitterbot for python 3

<source lang="python">

import os
import codecs
import json
import logging
import tweepy
import time
import re
import random
import pickle

def ignore(method):
"""
Use the @ignore decorator on TwitterBot methods you wish to leave
unimplemented, such as on_timeline and on_mention.
"""
method.not_implemented = True
return method

class TwitterBot:

def __init__(self):
self.config = {}

self.custom_handlers = []

self.config['reply_direct_mention_only'] = False
self.config['reply_followers_only'] = True

self.config['autofav_mentions'] = False
self.config['autofav_keywords'] = []

self.config['autofollow'] = False

self.config['tweet_interval'] = 30 * 60
self.config['tweet_interval_range'] = None

self.config['reply_interval'] = 10
self.config['reply_interval_range'] = None

self.config['ignore_timeline_mentions'] = True

self.config['logging_level'] = logging.DEBUG
self.config['storage'] = FileStorage()

self.state = {}

# call the custom initialization
self.bot_init()

auth = tweepy.OAuthHandler(self.config['api_key'], self.config['api_secret'])
auth.set_access_token(self.config['access_key'], self.config['access_secret'])
self.api = tweepy.API(auth)

self.id = self.api.me().id
self.screen_name = self.api.me().screen_name

logging.basicConfig(format='%(asctime)s | %(levelname)s: %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p',
filename=self.screen_name + '.log',
level=self.config['logging_level'])

logging.info('Initializing bot...')

try:
with self.config['storage'].read(self.screen_name) as f:
self.state = pickle.load(f)

except IOError:
self.state['last_timeline_id'] = 1
self.state['last_mention_id'] = 1

self.state['last_timeline_time'] = 0
self.state['last_mention_time'] = 0

self.state['last_tweet_id'] = 1
self.state['last_tweet_time'] = 1

self.state['last_reply_id'] = 0
self.state['last_reply_time'] = 0

self.state['recent_timeline'] = []
self.state['mention_queue'] = []

self.state['friends'] = self.api.friends_ids(self.id)
self.state['followers'] = self.api.followers_ids(self.id)
self.state['new_followers'] = []
self.state['last_follow_check'] = 0

logging.info('Bot initialized!')

def bot_init(self):
"""
Initialize custom state values for your bot.
"""
raise NotImplementedError("You MUST have bot_init() implemented in your bot! What have you DONE!")

def log(self, message, level=logging.INFO):
if level == logging.ERROR:
logging.error(message)
else:
logging.info(message)

def _log_tweepy_error(self, message, e):
try:
e_message = e.message[0]['message']
code = e.message[0]['code']
self.log("{}: {} ({})".format(message, e_message, code), level=logging.ERROR)
except:
self.log(message, e)

def _tweet_url(self, tweet):
return "http://twitter.com/" + tweet.author.screen_name + "/status/" + str(tweet.id)

def _save_state(self):
with self.config['storage'].write(self.screen_name) as f:
pickle.dump(self.state, f)
self.log('Bot state saved')

def on_scheduled_tweet(self):
"""
Post a general tweet to own timeline.
"""
#self.post_tweet(text)
raise NotImplementedError("You need to implement this to tweet to timeline (or pass if you don't want to)!")

def on_mention(self, tweet, prefix):
"""
Perform some action upon receiving a mention.
"""
#self.post_tweet(text)
raise NotImplementedError("You need to implement this to reply to/fav mentions (or pass if you don't want to)!")

def on_timeline(self, tweet, prefix):
"""
Perform some action on a tweet on the timeline.
"""
#self.post_tweet(text)
raise NotImplementedError("You need to implement this to reply to/fav timeline tweets (or pass if you don't want to)!")

def on_follow(self, f_id):
"""
Perform some action when followed.
"""
if self.config['autofollow']:
try:
self.api.create_friendship(f_id, follow=True)
self.state['friends'].append(f_id)
logging.info('Followed user id {}'.format(f_id))
except tweepy.TweepError as e:
self._log_tweepy_error('Unable to follow user', e)

time.sleep(3)

self.state['followers'].append(f_id)

def post_tweet(self, text, reply_to=None, media=None, file=None):
"""
Post a tweet containing the text.
If you provide a filename the file will be added to the tweet.
You can also provide the filedata, for example when using dynamically created images.
"""

kwargs = { "status": text }
args = []

if media is not None:
cmd = self.api.update_with_media
args.insert(0, media)

if file is not None:
kwargs["file"] = file
else:
cmd = self.api.update_status

try:
self.log('Tweeting "{}"'.format(text))
if reply_to:
self.log("-- Responding to status {}".format(self._tweet_url(reply_to)))
kwargs['in_reply_to_status_id'] = reply_to.id
else:
self.log("-- Posting to own timeline")

tweet = cmd(*args, **kwargs)
self.log('Status posted at {}'.format(self._tweet_url(tweet)))
return True

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t post status', e)
return False

def favorite_tweet(self, tweet):
try:
logging.info('Faving ' + self._tweet_url(tweet))
self.api.create_favorite(tweet.id)

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t fav status', e)

def _ignore_method(self, method):
return hasattr(method, 'not_implemented') and method.not_implemented

def _handle_timeline(self):
"""
Reads the latest tweets in the bots timeline and perform some action.
self.recent_timeline
"""
for tweet in self.state['recent_timeline']:
prefix = self.get_mention_prefix(tweet)
self.on_timeline(tweet, prefix)

words = tweet.text.lower().split()
if any(w in words for w in self.config['autofav_keywords']):
self.favorite_tweet(tweet)

#time.sleep(self.config['reply_interval'])

def _handle_mentions(self):
"""
Performs some action on the mentions in self.mention_queue
"""
# TODO: only handle a certain number of mentions at a time?
for mention in iter(self.state['mention_queue']):
prefix = self.get_mention_prefix(mention)
self.on_mention(mention, prefix)
self.state['mention_queue'].remove(mention)

if self.config['autofav_mentions']:
self.favorite_tweet(mention)

#time.sleep(self.config['reply_interval'])

def get_mention_prefix(self, tweet):
"""
Returns a string of users to @-mention when responding to a tweet.
"""
mention_back = ['@' + tweet.author.screen_name]
mention_back += [s for s in re.split('[^@\w]', tweet.text) if len(s) > 2 and s[0] == '@' and s[1:] != self.screen_name]

if self.config['reply_followers_only']:
mention_back = [s for s in mention_back if s[1:] in self.state['followers'] or s == '@' + tweet.author.screen_name]

return ' '.join(mention_back)

def _check_mentions(self):
"""
Checks mentions and loads most recent tweets into the mention queue
"""
if self._ignore_method(self.on_mention):
logging.debug('Ignoring mentions')
return

try:
current_mentions = self.api.mentions_timeline(since_id=self.state['last_mention_id'], count=100)

# direct mentions only?
if self.config['reply_direct_mention_only']:
current_mentions = [t for t in current_mentions if re.split('[^@\w]', t.text)[0] == '@' + self.screen_name]

if len(current_mentions) != 0:
self.state['last_mention_id'] = current_mentions[0].id

self.state['last_mention_time'] = time.time()

self.state['mention_queue'] += reversed(current_mentions)

logging.info('Mentions updated ({} retrieved, {} total in queue)'.format(len(current_mentions), len(self.state['mention_queue'])))

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t retrieve mentions', e)

except IncompleteRead as e:
self.log('Incomplete read error -- skipping mentions update')

def _check_timeline(self):
"""
Checks timeline and loads most recent tweets into recent timeline
"""
if self._ignore_method(self.on_timeline):
logging.debug('Ignoring timeline')
return

try:
current_timeline = self.api.home_timeline(count=200, since_id=self.state['last_timeline_id'])

# remove my tweets
current_timeline = [t for t in current_timeline if t.author.screen_name.lower() != self.screen_name.lower()]

# remove all tweets mentioning me
current_timeline = [t for t in current_timeline if not re.search('@'+self.screen_name, t.text, flags=re.IGNORECASE)]

if self.config['ignore_timeline_mentions']:
# remove all tweets with mentions (heuristically)
current_timeline = [t for t in current_timeline if '@' not in t.text]

if len(current_timeline) != 0:
self.state['last_timeline_id'] = current_timeline[0].id

self.state['last_timeline_time'] = time.time()

self.state['recent_timeline'] = list(reversed(current_timeline))

logging.info('Timeline updated ({} retrieved)'.format(len(current_timeline)))

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t retrieve timeline', e)

except IncompleteRead as e:
self.log('Incomplete read error -- skipping timeline update')

def _check_followers(self):
"""
Checks followers.
"""
logging.info("Checking for new followers...")

try:
self.state['new_followers'] = [f_id for f_id in self.api.followers_ids(self.id) if f_id not in self.state['followers']]

self.config['last_follow_check'] = time.time()

except tweepy.TweepError as e:
self._log_tweepy_error('Can\'t update followers', e)

except IncompleteRead as e:
self.log('Incomplete read error -- skipping followers update')

def _handle_followers(self):
"""
Handles new followers.
"""
for f_id in self.state['new_followers']:
self.on_follow(f_id)

def register_custom_handler(self, action, interval):
"""
Register a custom action to run at some interval.
"""
handler = {}

handler['action'] = action
handler['interval'] = interval
handler['last_run'] = 0

self.custom_handlers.append(handler)

def run(self):
"""
Runs the bot! This probably shouldn't be in a "while True" lol.
"""
while True:

# check followers every 15 minutes
#if self.autofollow and (time.time() - self.last_follow_check) > (15 * 60):
if self.state['last_follow_check'] > (15 * 60):
self._check_followers()
self._handle_followers()

# check mentions every minute-ish
#if self.reply_to_mentions and (time.time() - self.last_mention_time) > 60:
if (time.time() - self.state['last_mention_time']) > 60:
self._check_mentions()
self._handle_mentions()

# tweet to timeline
#if self.reply_to_timeline and (time.time() - self.last_mention_time) > 60:
if (time.time() - self.state['last_timeline_time']) > 60:
self._check_timeline()
self._handle_timeline()

# tweet to timeline on the correct interval
if (time.time() - self.state['last_tweet_time']) > self.config['tweet_interval']:
self.on_scheduled_tweet()

# TODO: maybe this should only run if the above is successful...
if self.config['tweet_interval_range'] is not None:
self.config['tweet_interval'] = random.randint(*self.config['tweet_interval_range'])

self.log("Next tweet in {} seconds".format(self.config['tweet_interval']))
self.state['last_tweet_time'] = time.time()

# run custom action
for handler in self.custom_handlers:
if (time.time() - handler['last_run']) > handler['interval']:
handler['action']()
handler['last_run'] = time.time()

# save current state
self._save_state()

logging.info("Sleeping for a bit...")
time.sleep(30)

class FileStorage(object):
"""
Default storage adapter.

Adapters must implement two methods: read(name) and write(name).
"""

def read(self, name):
"""
Return an IO-like object that will produce binary data when read from.
If nothing is stored under the given name, raise IOError.
"""
filename = self._get_filename(name)
if os.path.exists(filename):
logging.debug("Reading from {}".format(filename))
else:
logging.debug("{} doesn't exist".format(filename))
return open(filename, 'rb')

def write(self, name):
"""
Return an IO-like object that will store binary data written to it.
"""
filename = self._get_filename(name)
if os.path.exists(filename):
logging.debug("Overwriting {}".format(filename))
else:
logging.debug("Creating {}".format(filename))
return open(filename, 'wb')

def _get_filename(self, name):
return '{}_state.pkl'.format(name)

</source>

Template:PythonBooks

2015-06-02T16:55:37Z

SebastianStang:

=== Python ===
* Beazley, David: ''Python Cookbook'' ISBN 978-1449340377
* Chan, Jamie: ''Learn Python in One Day and Learn it Well'' ISBN 978-1506094380
* Blum, Richard: ''Python Programming for Raspberry Pi'' ISBN 978-0789752055
* Zelle, John: ''Python Programming: An Introduction to Computer Science'' ISBN 978-1590282410
* Gries, Paul: ''Practical Programming: An Introduction to Computer Science Using Python 3'' ISBN 978-1937785451

=== Bots n Plots ===
* Russell, Matthew A.: ''Mining the Social Web: Data Mining Facebook, Twitter, LinkedIn, Google+, GitHub, and More'' ISBN 978-1449367619
* Perkins, Jacob: ''Python Text Processing with NLTK 2.0 Cookbook'' ISBN 978-1849513609
* Bird, Steven: ''Natural Language Processing with Python'' ISBN 978-0596516499
* Craven, Dr. Paul Vincent: ''Program Arcade Games: With Python and Pygame'' ISBN 978-1500825966

=== Eval Nature ===
* Solem, Jan Erik: ''Programming Computer Vision with Python: Tools and algorithms for analyzing images'' ISBN 978-1449316549
* Ravishankar Chityala & Sridevi Pudipeddi: ''Image Processing and Acquisition Using Python (Chapman & Hall/CRC Mathematical and Computational Imaging Sc)'' ISBN 978-1466583757
* Downey, Allen B.: ''Think Complexity: Complexity Science and Computational Modeling'' ISBN 978-1449314637
* Mitchell, Melanie: ''Complexity: A Guided Tour'' ISBN 978-0199798100

Template:PythonBooks

2015-06-02T16:53:36Z

SebastianStang:

=== Python ===
* Beazley, David: ''Python Cookbook'' ISBN 978-1449340377
* Chan, Jamie: ''Learn Python in One Day and Learn it Well'' ISBN 978-1506094380
* Blum, Richard: ''Python Programming for Raspberry Pi'' ISBN 978-0789752055
* Zelle, John: ''Python Programming: An Introduction to Computer Science'' ISBN 978-1590282410

=== Bots n Plots ===
* Russell, Matthew A.: ''Mining the Social Web: Data Mining Facebook, Twitter, LinkedIn, Google+, GitHub, and More'' ISBN 978-1449367619
* Perkins, Jacob: ''Python Text Processing with NLTK 2.0 Cookbook'' ISBN 978-1849513609
* Bird, Steven: ''Natural Language Processing with Python'' ISBN 978-0596516499
* Craven, Dr. Paul Vincent: ''Program Arcade Games: With Python and Pygame'' ISBN 978-1500825966

=== Eval Nature ===
* Solem, Jan Erik: ''Programming Computer Vision with Python: Tools and algorithms for analyzing images'' ISBN 978-1449316549
* Ravishankar Chityala & Sridevi Pudipeddi: ''Image Processing and Acquisition Using Python (Chapman & Hall/CRC Mathematical and Computational Imaging Sc)'' ISBN 978-1466583757
* Downey, Allen B.: ''Think Complexity: Complexity Science and Computational Modeling'' ISBN 978-1449314637

Template:PythonBooks

2015-06-02T16:52:37Z

SebastianStang:

=== Python ===
* Beazley, David: ''Python Cookbook'' ISBN 978-1449340377
* Chan, Jamie: ''Learn Python in One Day and Learn it Well'' ISBN 978-1506094380
* Blum, Richard: ''Python Programming for Raspberry Pi'' ISBN 978-0789752055
* Zelle, John: ''Python Programming: An Introduction to Computer Science'' ISBN 978-1590282410

=== Bots n Plots ===
* Russell, Matthew A.: ''Mining the Social Web: Data Mining Facebook, Twitter, LinkedIn, Google+, GitHub, and More'' ISBN 978-1449367619
* Perkins, Jacob: ''Python Text Processing with NLTK 2.0 Cookbook'' ISBN 978-1849513609
* Bird, Steven: ''Natural Language Processing with Python'' ISBN 978-0596516499
* Craven, Dr. Paul Vincent: ''Program Arcade Games: With Python and Pygame'' ISBN 978-1500825966

=== Eval Nature ===
* Solem, Jan Erik: ''Programming Computer Vision with Python: Tools and algorithms for analyzing images'' ISBN 978-1449316549
* Ravishankar Chityala & Sridevi Pudipeddi: ''Image Processing and Acquisition Using Python (Chapman & Hall/CRC Mathematical and Computational Imaging Sc)'' ISBN 978-1466583757

Template:PythonBooks

2015-06-02T16:50:01Z

SebastianStang:

Template:PythonBooks

2015-06-02T16:45:10Z

SebastianStang:

Template:PythonBooks

2015-06-02T16:42:15Z

SebastianStang: Created page with "* Beazley, David: ''Python Cookbook'' ISBN 978-1449340377 * Chan, Jamie: ''Learn Python in One Day and Learn it Well'' ISBN 978-1506094380 * Blum, Richard: ''Python Programming ..."

* Beazley, David: ''Python Cookbook'' ISBN 978-1449340377
* Chan, Jamie: ''Learn Python in One Day and Learn it Well'' ISBN 978-1506094380
* Blum, Richard: ''Python Programming for Raspberry Pi'' ISBN 978-0789752055
* Zelle, John: ''Python Programming: An Introduction to Computer Science'' ISBN 978-1590282410

GMU:Bots 'n' Plots/Sebastian Stang

2015-04-22T09:05:17Z

SebastianStang:

( ) ( ) 
(>•.•<) 
<nowiki> (") (")</nowiki>

GMU:Bots 'n' Plots

2015-04-22T08:58:48Z

SebastianStang:

[[Image:Bots-n-plots-maillardet-drawing.png|thumb|left|300px|''Drawing by [[wikipedia:Maillardet's automaton|the Draughtsman-Writer Bot]] ca. 1800'']] 

'''Bots 'n' Plots — Malen nach 0 und 1'''

[[:Category:Werkmodul|Werkmodul]]/[[:Category:Fachmodul|Fachmodul]] 
''Lecturer:'' [[User:ms|Martin Schneider]] 
''Credits:'' 6 [[ECTS]], 4 [[SWS]] 
''Date:'' Wednesday 17:00 - 20:30 Uhr 
''Venue:'' [[Marienstraße 7b]], Room 204 
''First meeting:'' Wednesday, 15. Apr. 2015

 

'''NEWS'''

'''The Deadline has been extended by 24 hours :)'''
'''You need to apply until 24:00 on April 13th, 2015.'''
Applications after the deadline will not be taken into consideration.
I will let you know if you made it onto the list on April 14th.

'''Follow [http://twitter.com/botsnplots @botsnplots] on Twitter!

== Description ==

''The internet of things is infiltrating the social web.'' 
''A rich ecosystem of social bots is evolving right now.'' 
''Those bots range from the purposeful via the poetic to the philosophical.'' 
''And they are starting to talk to each other.'' 

In the Bots 'n' Plots course, we will create little robots that doodle and babble. 
Our robots will be based in software, but we will also learn how to connect them with the physical world, using vision sound and serial connections. 

In the course of the class you will:

* Learn programming with Python
* Process images and text
* Create generative drawings and poems
* Use APIs for the social web, including Twitter and Mediawiki
* Create your own software bots and make them talk to each other

The course requires no previous programming experience.

As a result of the course you will acquire fundamental programming skills that will enable you to take more advanced courses in the future. 
It is recommended to combine the course with the [[GMU:eval(nature)|eval(nature) module]]. 

== Beschreibung ==

''Das Internet der Dinge erobert die sozialen Netzwerke.'' 
''Im Augenblick entwickelt sich ein vielfältiges Ökosystem sozialer Bots.'' 
''Die Bots decken ein weites Spektrum ab, vom Praktischen, über Poetisches bis hin zum Philosophischen.'' 
''Und sie fangen an miteinander zu kommunizieren...'' 

In ''Malen nach 0 und 1'' werden wir kleine Roboter erschaffen, die kritzeln und brabbeln. 
Unsere Roboter bestehen aus Nullen und Einsen, aber wir werden auch lernen sie mit der materiellen Welt zu verbinden, wobei Kameras, Töne und Kabel zum Einsatz kommen. 

Im Rahmen des Moduls werdet ihr:

* Programmieren mit Python lernen
* Grafik und Text verarbeiten
* Generative Grafiken und Gedichte erzeugen
* APIs für Soziale Netzwerke nutzen, inkl. Twitter und Mediawiki
* Eigene Software-Bots entwickeln und sie dazu bringen miteinander zu reden.

Dieses Modul erfordert keine Programmierkentnisse.

Im Rahmen des Kurses werden grundlegende Programmierkentnisse vermittelt, die es ermöglichen in Zukunft fortgeschrittene Kurse zu belegen. 
Es wird empfohlen diesen Kurs mit dem Projekt-Modul [[GMU:eval(nature)|eval(nature)]] zu kombinieren.

== Language ==

The course will be in English, unless all participants are speaking German.

== Eligible Participants ==

Undergraduates and graduates enrolled in the faculties of:

* Media Art/Design
* Visual Communication

== Requirements ==

* Burning Interest in Artificial Intelligence, Computer-Linguistics and Generative Design
* Previous course about the Internet of Things highly recommended
* Working knowledge of Web Technologies (HTML, CSS, Javascript ...)
* Time and Devotion for lots of coding homework, which may be frustrating at times
* Programming experience considered helpful

== Application ==

The deadline to apply for this course is April 13th, 2015

You need to provide links to previous work to be elligible to this course.

'''To:''' [[User:ms|Martin Schneider]] 
'''Subject:''' Bots n Plots /// Application 
'''Content:'''

# Please provide links to three of your visual, poetic or algorithmic works online.
# Please answer these questions:
#* What is your favourite bot on twitter?
#* What kind of bot would you like to be able to create at the end of the course?
# Please tell us about you:
#* program and semester (Studienprogramm und Fachsemester)
#* matriculation number (Matrikelnummer)
#* Valid email address @uni-weimar.de (no other mailing addresses will be accepted) [[SCC-Services#E-Mail|Why?]]

== Schedule ==

This is the outline of the course.
The details may still be subject to change.

{| class="wikitable"
|-
! Theme !! Topic !! Date
|-
| rowspan="2" | [[/Part1|Part 1: Python]]
| 01: Programming I
| 15. April 2015
|-
| 02: Programming II
| 22. April 2015
|-
| rowspan="4" | [[/Part2|Part 2: Plotter Bots]]
| 03: Drawing and Plotting I
| 29. April 2015
|-
| 04: Drawing and Plotting II
| 06. May 2015
|-
| 05: Image Processing I
| 13. May 2015
|-
| 06: Image Processing II
| 20. May 2015
|-
| rowspan="3" | [[/Part3|Part 3: Chatter Bots]]
| 07: Language Processing I
| 27. May 2015
|-
| 08: Language Processing II
| 03. June 2015
|-
| 09: Generating Poetry
| 10. June 2015
|-
| rowspan="4" | [[/Part4|Part 4: Social Bots]]
| 10: Twitter Bots I
| 17. June 2015
|-
| 11: Twitter Bots II
| 24. June 2015
|-
| 12: Wiki Bots I
| 01. July 2015
|-
| 13: Wiki Bots II
| 08. July 2015
|}

== Evaluation ==

* Presence and active participation (required)
* Punctual and complete submission of homework (required)

* 50% Technical and aesthetic execution of the final bot project
* 20% Emergent behaviour from making the robots talk
* 20% Documentation of the final project
* 10% Contribution to the MediaWiki

== Participants ==

* [[GMU:Bots_'n'_Plots/Sebastian Stang|Sebastian Stang]]
* [[GMU:Bots_'n'_Plots/Maria Degand|Maria Degand]]
* [[GMU:Bots_'n'_Plots/Klaus Kraemer|Klaus Kraemer]]
* [[GMU:Bots_'n'_Plots/Angelica Sohn|Angelica Sohn]]
* [[GMU:Bots_'n'_Plots/Luis Hurtarte|Luis Hurtarte]]
* [[GMU:Bots_'n'_Plots/Apasri Titatarn|Apasri Titatarn]]
* [[GMU:Bots_'n'_Plots/Jan Dropmann|Jan Dropmann]]
* [[GMU:Bots_'n'_Plots/Azucena Sanchez|Azucena Sanchez]]
* [[GMU:Bots_'n'_Plots/Natalia Martínez|Natalia Martínez]]
* [[GMU:Bots_'n'_Plots/smin kim|Smin Kim]]
* [[GMU:Bots_'n'_Plots/minsoo hwang|minsoo Hwang]]
* [[GMU:Bots_'n'_Plots/Christopher Marx|Christopher Marx]]
* [[GMU:Bots_'n'_Plots/Shubhra Bhatt|Shubhra Bhatt]]
* [[GMU:Bots_'n'_Plots/Constantin Oestreich|Constantin Oestreich]]

== Links ==

Here are a couple of links that should give you an idea of where this course is heading ...

=== Learning Python ===
* [http://www.codecademy.com/en/tracks/python Learn Python] at Code Academy
* [http://www.diveintopython3.net Dive Into Python 3]

=== Image Processing ===
* [http://software-carpentry.org/v4/media/ Multimedia Programming] by Software Carpentry
=== Video Processing ===
* [https://zulko.github.io/moviepy/ MoviePy] by Zulko
* [https://zulko.github.io/blog/2014/09/20/vector-animations-with-python/ Vector Animations with Python]
=== Audio ===
==== IO ====
* [http://people.csail.mit.edu/hubert/pyaudio/ PyAudio] realtime IO, PortAudio
* [https://github.com/thestk/rtaudio/tree/master/contrib/python/pyrtaudio PyRtAudio] realtime IO, RtAudio
* [http://www.ar.media.kyoto-u.ac.jp/members/david/softwares/audiolab/ audiolab] audio file IO, libsndfile
==== Analysis and Synthesis ====
* [http://www.cerlsoundgroup.org/Loris/ Loris]
* [http://musickit.sourceforge.net MusicKit]
* [http://sndobj.sourceforge.net SndObject]
==== Plotting ====
* [http://matplotlib.org matplotlib]
==== Number Crunching ====
* [http://docs.scipy.org/doc/ scipy and numpy]

=== Language Processing ===
* [http://h6o6.com/2013/03/using-python-and-the-nltk-to-find-haikus-in-the-public-twitter-stream/ Using Python and the NLTK to find Haikus in the public twitter stream]
* [http://dhconnelly.com/paip-python/docs/paip/eliza.html Eliza.py]
=== Twitter ===
* [https://zulko.github.io/blog/2014/07/26/a-tweets-controlled-python-script/|A Python Script controlled via Twitter]
=== Contribution by Students ===
* [http://www.belfasttelegraph.co.uk/technology/robot-that-bought-mdma-passport-and-baseball-cap-released-by-authorities-31150495.html "Random Darknet Shopper" bot released from prison]

== Literature ==
* Bird, Steven: ''Natural Language Processing with Python'' ISBN 978-0596516499 ([http://www.nltk.org/book/ online])
* Lobin, Hennig:''Computerlinguistik und Texttechnologie'' ISBN 978-3825232825
* Russel, Mathew: ''Mining the Social Web'' ISBN 978-1449367619
* Segaran, Toby'': Programming Collective Intelligence'' ISBN 978-0596529321

=== Python ===
This is a list of recommended books for the Python language: 


* Beazley, David: ''Python Cookbook'' ISBN 978-1449340377
* Blum, Richard: ''Python Programming for Raspberry Pi'' ISBN 978-0789752055
* Chan, Jamie: ''Learn Python in One Day and Learn it Well'' ISBN 978-1506094380
* Zelle, John: ''Python Programming: An Introduction to Computer Science'' ISBN 978-1590282410 ([http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.111.6062 online])

=== Further Reading ===
There are a couple of books in the Semesterapparat of [[Society of Networked Things]], that you might want to flip trough.

[[Category:SS15]]
[[Category:Werkmodul]]
[[Category:Fachmodul]]
[[Category:Martin Schneider]]
[[Category:Python]]
[[Category:Gestaltung]]
[[Category:Design]]
[[Category:Poetry]]
[[Category:Generative Gestaltung]]
[[Category:Robots]]

GMU:Bots 'n' Plots

2015-04-22T08:41:26Z

SebastianStang: added audio file io

[[Image:Bots-n-plots-maillardet-drawing.png|thumb|left|300px|''Drawing by [[wikipedia:Maillardet's automaton|the Draughtsman-Writer Bot]] ca. 1800'']] 

'''Bots 'n' Plots — Malen nach 0 und 1'''

[[:Category:Werkmodul|Werkmodul]]/[[:Category:Fachmodul|Fachmodul]] 
''Lecturer:'' [[User:ms|Martin Schneider]] 
''Credits:'' 6 [[ECTS]], 4 [[SWS]] 
''Date:'' Wednesday 17:00 - 20:30 Uhr 
''Venue:'' [[Marienstraße 7b]], Room 204 
''First meeting:'' Wednesday, 15. Apr. 2015

 

'''NEWS'''

'''The Deadline has been extended by 24 hours :)'''
'''You need to apply until 24:00 on April 13th, 2015.'''
Applications after the deadline will not be taken into consideration.
I will let you know if you made it onto the list on April 14th.

'''Follow [http://twitter.com/botsnplots @botsnplots] on Twitter!

== Description ==

''The internet of things is infiltrating the social web.'' 
''A rich ecosystem of social bots is evolving right now.'' 
''Those bots range from the purposeful via the poetic to the philosophical.'' 
''And they are starting to talk to each other.'' 

In the Bots 'n' Plots course, we will create little robots that doodle and babble. 
Our robots will be based in software, but we will also learn how to connect them with the physical world, using vision sound and serial connections. 

In the course of the class you will:

* Learn programming with Python
* Process images and text
* Create generative drawings and poems
* Use APIs for the social web, including Twitter and Mediawiki
* Create your own software bots and make them talk to each other

The course requires no previous programming experience.

As a result of the course you will acquire fundamental programming skills that will enable you to take more advanced courses in the future. 
It is recommended to combine the course with the [[GMU:eval(nature)|eval(nature) module]]. 

== Beschreibung ==

''Das Internet der Dinge erobert die sozialen Netzwerke.'' 
''Im Augenblick entwickelt sich ein vielfältiges Ökosystem sozialer Bots.'' 
''Die Bots decken ein weites Spektrum ab, vom Praktischen, über Poetisches bis hin zum Philosophischen.'' 
''Und sie fangen an miteinander zu kommunizieren...'' 

In ''Malen nach 0 und 1'' werden wir kleine Roboter erschaffen, die kritzeln und brabbeln. 
Unsere Roboter bestehen aus Nullen und Einsen, aber wir werden auch lernen sie mit der materiellen Welt zu verbinden, wobei Kameras, Töne und Kabel zum Einsatz kommen. 

Im Rahmen des Moduls werdet ihr:

* Programmieren mit Python lernen
* Grafik und Text verarbeiten
* Generative Grafiken und Gedichte erzeugen
* APIs für Soziale Netzwerke nutzen, inkl. Twitter und Mediawiki
* Eigene Software-Bots entwickeln und sie dazu bringen miteinander zu reden.

Dieses Modul erfordert keine Programmierkentnisse.

Im Rahmen des Kurses werden grundlegende Programmierkentnisse vermittelt, die es ermöglichen in Zukunft fortgeschrittene Kurse zu belegen. 
Es wird empfohlen diesen Kurs mit dem Projekt-Modul [[GMU:eval(nature)|eval(nature)]] zu kombinieren.

== Language ==

The course will be in English, unless all participants are speaking German.

== Eligible Participants ==

Undergraduates and graduates enrolled in the faculties of:

* Media Art/Design
* Visual Communication

== Requirements ==

* Burning Interest in Artificial Intelligence, Computer-Linguistics and Generative Design
* Previous course about the Internet of Things highly recommended
* Working knowledge of Web Technologies (HTML, CSS, Javascript ...)
* Time and Devotion for lots of coding homework, which may be frustrating at times
* Programming experience considered helpful

== Application ==

The deadline to apply for this course is April 13th, 2015

You need to provide links to previous work to be elligible to this course.

'''To:''' [[User:ms|Martin Schneider]] 
'''Subject:''' Bots n Plots /// Application 
'''Content:'''

# Please provide links to three of your visual, poetic or algorithmic works online.
# Please answer these questions:
#* What is your favourite bot on twitter?
#* What kind of bot would you like to be able to create at the end of the course?
# Please tell us about you:
#* program and semester (Studienprogramm und Fachsemester)
#* matriculation number (Matrikelnummer)
#* Valid email address @uni-weimar.de (no other mailing addresses will be accepted) [[SCC-Services#E-Mail|Why?]]

== Schedule ==

This is the outline of the course.
The details may still be subject to change.

{| class="wikitable"
|-
! Theme !! Topic !! Date
|-
| rowspan="2" | [[/Part1|Part 1: Python]]
| 01: Programming I
| 15. April 2015
|-
| 02: Programming II
| 22. April 2015
|-
| rowspan="4" | [[/Part2|Part 2: Plotter Bots]]
| 03: Drawing and Plotting I
| 29. April 2015
|-
| 04: Drawing and Plotting II
| 06. May 2015
|-
| 05: Image Processing I
| 13. May 2015
|-
| 06: Image Processing II
| 20. May 2015
|-
| rowspan="3" | [[/Part3|Part 3: Chatter Bots]]
| 07: Language Processing I
| 27. May 2015
|-
| 08: Language Processing II
| 03. June 2015
|-
| 09: Generating Poetry
| 10. June 2015
|-
| rowspan="4" | [[/Part4|Part 4: Social Bots]]
| 10: Twitter Bots I
| 17. June 2015
|-
| 11: Twitter Bots II
| 24. June 2015
|-
| 12: Wiki Bots I
| 01. July 2015
|-
| 13: Wiki Bots II
| 08. July 2015
|}

== Evaluation ==

* Presence and active participation (required)
* Punctual and complete submission of homework (required)

* 50% Technical and aesthetic execution of the final bot project
* 20% Emergent behaviour from making the robots talk
* 20% Documentation of the final project
* 10% Contribution to the MediaWiki

== Participants ==

* [[GMU:Bots_'n'_Plots/Sebastian Stang|Sebastian Stang]]
* [[GMU:Bots_'n'_Plots/Maria Degand|Maria Degand]]
* [[GMU:Bots_'n'_Plots/Klaus Kraemer|Klaus Kraemer]]
* [[GMU:Bots_'n'_Plots/Angelica Sohn|Angelica Sohn]]
* [[GMU:Bots_'n'_Plots/Luis Hurtarte|Luis Hurtarte]]
* [[GMU:Bots_'n'_Plots/Apasri Titatarn|Apasri Titatarn]]
* [[GMU:Bots_'n'_Plots/Jan Dropmann|Jan Dropmann]]
* [[GMU:Bots_'n'_Plots/Azucena Sanchez|Azucena Sanchez]]
* [[GMU:Bots_'n'_Plots/Natalia Martínez|Natalia Martínez]]
* [[GMU:Bots_'n'_Plots/smin kim|Smin Kim]]
* [[GMU:Bots_'n'_Plots/minsoo hwang|minsoo Hwang]]
* [[GMU:Bots_'n'_Plots/Christopher Marx|Christopher Marx]]
* [[GMU:Bots_'n'_Plots/Shubhra Bhatt|Shubhra Bhatt]]
* [[GMU:Bots_'n'_Plots/Constantin Oestreich|Constantin Oestreich]]

== Links ==

Here are a couple of links that should give you an idea of where this course is heading ...

=== Learning Python ===
* [http://www.codecademy.com/en/tracks/python Learn Python] at Code Academy
* [http://www.diveintopython3.net Dive Into Python 3]

=== Image Processing ===
* [http://software-carpentry.org/v4/media/ Multimedia Programming] by Software Carpentry
=== Video Processing ===
* [https://zulko.github.io/moviepy/ MoviePy] by Zulko
* [https://zulko.github.io/blog/2014/09/20/vector-animations-with-python/ Vector Animations with Python]
=== Audio Processing ===
====IO====
* [http://people.csail.mit.edu/hubert/pyaudio/ PyAudio] realtime IO, PortAudio
* [https://github.com/thestk/rtaudio/tree/master/contrib/python/pyrtaudio PyRtAudio] realtime IO, RtAudio
* [http://www.ar.media.kyoto-u.ac.jp/members/david/softwares/audiolab/ audiolab] audio file IO, libsndfile
=== Language Processing ===
* [http://h6o6.com/2013/03/using-python-and-the-nltk-to-find-haikus-in-the-public-twitter-stream/ Using Python and the NLTK to find Haikus in the public twitter stream]
* [http://dhconnelly.com/paip-python/docs/paip/eliza.html Eliza.py]
=== Twitter ===
* [https://zulko.github.io/blog/2014/07/26/a-tweets-controlled-python-script/|A Python Script controlled via Twitter]
=== Contribution by Students ===
* [http://www.belfasttelegraph.co.uk/technology/robot-that-bought-mdma-passport-and-baseball-cap-released-by-authorities-31150495.html "Random Darknet Shopper" bot released from prison]

== Literature ==
* Bird, Steven: ''Natural Language Processing with Python'' ISBN 978-0596516499 ([http://www.nltk.org/book/ online])
* Lobin, Hennig:''Computerlinguistik und Texttechnologie'' ISBN 978-3825232825
* Russel, Mathew: ''Mining the Social Web'' ISBN 978-1449367619
* Segaran, Toby'': Programming Collective Intelligence'' ISBN 978-0596529321

=== Python ===
This is a list of recommended books for the Python language: 


* Beazley, David: ''Python Cookbook'' ISBN 978-1449340377
* Blum, Richard: ''Python Programming for Raspberry Pi'' ISBN 978-0789752055
* Chan, Jamie: ''Learn Python in One Day and Learn it Well'' ISBN 978-1506094380
* Zelle, John: ''Python Programming: An Introduction to Computer Science'' ISBN 978-1590282410 ([http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.111.6062 online])

=== Further Reading ===
There are a couple of books in the Semesterapparat of [[Society of Networked Things]], that you might want to flip trough.

[[Category:SS15]]
[[Category:Werkmodul]]
[[Category:Fachmodul]]
[[Category:Martin Schneider]]
[[Category:Python]]
[[Category:Gestaltung]]
[[Category:Design]]
[[Category:Poetry]]
[[Category:Generative Gestaltung]]
[[Category:Robots]]

GMU:Bots 'n' Plots

2015-04-22T08:34:15Z

SebastianStang: added Audio-IO libraries

[[Image:Bots-n-plots-maillardet-drawing.png|thumb|left|300px|''Drawing by [[wikipedia:Maillardet's automaton|the Draughtsman-Writer Bot]] ca. 1800'']] 

'''Bots 'n' Plots — Malen nach 0 und 1'''

[[:Category:Werkmodul|Werkmodul]]/[[:Category:Fachmodul|Fachmodul]] 
''Lecturer:'' [[User:ms|Martin Schneider]] 
''Credits:'' 6 [[ECTS]], 4 [[SWS]] 
''Date:'' Wednesday 17:00 - 20:30 Uhr 
''Venue:'' [[Marienstraße 7b]], Room 204 
''First meeting:'' Wednesday, 15. Apr. 2015

 

'''NEWS'''

'''The Deadline has been extended by 24 hours :)'''
'''You need to apply until 24:00 on April 13th, 2015.'''
Applications after the deadline will not be taken into consideration.
I will let you know if you made it onto the list on April 14th.

'''Follow [http://twitter.com/botsnplots @botsnplots] on Twitter!

== Description ==

''The internet of things is infiltrating the social web.'' 
''A rich ecosystem of social bots is evolving right now.'' 
''Those bots range from the purposeful via the poetic to the philosophical.'' 
''And they are starting to talk to each other.'' 

In the Bots 'n' Plots course, we will create little robots that doodle and babble. 
Our robots will be based in software, but we will also learn how to connect them with the physical world, using vision sound and serial connections. 

In the course of the class you will:

* Learn programming with Python
* Process images and text
* Create generative drawings and poems
* Use APIs for the social web, including Twitter and Mediawiki
* Create your own software bots and make them talk to each other

The course requires no previous programming experience.

As a result of the course you will acquire fundamental programming skills that will enable you to take more advanced courses in the future. 
It is recommended to combine the course with the [[GMU:eval(nature)|eval(nature) module]]. 

== Beschreibung ==

''Das Internet der Dinge erobert die sozialen Netzwerke.'' 
''Im Augenblick entwickelt sich ein vielfältiges Ökosystem sozialer Bots.'' 
''Die Bots decken ein weites Spektrum ab, vom Praktischen, über Poetisches bis hin zum Philosophischen.'' 
''Und sie fangen an miteinander zu kommunizieren...'' 

In ''Malen nach 0 und 1'' werden wir kleine Roboter erschaffen, die kritzeln und brabbeln. 
Unsere Roboter bestehen aus Nullen und Einsen, aber wir werden auch lernen sie mit der materiellen Welt zu verbinden, wobei Kameras, Töne und Kabel zum Einsatz kommen. 

Im Rahmen des Moduls werdet ihr:

* Programmieren mit Python lernen
* Grafik und Text verarbeiten
* Generative Grafiken und Gedichte erzeugen
* APIs für Soziale Netzwerke nutzen, inkl. Twitter und Mediawiki
* Eigene Software-Bots entwickeln und sie dazu bringen miteinander zu reden.

Dieses Modul erfordert keine Programmierkentnisse.

Im Rahmen des Kurses werden grundlegende Programmierkentnisse vermittelt, die es ermöglichen in Zukunft fortgeschrittene Kurse zu belegen. 
Es wird empfohlen diesen Kurs mit dem Projekt-Modul [[GMU:eval(nature)|eval(nature)]] zu kombinieren.

== Language ==

The course will be in English, unless all participants are speaking German.

== Eligible Participants ==

Undergraduates and graduates enrolled in the faculties of:

* Media Art/Design
* Visual Communication

== Requirements ==

* Burning Interest in Artificial Intelligence, Computer-Linguistics and Generative Design
* Previous course about the Internet of Things highly recommended
* Working knowledge of Web Technologies (HTML, CSS, Javascript ...)
* Time and Devotion for lots of coding homework, which may be frustrating at times
* Programming experience considered helpful

== Application ==

The deadline to apply for this course is April 13th, 2015

You need to provide links to previous work to be elligible to this course.

'''To:''' [[User:ms|Martin Schneider]] 
'''Subject:''' Bots n Plots /// Application 
'''Content:'''

# Please provide links to three of your visual, poetic or algorithmic works online.
# Please answer these questions:
#* What is your favourite bot on twitter?
#* What kind of bot would you like to be able to create at the end of the course?
# Please tell us about you:
#* program and semester (Studienprogramm und Fachsemester)
#* matriculation number (Matrikelnummer)
#* Valid email address @uni-weimar.de (no other mailing addresses will be accepted) [[SCC-Services#E-Mail|Why?]]

== Schedule ==

This is the outline of the course.
The details may still be subject to change.

{| class="wikitable"
|-
! Theme !! Topic !! Date
|-
| rowspan="2" | [[/Part1|Part 1: Python]]
| 01: Programming I
| 15. April 2015
|-
| 02: Programming II
| 22. April 2015
|-
| rowspan="4" | [[/Part2|Part 2: Plotter Bots]]
| 03: Drawing and Plotting I
| 29. April 2015
|-
| 04: Drawing and Plotting II
| 06. May 2015
|-
| 05: Image Processing I
| 13. May 2015
|-
| 06: Image Processing II
| 20. May 2015
|-
| rowspan="3" | [[/Part3|Part 3: Chatter Bots]]
| 07: Language Processing I
| 27. May 2015
|-
| 08: Language Processing II
| 03. June 2015
|-
| 09: Generating Poetry
| 10. June 2015
|-
| rowspan="4" | [[/Part4|Part 4: Social Bots]]
| 10: Twitter Bots I
| 17. June 2015
|-
| 11: Twitter Bots II
| 24. June 2015
|-
| 12: Wiki Bots I
| 01. July 2015
|-
| 13: Wiki Bots II
| 08. July 2015
|}

== Evaluation ==

* Presence and active participation (required)
* Punctual and complete submission of homework (required)

* 50% Technical and aesthetic execution of the final bot project
* 20% Emergent behaviour from making the robots talk
* 20% Documentation of the final project
* 10% Contribution to the MediaWiki

== Participants ==

* [[GMU:Bots_'n'_Plots/Sebastian Stang|Sebastian Stang]]
* [[GMU:Bots_'n'_Plots/Maria Degand|Maria Degand]]
* [[GMU:Bots_'n'_Plots/Klaus Kraemer|Klaus Kraemer]]
* [[GMU:Bots_'n'_Plots/Angelica Sohn|Angelica Sohn]]
* [[GMU:Bots_'n'_Plots/Luis Hurtarte|Luis Hurtarte]]
* [[GMU:Bots_'n'_Plots/Apasri Titatarn|Apasri Titatarn]]
* [[GMU:Bots_'n'_Plots/Jan Dropmann|Jan Dropmann]]
* [[GMU:Bots_'n'_Plots/Azucena Sanchez|Azucena Sanchez]]
* [[GMU:Bots_'n'_Plots/Natalia Martínez|Natalia Martínez]]
* [[GMU:Bots_'n'_Plots/smin kim|Smin Kim]]
* [[GMU:Bots_'n'_Plots/minsoo hwang|minsoo Hwang]]
* [[GMU:Bots_'n'_Plots/Christopher Marx|Christopher Marx]]
* [[GMU:Bots_'n'_Plots/Shubhra Bhatt|Shubhra Bhatt]]
* [[GMU:Bots_'n'_Plots/Constantin Oestreich|Constantin Oestreich]]

== Links ==

Here are a couple of links that should give you an idea of where this course is heading ...

=== Learning Python ===
* [http://www.codecademy.com/en/tracks/python Learn Python] at Code Academy
* [http://www.diveintopython3.net Dive Into Python 3]

=== Image Processing ===
* [http://software-carpentry.org/v4/media/ Multimedia Programming] by Software Carpentry
=== Video Processing ===
* [https://zulko.github.io/moviepy/ MoviePy] by Zulko
* [https://zulko.github.io/blog/2014/09/20/vector-animations-with-python/ Vector Animations with Python]
=== Audio Processing ===
====IO====
* [http://people.csail.mit.edu/hubert/pyaudio/ PyAudio] PortAudio wrapper
* [https://github.com/thestk/rtaudio/tree/master/contrib/python/pyrtaudio PyRtAudio] RtAudio wrapper
=== Language Processing ===
* [http://h6o6.com/2013/03/using-python-and-the-nltk-to-find-haikus-in-the-public-twitter-stream/ Using Python and the NLTK to find Haikus in the public twitter stream]
* [http://dhconnelly.com/paip-python/docs/paip/eliza.html Eliza.py]
=== Twitter ===
* [https://zulko.github.io/blog/2014/07/26/a-tweets-controlled-python-script/|A Python Script controlled via Twitter]
=== Contribution by Students ===
* [http://www.belfasttelegraph.co.uk/technology/robot-that-bought-mdma-passport-and-baseball-cap-released-by-authorities-31150495.html "Random Darknet Shopper" bot released from prison]

== Literature ==
* Bird, Steven: ''Natural Language Processing with Python'' ISBN 978-0596516499 ([http://www.nltk.org/book/ online])
* Lobin, Hennig:''Computerlinguistik und Texttechnologie'' ISBN 978-3825232825
* Russel, Mathew: ''Mining the Social Web'' ISBN 978-1449367619
* Segaran, Toby'': Programming Collective Intelligence'' ISBN 978-0596529321

=== Python ===
This is a list of recommended books for the Python language: 


* Beazley, David: ''Python Cookbook'' ISBN 978-1449340377
* Blum, Richard: ''Python Programming for Raspberry Pi'' ISBN 978-0789752055
* Chan, Jamie: ''Learn Python in One Day and Learn it Well'' ISBN 978-1506094380
* Zelle, John: ''Python Programming: An Introduction to Computer Science'' ISBN 978-1590282410 ([http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.111.6062 online])

=== Further Reading ===
There are a couple of books in the Semesterapparat of [[Society of Networked Things]], that you might want to flip trough.

[[Category:SS15]]
[[Category:Werkmodul]]
[[Category:Fachmodul]]
[[Category:Martin Schneider]]
[[Category:Python]]
[[Category:Gestaltung]]
[[Category:Design]]
[[Category:Poetry]]
[[Category:Generative Gestaltung]]
[[Category:Robots]]

GMU:Bots 'n' Plots

2015-04-18T03:38:00Z

SebastianStang:

[[Image:Bots-n-plots-maillardet-drawing.png|thumb|left|300px|''Drawing by [[wikipedia:Maillardet's automaton|the Draughtsman-Writer Bot]] ca. 1800'']] 

'''Bots 'n' Plots — Malen nach 0 und 1'''

[[:Category:Werkmodul|Werkmodul]]/[[:Category:Fachmodul|Fachmodul]] 
''Lecturer:'' [[User:ms|Martin Schneider]] 
''Credits:'' 6 [[ECTS]], 4 [[SWS]] 
''Date:'' Wednesday 17:00 - 20:30 Uhr 
''Venue:'' [[Marienstraße 7b]], Room 204 
''First meeting:'' Wednesday, 15. Apr. 2015

 

'''NEWS'''

'''The Deadline has been extended by 24 hours :)'''
'''You need to apply until 24:00 on April 13th, 2015.'''
Applications after the deadline will not be taken into consideration.
I will let you know if you made it onto the list on April 14th.

'''Follow [http://twitter.com/botsnplots @botsnplots] on Twitter!

== Description ==

''The internet of things is infiltrating the social web.'' 
''A rich ecosystem of social bots is evolving right now.'' 
''Those bots range from the purposeful via the poetic to the philosophical.'' 
''And they are starting to talk to each other.'' 

In the Bots 'n' Plots course, we will create little robots that doodle and babble. 
Our robots will be based in software, but we will also learn how to connect them with the physical world, using vision sound and serial connections. 

In the course of the class you will:

* Learn programming with Python
* Process images and text
* Create generative drawings and poems
* Use APIs for the social web, including Twitter and Mediawiki
* Create your own software bots and make them talk to each other

The course requires no previous programming experience.

As a result of the course you will acquire fundamental programming skills that will enable you to take more advanced courses in the future. 
It is recommended to combine the course with the [[GMU:eval(nature)|eval(nature) module]]. 

== Beschreibung ==

''Das Internet der Dinge erobert die sozialen Netzwerke.'' 
''Im Augenblick entwickelt sich ein vielfältiges Ökosystem sozialer Bots.'' 
''Die Bots decken ein weites Spektrum ab, vom Praktischen, über Poetisches bis hin zum Philosophischen.'' 
''Und sie fangen an miteinander zu kommunizieren...'' 

In ''Malen nach 0 und 1'' werden wir kleine Roboter erschaffen, die kritzeln und brabbeln. 
Unsere Roboter bestehen aus Nullen und Einsen, aber wir werden auch lernen sie mit der materiellen Welt zu verbinden, wobei Kameras, Töne und Kabel zum Einsatz kommen. 

Im Rahmen des Moduls werdet ihr:

* Programmieren mit Python lernen
* Grafik und Text verarbeiten
* Generative Grafiken und Gedichte erzeugen
* APIs für Soziale Netzwerke nutzen, inkl. Twitter und Mediawiki
* Eigene Software-Bots entwickeln und sie dazu bringen miteinander zu reden.

Dieses Modul erfordert keine Programmierkentnisse.

Im Rahmen des Kurses werden grundlegende Programmierkentnisse vermittelt, die es ermöglichen in Zukunft fortgeschrittene Kurse zu belegen. 
Es wird empfohlen diesen Kurs mit dem Projekt-Modul [[GMU:eval(nature)|eval(nature)]] zu kombinieren.

== Language ==

The course will be in English, unless all participants are speaking German.

== Eligible Participants ==

Undergraduates and graduates enrolled in the faculties of:

* Media Art/Design
* Visual Communication

== Requirements ==

* Burning Interest in Artificial Intelligence, Computer-Linguistics and Generative Design
* Previous course about the Internet of Things highly recommended
* Working knowledge of Web Technologies (HTML, CSS, Javascript ...)
* Time and Devotion for lots of coding homework, which may be frustrating at times
* Programming experience considered helpful

== Application ==

The deadline to apply for this course is April 13th, 2015

You need to provide links to previous work to be elligible to this course.

'''To:''' [[User:ms|Martin Schneider]] 
'''Subject:''' Bots n Plots /// Application 
'''Content:'''

# Please provide links to three of your visual, poetic or algorithmic works online.
# Please answer these questions:
#* What is your favourite bot on twitter?
#* What kind of bot would you like to be able to create at the end of the course?
# Please tell us about you:
#* program and semester (Studienprogramm und Fachsemester)
#* matriculation number (Matrikelnummer)
#* Valid email address @uni-weimar.de (no other mailing addresses will be accepted) [[SCC-Services#E-Mail|Why?]]

== Schedule ==

This is the outline of the course.
The details may still be subject to change.

{| class="wikitable"
|-
! Theme !! Topic !! Date
|-
| rowspan="2" | [[/Part1|Part 1: Python]]
| 01: Programming I
| 15. April 2015
|-
| 02: Programming II
| 22. April 2015
|-
| rowspan="4" | [[/Part2|Part 2: Plotter Bots]]
| 03: Drawing and Plotting I
| 29. April 2015
|-
| 04: Drawing and Plotting II
| 06. May 2015
|-
| 05: Image Processing I
| 13. May 2015
|-
| 06: Image Processing II
| 20. May 2015
|-
| rowspan="3" | [[/Part3|Part 3: Chatter Bots]]
| 07: Language Processing I
| 27. May 2015
|-
| 08: Language Processing II
| 03. June 2015
|-
| 09: Generating Poetry
| 10. June 2015
|-
| rowspan="4" | [[/Part4|Part 4: Social Bots]]
| 10: Twitter Bots I
| 17. June 2015
|-
| 11: Twitter Bots II
| 24. June 2015
|-
| 12: Wiki Bots I
| 01. July 2015
|-
| 13: Wiki Bots II
| 08. July 2015
|}

== Evaluation ==

* Presence and active participation (required)
* Punctual and complete submission of homework (required)

* 50% Technical and aesthetic execution of the final bot project
* 20% Emergent behaviour from making the robots talk
* 20% Documentation of the final project
* 10% Contribution to the MediaWiki

== Participants ==

* [[GMU:Bots_'n'_Plots/Sebastian Stang|Sebastian Stang]]
* [[GMU:Bots_'n'_Plots/Maria Degand|Maria Degand]]
* [[GMU:Bots_'n'_Plots/Klaus Kraemer|Klaus Kraemer]]
* [[GMU:Bots_'n'_Plots/Angelica Sohn|Angelica Sohn]]
* [[GMU:Bots_'n'_Plots/Luis Hurtarte|Luis Hurtarte]]
* [[GMU:Bots_'n'_Plots/Apasri Titatarn|Apasri Titatarn]]
* [[GMU:Bots_'n'_Plots/Jan Dropmann|Jan Dropmann]]
* [[GMU:Bots_'n'_Plots/Azucena Sanchez|Azucena Sanchez]]
* [[GMU:Bots_'n'_Plots/Natalia Martínez|Natalia Martínez]]
* [[GMU:Bots_'n'_Plots/smin kim|Smin Kim]]
* [[GMU:Bots_'n'_Plots/minsoo hwang|minsoo Hwang]]
* [[GMU:Bots_'n'_Plots/Christopher Marx|Christopher Marx]]
* [[GMU:Bots_'n'_Plots/Shubhra Bhatt|Shubhra Bhatt]]
* [[GMU:Bots_'n'_Plots/Constantin Oestreich|Constantin Oestreich]]

== Links ==

Here are a couple of links that should give you an idea of where this course is heading ...

=== Learning Python ===
* [http://www.codecademy.com/en/tracks/python Learn Python] at Code Academy
* [http://www.diveintopython3.net Dive Into Python 3]

=== Image Processing ===
* [http://software-carpentry.org/v4/media/ Multimedia Programming] by Software Carpentry
=== Video Processing ===
* [https://zulko.github.io/moviepy/ MoviePy] by Zulko
* [https://zulko.github.io/blog/2014/09/20/vector-animations-with-python/ Vector Animations with Python]
=== Language Processing ===
* [http://h6o6.com/2013/03/using-python-and-the-nltk-to-find-haikus-in-the-public-twitter-stream/ Using Python and the NLTK to find Haikus in the public twitter stream]
* [http://dhconnelly.com/paip-python/docs/paip/eliza.html Eliza.py]
=== Twitter ===
* [https://zulko.github.io/blog/2014/07/26/a-tweets-controlled-python-script/|A Python Script controlled via Twitter]

== Literature ==
* Bird, Steven: ''Natural Language Processing with Python'' ISBN 978-0596516499 ([http://www.nltk.org/book/ online])
* Lobin, Hennig:''Computerlinguistik und Texttechnologie'' ISBN 978-3825232825
* Russel, Mathew: ''Mining the Social Web'' ISBN 978-1449367619
* Segaran, Toby'': Programming Collective Intelligence'' ISBN 978-0596529321

=== Python ===
This is a list of recommended books for the Python language: 


* Beazley, David: ''Python Cookbook'' ISBN 978-1449340377
* Blum, Richard: ''Python Programming for Raspberry Pi'' ISBN 978-0789752055
* Chan, Jamie: ''Learn Python in One Day and Learn it Well'' ISBN 978-1506094380
* Zelle, John: ''Python Programming: An Introduction to Computer Science'' ISBN 978-1590282410 ([http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.111.6062 online])

=== Further Reading ===
There are a couple of books in the Semesterapparat of [[Society of Networked Things]], that you might want to flip trough.

[[Category:SS15]]
[[Category:Werkmodul]]
[[Category:Fachmodul]]
[[Category:Martin Schneider]]
[[Category:Python]]
[[Category:Gestaltung]]
[[Category:Design]]
[[Category:Poetry]]
[[Category:Generative Gestaltung]]
[[Category:Robots]]