Die zwei Bugs die behoben wurden, verbessern die Qualität der Antworten, dafür muss allerdings die Konfiguration angepasst werden. Am besten den Wortfilter und die Einstellungen aus der neuen Datei nochmal in die veraltete Datei kopieren, dann müsste es passen. Zudem sollte das Problem, dass Twempy manchmal rumspamt ebenfalls behoben sein – ich musste um einen Bug in der Twitter API herumprogrammieren.

Wichtig: Die SQL Struktur einer Tabelle hat sich geändert, ein Patch von 0.3a auf 0.4a liegt bei und auch eine neuer Komplettabzug meiner Datenbank ist im neuen Archiv enthalten.

Und hier die aktuellen Quellen: http://www.codemonster.de/source/twempy_0.4a.rar (Lizenz: GPLv3)

Viel Spaß!

Die verbesserte Funktion berücksichtigt nun auch die Wortlängen und blendet mögliche Antworten, mit zu vielen Treffern bei kurzen Wörten aus, wenn eine bessere Antwort gefunden werden kann. Sollte die Funktion allerdings nichts passendes finden, dann wird wieder auf die alte unscharfe Funktion zurückgegriffen.

Und hier gibt es die aktuellen Quellen zum Download: http://www.codemonster.de/source/twempy_0.3a.rar (Lizenz: GPLv3)

Neu ist übrigens auch ein Ein- und Ausschaltbarer Debug Modus.

Die Installation wird in der Datei INSTALL.txt beschrieben, der Code ist ausreichend kommentiert. *hust*

Es hat sich inzwischen übrigens gezeigt, dass der Bot sehr viele Tweets lernen muss, um wirklich gute Antworten liefern zu können, und auch, dass bestimmte Worte besser nicht mit in die Suche nach einer Antwort mit einbezogen werden können. In einigen Bereichen bringt Twempy bereits jetzt treffende Ergebnisse, doch bis wirklich ein breites Spektrum an Themen abgedeckt werden können, wird vermutlich eine Antwort-Basis von wenigstens 20.000 Tweets oder noch mehr benötigt. Leider stoße ich mit dem Bot bereits jetzt oft an das Rate-Limit der Twitter API, ich muss dem Twitter Team wohl mal eine E-Mail schreiben.

Viel Spaß mit dem Bot. Wer Verbesserungsvorschläge hat, immer her damit!

CODE IS POETRY.

Und so funktioniert es: Twempy sucht alle 5 Minuten nach Tweets mit bestimmten Schlüsselwörtern wie “und, er, sie, das, …”. Findet er einen passenden Tweet, ermittelt der Bot, ob es eine Antwort auf einen anderen Tweet war. Ist dies der Fall wird die Ursprungnachricht geladen und die Wörter extrahiert. Die Wörter werden danach verknüfpt mit dem Antwort-Tweet in einer Datenbank gespeichert. So bildet sich eine Relation von Wörtern zu tweets. Das schöne dabei ist, das Twempy im Grunde jetzt Sprache lernen kann, denn seine Datenbasis wird nicht durch den Programmierer beeinflusst, sondern ausschließlich aus echten Konversationen gebildet.

Erhält Twempy eine @reply (mention), extrahiert er die Wörter und schlägt in der Datenbank nach, welche Antworten passen könnten. Gibt es mehrere gleichwertige Antwortmöglichkeiten, wird zufällig eine mögliche Antwort ausgewählt und getwittert. Ich hoffe, dass die Qualität der Antworten mit wachsender Datenbank besser wird.

Ein weiteres nettes Feature ist, dass beim Lernen die Tweets, die nicht an einen anderen Twitter-Account gerichtet waren ebenfalls in der Datenbank gespeichert werden. Von Zeit zu Zeit twittert Twempy zufällig einen dieser Tweets. Danach wird die Nachricht gelöscht, damit er auf keinen Fall zwei Mal das gleiche sagt.

Offen ist noch, ob ich dieses Verfahren auch auf die Antworten, die der Bot sendet anwenden sollte, so dass auch niemals zwei Mal die gleiche Antwort gesendet werden könnte. Twempy würde seinen Antworten damit wieder verlernen, was aber auch das Risiko birgt, dass er irgendwann keine Antworten mehr parat hat. Da bin ich noch unschlüssig.

Wenn der Quellcode ausgereift ist, werde ich ihn veröffentlichen, aber ich muss noch etwas abwarten. Einige Dinge sind noch unklar, zum Beispiel die Frage, ob die Datenbasis besser wird, wenn nur Anworten gespeichert werden, die einen Ursprungstweet als Auslöser hatten, der nicht selbst ebenfalls eine Antwort auf einen anderen Tweet war. Mir ist nämlich aufgefallen, dass diese mitten aus der Konversation gegriffenen Antworten teilweise in keinem logischn Zusammenhang zu den verwendeten Wörtern stehen.

