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…

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. ;-)

Aber nun zur Definition von SOAP (Quelle: Wikipedia): SOAP (ursprünglich für Simple Object Access Protocol) ist ein Netzwerkprotokoll, mit dessen Hilfe Daten zwischen Systemen ausgetauscht und Remote Procedure Calls durchgeführt werden können. SOAP stützt sich auf andere Standards: XML zur Repräsentation der Daten und Internet-Protokolle der Transport- und Anwendungsschicht (vgl. TCP/IP-Referenzmodell) zur Übertragung der Nachrichten. Die gängigste Kombination ist SOAP über HTTP und TCP.

In der Praxis bedeutet das folgendes: In einer XML Datei (WSDL) werden Nachrichten-Typen definiert und an Operationen gebunden. Dabei gibt es Input-Nachrichten und Output-Nachrichten, sprich Übergaben und Rückgaben. Die WSDL Datei (WSDL = Web Services Description Language) wird dabei vom Client, als auch vom Server genutzt und regelt so die Kommunikation dieser beider Stellen.

Die Vorgehensweise um einen neuen Web-Service zu erstellen ist bei mir immer zuerst die WSDL zu erzeugen, danach die Operationen im Server abzubilden, um diese anschließend mit dem Client zu testen. Eine Beispiel WSDL könnte z.B. so aussehen:

<?xml version="1.0" encoding="UTF-8"?>
<definitions name="TheGeek"
	targetNamespace="http://thegeek.de/wp-soap/thegeek.wsdl"
	xmlns:tns="http://thegeek.de/wp-soap/thegeek.wsdl"
	xmlns="http://schemas.xmlsoap.org/wsdl/"
	xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
	xmlns:xsd="http://www.w3.org/2001/XMLSchema">

	<!-- GET LATEST POSTS -->
	<message name="RequestGetPostsIn">
		<part name="apikey" type="xsd:string"/>
		<part name="num" type="xsd:integer"/>
	</message>
	<message name="RequestGetPostsOut">
		<part name="returncode" type="xsd:integer"/>
		<part name="error" type="xsd:string"/>
		<part name="posts" type="xsd:struct"/>
		<part name="posts_count" type="xsd:integer"/>
	</message>
	<portType name="RequestGetPosts_PortType">
		<operation name="GetPosts">
			<input message="tns:RequestGetPostsIn"/>
			<output message="tns:RequestGetPostsOut"/>
		</operation>
	</portType>
	<binding name="GetPosts_Binding" type="tns:RequestGetPosts_PortType">
		<soap:binding style="rpc" transport="http://schemas.xmlsoap.org/soap/http"/>
		<operation name="GetPosts">
			<soap:operation soapAction="GetPosts"/>
			<input>
				<soap:body
					encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
					namespace="urn:thegeek-getpostsservice"
					use="encoded"/>
			</input>
			<output>
				<soap:body
					encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
					namespace="urn:thegeek-getpostsservice"
					use="encoded"/>
			</output>
		</operation>
	</binding>
	<service name="GetPosts_Service">
		<documentation>Return latest posts</documentation>
		<port binding="tns:GetPosts_Binding" name="GetPosts_Port">
			<soap:address location="http://thegeek.de/wp-soap/index.php"/>
		</port>
	</service>

</definitions>

Diese WSDL definiert eine einfache Funktion “GetPosts” mit einer eingehenden Nachricht und einer ausgehenden Nachricht. Für die einzelnen Felder der Nachrichten sind entsprechende Typen definiert. Nachdem die Nachrichten an die Operation “GetPosts” gebunden wurden, wird mit dieser Operation ein Soap-Service definiert. Ein Service besteht also aus einem Binding, welches wiederum aus eine Input- und/oder Output-Message besteht. Das klingt nun zugegeben ziemlich kompliziert, ist aber in der Praxis wirklich einfach nachzuvollziehen, wenn wir uns mal den Server-Quellcode zu dieser WSDL Definition ansehen.

<?php

// SOAP config array
$soap_config = array( 'encoding' => 'UTF-8' );

// Don't cache WSDL files, mandatory for development
ini_set( 'soap.wsdl_cache_enabled', '0' );

class thegeek_soapserver
{
	function __construct( $parameters )
	{

	}