Es wird noch einige Tests benötigen, warten wir mal ab…

Es ist jetzt erstmal nur ein Gedankenspiel, viel nachgedacht habe ich darüber noch nicht, aber könnte man die Twitter API nicht dazu nutzen einen Chat-Bot zu entwickeln, der aus Konversationen auf Twitter lernt? Nehmen wir doch mal eine wahllos ausgewählte Konversation aus meiner Timeline:

vjstephan: Sich selber mal für ein paar Stunden ohne Internetz und Handy in den Schnittraum einsperren wirkt wahre Wunder. #twitaly
motorradblogger: @vjstephan Oh darf man gespannt sein? #twitaly
vjstephan: @motorradblogger Wieso solltest du gespannt sein? Du warst doch dabei.
motorradblogger: @vjstephan Das ist so lang her. Hab schon wieder alles vergessen. ;-)

Ein Bot könnte über die Twitter API solche Konversationen suchen und bis zum Ursprung zurückverfolgen. Dafür wird in den Tweets extra eine “in reply to” ID gespeichert. Ist der Ursprungstweet gefunden, werden die einzelnen Wörter (ohne Links und Hashtags) herausgeschnitten und in einer Datenbank mit der Antwort (oder den Antworten) auf den Tweet verknüpft. Dieses Verfahren wird auf alle Tweets der Konversation angewendet.

Hat dieser Bot eine große Datenbasis angesammelt, könnte man ihm selbst einen Tweet schicken. Auch hier werden die einzelnen Wörter wieder ausgeschnitten und mit der Datenbank verglichen. Es ergeben sich dann aufgrund der Worthäufigkeit verschiedene Antwortmöglichkeiten, von denen die passenste, oder manchmal auch eine zufällige, als Antwort gesendet wird.

Das System würde von echten Konversationen lernen und möglicherweise würden die Antworten des Bots dadurch auch sehr echt wirken.

Ich werde das am Wochenende mal ausprobieren. Mal sehen was daraus wird. Vielleicht knackt so ein Bot ja endlich den Turing Test. ;-)

Einen Account und einen Namen hat der Bot jedenfalls schonmal: http://twitter.com/twempy

Also habe ich kurzerhand einen neuen Twitter-Account mit dem klangvollen Namen “@subversives” erstellt und ein kleines PHP-Skript geschrieben, dass neue Tweets mit einem #harley Hashtag sucht und eine zufällig ausgewählte Antwort erstellt. Natürlich konfigurierbar. :-)

Dazu gibt es zwei kleine Funktionen. Die erste Funktion sucht Tweets nach einem bestimmten Suchbegriff:

// Twitter search api
function twt_search( $username, $password, $search, $since_id = 0, $rpp = 30, $page = 1 )
{
	// Curl init
	$curl = curl_init();

	// Curl basic settings
	curl_setopt( $curl, CURLOPT_URL, 'http://search.twitter.com/search.json' );
	curl_setopt( $curl, CURLOPT_RETURNTRANSFER, 1 );
	curl_setopt( $curl, CURLOPT_USERPWD, "$username:$password" );
	curl_setopt( $curl, CURLOPT_POST, true );

	// Build POST parameters
	$post_arr = array();
	$post_arr[] = "q=" . urlencode( $search );
	if( !empty( $since_id ) )
		$post_arr[] = "since_id=" . $since_id;
	if( !empty( $rpp ) )
		$post_arr[] = "rpp=" . $rpp;
	if( !empty( $page ) )
		$post_arr[] = "page=" . $page;
	curl_setopt( $curl, CURLOPT_POSTFIELDS, implode( '&', $post_arr ) );

	// Exec, set return
	$return = json_decode( curl_exec( $curl ) );

	// Close curl
	curl_close( $curl );

	return $return;
}

Übergeben werden Benutzername, Passwort, der Suchbegriff und – wenn bekannt – auch die “since_id”, welche es ermöglicht nur Tweets mit einer höheren ID zu ermitteln. Das ist für unser lustiges Protest-Skript wichtig, denn wir wollen die Leute ja nicht zuspammen und immer wieder auf die gleichen Tweets antworten. Nur neue Tweets seit der letzten Suche sollen berücksichtigt werden, also merken wir uns einfach die höchste Tweet ID und übergeben diese wieder bei der nächsten Suche. Der Parameter “rpp” steht übrigens für “results per page” – mit der Voreinstellung werden also maximal 30 Tweets zurückgegeben.

Technisch wird die Abfrage über die CURL-Bibliothek realisiert, theoretisch ginge es aber auch mit “file_get_contents” oder “fopen”, aber ich mag CURL. Ist ganz praktisch.

Die zweite benötigte Funktion erstellt über die Twitter API einen neuen Tweet. Auch hier stehen wieder einige Parameter zur Verfügung:

// Twitter update api
function twt_update( $username, $password, $status, $in_reply_to_status_id = '', $lat = '', $long = '' )
{
	// Curl init
	$curl = curl_init();

	// Curl basic settings
	curl_setopt( $curl, CURLOPT_URL, 'http://twitter.com/statuses/update.json' );
	curl_setopt( $curl, CURLOPT_RETURNTRANSFER, 1 );
	curl_setopt( $curl, CURLOPT_USERPWD, "$username:$password" );
	curl_setopt( $curl, CURLOPT_POST, true );

	// Build POST parameters
	$post_arr = array();
	$post_arr[] = "status=" . urlencode( $status );
	if( !empty( $in_reply_to_status_id ) )
		$post_arr[] = "in_reply_to_status_id=" . $in_reply_to_status_id;
	if( !empty( $lat ) )
		$post_arr[] = "lat=" . $lat;
	if( !empty( $long ) )
		$post_arr[] = "long=" . $long;
	curl_setopt( $curl, CURLOPT_POSTFIELDS, implode( '&', $post_arr ) );

	// Exec, set return
	$return = json_decode( curl_exec( $curl ) );

	// Close curl
	curl_close( $curl );

	return $return;
}

Neben Nutzername und Passwort können an diese Funktion der Statustext (Tweet) und der sehr wichtige Parameter “in_reply_to_status_id” übergeben werden. Wird die ID eines Tweets mit diesem Parameter übergeben, erkennt Twitter, dass es sich um eine @rely zu dem Tweet mit der übergebenen ID handelt. Da wir ja Antworten senden wollen, genau das richtige! Die Parameter “lat” und “long” sind übrigens nur schmückendes Beiwerk und werden von mir nicht genutzt. Ich habe das nur der Vollständigkeit halber mit rein genommen.

Nun zur Anwendung der Funktionen:

// Twitter account settings
$username = 'user';
$password = 'pass';

// Configure some reply variations in english and german
$replys_en = array(
	'Always remember #BUELL if you talk about Harley Davidson!',
	'Hey, remember #BUELL if you talk about Harley Davidson!',
	'Remember #BUELL FOREVER! Harley Davidson? NEVER!',
	'It makes me sick, that you dont talk about #BUELL ;-)',
	'#BUELL #BUELL #BUELL remember the Harley Davidson #FAIL',
	'#BUELL killed by Harley Davidson in 2k9. Remember that!',
	'#BUELL will never die. Harley Davidson will.'
);
$replys_de = array(
	'Erinner dich an #BUELL wenn du über Harley Davidson sprichst!',
	'Harley Davidson? Die Firma, die #BUELL zerstört hat?',
	'#BUELL FOREVER! Harley Davidson? NEVER!',
	'Es macht mich krank, dass nicht auch über #BUELL sprichst!',
	'#BUELL #BUELL #BUELL denk an den Harley Davidson #FAIL',
	'#BUELL wurde von Harley Davidson 2k9 geschlossen. HD is next!',
	'#BUELL wird niemals sterben, aber Harley Davidson. #Rentnerchopper'
);

// Load last parsed tweet id
if( file_exists( 'harley_since_id.dat' ) )
	$harley_since_id = file_get_contents( 'harley_since_id.dat' );
else
	$harley_since_id = 0;

// Search for tag harley
$harley = twt_search( $username, $password, '#harley', $harley_since_id );
if( is_object( $harley ) )
{
	if( count( $harley -> results ) )
	{
		foreach( $harley -> results AS $rkey => $tweet )
		{
			// Descending order, so the first array element has the highest id!
			if( $rkey == 0 )
				$harley_since_id = $tweet -> id;
			// Only reply if buell not found
			if( stripos( $tweet -> text, 'buell' ) === false && $tweet -> from_user != $username )
			{
				if( $tweet -> iso_language_code != 'de' )
					$reply = "@{$tweet->from_user} " . $replys_en[ array_rand( $replys_en ) ];
				else
					$reply = "@{$tweet->from_user} " . $replys_de[ array_rand( $replys_de ) ];

				echo "$reply\n";

				// Send reply
				twt_update( $username, $password, $reply, $tweet -> id );
			}
		}
	}
	else	echo "No new tweets to tag #harley\n";
}

// Store last parsed tweet id
file_put_contents( 'harley_since_id.dat', $harley_since_id );