	public function GetPosts( $apikey = '', $num = 10 )
	{
		if( $apikey == 'demoapikey' )
		{
			$posts = array( 	array( 'title' => 'Demo Post 1', 'body' => 'Demo content 1' ),
						array( 'title' => 'Demo Post 2', 'body' => 'Demo content 2' ),
						array( 'title' => 'Demo Post 3', 'body' => 'Demo content 3' ),
						array( 'title' => 'Demo Post 4', 'body' => 'Demo content 4' )
			);
			return array(	'return' => true,
					'error' => '',
					'posts' => $posts,
					'posts_count' => 0
			);
		}
		// API KEY FAIL
		else
		{
			return array(	'return' => false,
					'error' => 'API KEY INVALID',
					'posts' => array(),
					'posts_count' => 0
			);
		}
	}
}

// Run SOAP server
$soapserver = new SoapServer( 'http://thegeek.de/wp-soap/thegeek.wsdl', $soap_config );
$soapserver -> setClass( 'thegeek_soapserver', 'some parameters for the constructor (example only...)' );
$soapserver -> handle();

?>

Nachdem die Soap-Config für die PHP Klasse “SoapServer” definiert und das caching von WSDL Dateien per “ini_set” ausgeschaltet wurde, folgt unsere eigene Klasse, die den Web-Service abbildet. Der Konstruktor kann wie gewohnt definiert werden, auch beim Initialisieren unserer Klasse über die PHP Klasse “SoapServer”, können beliebige Parameter übergeben werden. Übrigens sind auch extends problemlos möglich.

Dann findet sich in der Klasse eine Methode, welche unseren SoapService “GetPosts” abbildet, als Übergabeparameter sind die Variablen unserer Input-Nachricht angegeben. Wie die Variablennamen in der Methode gewählt werden ist egal, aber die Methode muss genau so heißen, wie in der WSDL angegeben (soap:operation soapAction=”GetPosts”). Der Code in der Methode dient natürlich nur der Verdeutlichung, wie Rückgaben erfolgen, nämlich als assoziatives Array, welches die in der WSDL definierte Output-Nachricht abbildet.

Um unsere Server-Klasse dann zu initialisieren, wird die PHP Klasse “SoapServer” mit entsprechenden Parametern (Web-Pfad zur WSDL, SoapConfig) aufgerufen. Danach wird mit Hilfe der Methode “setClass” unsere Klasse als Handler ausgewählt und der Server letztendlich mit der Methode “handle” konstruiert.

Fehlt eigentlich nur noch ein kleiner Test-Client:

<?php

// Create new SOAP client
$soap_client = new SoapClient( 'http://thegeek.de/wp-soap/thegeek.wsdl', array( 'encoding' => 'UTF-8' ) );
if( is_object( $soap_client ) )
{
	$soap_result = $soap_client -> GetPosts( 'demoapikey', 10 );
	// Debug output
	echo "<pre>";
	print_r( $soap_result );
	echo "</pre>";
}
else	die( 'SOAP Server not available' );

?>

Der Client ist ziemlich problemlos umzusetzen: Einfach mit der PHP Klasse “SoapClient” ein Client-Objekt erzeugen (Web-Pfad zur WSDL übergeben) und die Methoden (= Operationen) wie in der WSDL definiert nutzen. Obiges Beispiel gibt folgendes aus:

Array
(
    [returncode] =>
    [error] =>
    [posts] => Array
        (
            [0] => Array
                (
                    [title] => Demo Post 1
                    [body] => Demo content 1
                )

            [1] => Array
                (
                    [title] => Demo Post 2
                    [body] => Demo content 2
                )

            [2] => Array
                (
                    [title] => Demo Post 3
                    [body] => Demo content 3
                )

            [3] => Array
                (
                    [title] => Demo Post 4
                    [body] => Demo content 4
                )

        )

    [posts_count] => 0
)

So schwierig ist das mit SOAP und PHP also nicht. Wichtig ist allerdings noch: PHP muss mit der Option “–enable-soap” kompiliert werden, um die SOAP Extension nutzen zu können. Alternativ kann aber auch das SOAP PEAR Paket genutzt oder auf die Klasse nuSoap zurückgegriffen werden.

Wer selbst mal von seinem Webspace aus testen will: http://thegeek.de/wp-soap/thegeek.wsdl

Wer Fragen hat: Comments are open.

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’.