Zuerst werden in zwei Arrays englische bzw. deutsche Ausdrücke des Protests definiert, danach wird aus einer kleinen Datendatei die ID des letzten gefundenen Tweets geladen und die Suche ausgeführt.
Die Suchfunktion gibt ein Objekt zurück, dass in der Eigenschaft “results” die gefundenen Tweets als Array enthält, welches anschließend durchlaufen wird. Beim ersten gefundenen Tweet wird die “since_id” neu gesetzt. Warum beim ersten? Na, weil die Tweets absteigend sortiert sind – der Erste ist also immer der Aktuellste.
Enthält der Tweet nicht das Wort “buell”, wird in der entsprechenden Sprache (deutsch oder englisch) eine @reply an den Twitter-Account des Tweets gesendet.

Tja, das war’s eigentlich schon. Wer es mal probieren und einen Spruch reingedrückt bekommen will, der zwitschert einfach mal was mit dem Hashtag #harley – es dauert allerdings ein wenig, bis die Antwort kommt, das Skript läuft nur alle 15 Minuten.

Ich bin gespannt, wie lange der Account aktiv ist, ohne als Spam gemeldet zu werden. ;-)

Eine simple Google Suche hebelt den Schutzmechanismus von Twitter aus: “site:http://twitter.com/geschuetzter_account” (Beispiel). Offenbar erlaubt Twitter dem GoogleBot den Zugriff auch auf geschützte Tweets und da die Nachrichten nur 140-Zeichen lang sind, können diese über die Suchergebnisliste der Suchmaschine prima – oder gleich komplett über den Google Cache – gelesen werden.

Und nein, die Daten sind meiner Erkenntnis nach nicht im Index gelandet, weil der Twitter-Account zwischenzeitlich nicht geschützt war, es sind auch Tweets aus diesem Monat zu finden.

Das ist irgendwie… hmmm… #FAIL!

[Update]

Laut Aussage eines Freundes ist es doch keine Sicherheitslücke, Accounts die immer geschützt waren, können auch nicht über den Google-Cache oder die Suche aufgerufen werden. Scheinbar war der von mir gefundene Account dann doch zwischenzeitlich nicht geschützt. Verifiziert habe ich das noch nicht.

An der Problematik, dass die Tweets, wenn der Account erst nachträglich geschützt wurde, über Google weiterhin abrufbar sind, ändert das allerdings nichts. Aber das ist ja schon ein recht altes Problem. Was einmal versehentlich öffentlich publiziert wurde, ist aus dem Netz schwer wieder zu entfernen.

Einfach im Browser oder RSS Reader eine dem folgenden Format entsprechende URL eingeben:

http://api.twitter.com/1/ACCOUTNAME/lists/LISTENNAME/statuses.atom

Wobei “ACCOUNTNAME” durch den Twitternamen z.B. “motorradblogger” zu ersetzen ist. Das gleiche gilt natürlich für “LISTENNAME“.

Zum Beispiel so: Meine Liste von Motorradbloggern.

Die Funktion ist zwar nicht perfekt, mir reichte sie jedoch.

<?php
function get_friends( $screen_name, $page_limit = 200 )
{
	$screen_names = array();
	for( $page = 1; $page < $page_limit; $page++ )
	{
		ob_start();
		$friends_json = file_get_contents( 'http://twitter.com/statuses/friends.json?screen_name=' . $screen_name . '&page=' . $page );
		$errors = ob_get_contents();
		ob_end_clean();
		if( $friends_json !== false )
		{
			$friends = json_decode( $friends_json );
			if( is_array( $friends ) && count( $friends ) )
			{
				foreach( $friends AS $friend )
					$screen_names[ $friend -> id ] = $friend -> screen_name;
			}
			else
			if( !count( $friends ) )
			{
				break;
			}
			else
			{
				$screen_names = array();
				break;
			}
		}
		else	break;
	}
	if( count( $screen_names ) || $errors == '' )
	{
		return $screen_names;
	}
	else
	{
		if( strpos( $errors, '401 Unauthorized' ) !== false )
			return false;
		else
			return null;
	}
}

// Example usage
print_r( get_friends( 'motorradblogger' ) );
?>

Schade übrigens, dass die Anzahl der Requests pro Stunde bei Twitter limitiert ist, sonst ließen sich ziemlich schnell, ziemlich viele Twitter-Accounts crawlen. ;-)

Die Benutzung ist sehr simpel: Einfach den Accountnamen übergeben, die Funktion läd Seitenweise alle Accounts, denen gefolgt wird und gibt diese in einem assoziativen Array (Schlüssel: Account-ID, Wert: Accountname) zurück. Im Falle eines Fehlers wird ‘false’ zurückgegeben, bei einem unbekannten Fehler ‘null’.