The first thing we will need to do is create a custom widget from forms.Textarea found in the django.forms module. We accomplish this by inheriting the Textarea class and overriding the constructor and render methods. Defining the relative path (on your web server) to the TInyMCE javascript source is also required here. So be aware that you will need to change that path to suite your environment. You may also want to change the content_css variable to include your sites’ main CSS file. The following is the source code for widgets.py which should be place in your projects root directory.

from django import forms
from django.conf import settings
from django.utils.safestring import mark_safe
 
class AdvancedEditor(forms.Textarea):
	class Media:
		js = ('/images/tiny_mce/tiny_mce.js',)
 
	def __init__(self, language=None, attrs=None):
		self.language = language or settings.LANGUAGE_CODE[:2]
		self.attrs = {'class': 'advancededitor'}
		if attrs: self.attrs.update(attrs)
		super(AdvancedEditor, self).__init__(attrs)
 
	def render(self, name, value, attrs=None):
		rendered = super(AdvancedEditor, self).render(name, value, attrs)
		return rendered + mark_safe(u'''
		<script type="text/javascript">
		tinyMCE.init({
			mode: "textareas",
			theme: "advanced",
			plugins: "advhr,table,emotions,media,insertdatetime,directionality",
			theme_advanced_toolbar_align: "left",
			theme_advanced_toolbar_location: "top",
			theme_advanced_buttons1:"bold,italic,underline,strikethrough,sub,sup,separator,justifyleft,justifycenter,justifyright,justifyfull,separator,formatselect,fontselect,fontsizeselect",
			theme_advanced_buttons2:"bullist,numlist,outdent,indent,ltr,rtl,separator,link,unlink,anchor,image,separator,table,insertdate,inserttime,advhr,emotions,media,charmap,separator,undo,redo",
			theme_advanced_buttons3: "",
			content_css: "images/style.css",
			height: "350px",
			width: "653px"
		});
		</script>''')

Now we need to create our form which enables us to use the new widget. Just as an example, we will make a form for use in the Django admin control panel: to show how to use the widget in model admin classes. We simply create  a standard ModelForm class as normal, except that the field you wish to use as your WYWISWYG editor must be a CharField. In my example, I create a simple form for use in the Django admin control panel to allow users to write news articles with advanced editing capabilities. You can do this for any class within any of your forms.py files in either the projects’ main directory or within an application directory. The code is as follows:

from django import forms
from django.db.models import get_model
from django.contrib.auth.models import User
from sodclan.widgets import AdvancedEditor
from sodclan.models import Article
 
class ArticleModelAdminForm(forms.ModelForm):
	title = forms.CharField(max_length=50)
	author = forms.ModelChoiceField(queryset=User.objects.all())
	content = forms.CharField(widget=AdvancedEditor())
 
	class Meta:
		model = Article

As you can see, we imported the AdvancedEditor class we created earlier including the Article class which represents the model we wish to associate the form with. Notice the widget for the content field has been set to AdvancedEditor(). Now we can modify our ModelAdmin class to utilize our form and thus allow us to use TinyMCE within the Django admin control panel. In my admin.py file, the code is as follows:

from django.contrib import admin
from sodclan.forms import ArticleModelAdminForm
from sodclan.models import *
 
class ArticleAdmin(admin.ModelAdmin):
	list_display = ('title', 'author', 'date',)
	search_fields = ['title',]
	date_hierarchy = 'date'
	form = ArticleModelAdminForm
 
admin.site.register(Article, ArticleAdmin)

Here we import the model admin form we created in the last code segment. The only difference here from a normal ModelAdmin class is that we define the form field. We set this field to our form class, in this case: ArticleModelAdminForm. When finally run, the result will look something like this:

Remember that we used an example using the Django admin control panel just to show how to do it. But you can take this concept and apply it anywhere in your Django web application where you can utilize forms. Which allows you to make very rich, usable web applications very easily. Hope this helps, comment with any questions or remarks.

We will start by importing the python socket module and creating a UDP connection to the server.

import socket
 
if __name__ == "__main__":
   sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
 
   # Connect to CoD4 server at 8.9.17.24:28960
   # Will also work for most other games in a similar fasion
   sock.connect(("8.9.17.24", 28960))

Now that we have established a connection with the game server, we may now start sending it rcon commands. Just remember that the protocol requires that you have a packet header of 0xFF0xFF0xFF0xFFrcon password where the password is replaced with your rcon password. You can then follow the packet header by the command you wish to run on the server. In this example we are simply going to print the server status.

	sock.send("\xFF\xFF\xFF\xFFrcon xxxxxxxxxx status")
	print sock.recv(65565)

Which will display a result similar to this:

����print
map: mp_broadcast
num score ping guid name lastmsg address qport rate
— —– —- ——————————– ————— ——- ——————— —– —–
0 262 137 666a7a82ac0897a213a3a220a1f59893 [0.o]BlameTruth^7 50 80.73.221.70:-8128 31736 25000
1 42 160 42e130756a877c36f71b4f25a96e07cd luluno^7 50 84.195.170.81:-2965 -30455 25000
2 52 36 829a446fd0b0d79f52d8adab5bbbe343 Zack^7 50 173.24.37.249:28960 22992 25000
3 642 31 d3aa0bf47f9c1734b2f7b21089ccafb9 Outlaw^7 0 76.228.193.186:28960 -11398 25000
4 142 110 c53129735bd532ada06d00289e7d609b Hasenpflug^7 50 24.7.31.6:28960 -5755 25000
5 392 96 f44087b315b41f77be8176664e4241f5 [KoS]Karma^7 50 76.14.127.157:28960 5397 25000
6 40 52 4dc7f80bea865494032e4dd782adac8d I Sketchy I^7 0 173.30.206.39:28960 -393 25000
7 0 152 f6aa1b9d5a9865b80e756f43674807e9 fRoz1n1^7 50 99.29.116.44:28960 -17501 25000
8 180 256 79ebdaf076b3301a7c2b95e109ca87d0 REBORN YEH^7 0 58.170.56.2:28960 23402 25000

Finally all you have to do is close the connection with sock.close() and the entirety of the code will look something like this:

import socket
 
if __name__ == "__main__":
	sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
 
	# Connect to CoD4 server at 8.9.17.24:28960
	# Will also work for most other games in a similar fasion
	sock.connect(("8.9.17.24", 28960))
	sock.send("\xFF\xFF\xFF\xFFrcon xxxxxxxxxx status")
	print sock.recv(65565)
	sock.close()

As noted, the Rcon protocol is extremely simple and its up to you to think of how you can use Rcon bots to improve the quality and functionality of your game servers. Just remember that you do not have to sock.recv() data from the server every time to send data and remember that the server may send data in chunks in which case you may not receive everything you need in one transmission. But overall its as simple as shown in this tutorial.

You will need two components in order to make this work: the first being QJoyPad to bind controller buttons to keys, and JoyMouse to use one of the joysticks on the controller to control the mouse. Also remember that I am only using the USB cable to use the controller rather than using it via Bluetooth. I will post directions for using Bluetooth and the accelerometers in the controller at a later date, if I am able to get a hold of a Bluetooth adapter. Nevertheless, the tools are the same.

Because QJoyPad is currently unmaintained, and the packages available from their site are out of date; we will need to compile from source. The first thing we need to do is install dependencies:

sudo apt-get install libqt3-mt-dev libxtst-dev

Then download the tarball from here, extract it, and compile as usual.

cd ~/Desktop/qjoypad-3.4.1/src
make
sudo make install

Before we can get started with QJoyPad; we need to first plug in the controller and make sure that it’s being recognized by Linux. First make sure that your PlayStation 3 is completely turned off (via the switch in the back). Then plug the one end of the USB cable into the computer, but leave it unplugged from the controller. Hit the PS button to activate the controller and the red LED’s on the top will start to blink. Now plug the USB cable into the controller and verify that it has been recognized.

maddog39@desktop:~$ ls -a /dev/input | grep js
js0

Though take note to the device name of the controller (/dev/input/js0 in my case) as we will need to use this later. Now we can start to configure the buttons on the controller and assign them to keyboard keystrokes. When you launch QJoyPad (via the qjoypad command as no Applications menu item is provided), click on it’s tray icon and the button editor will appear.

The first thing you will want to do is create a new layout. Simply click Add at the top of the window and enter a label for your layout. You can see which controller buttons correspond to buttons in QJoyPad by pressing or holding the button you want to modify as it will appear highlighted in blue when its activated. To assign a keypress to any button or axis, click the button or axis you want to modify and a dialog will appear, then click [NO KEY] and hit the key you want to assign.

In order to be able to use either of the PS3 controller’s joysticks as mice, we need to install JoyMouse which can be downloaded here. Its a really simple program and as far as I know it doesnt have any dependencies so you should be good with a standard build. Extract the tarball to your desktop and open a terminal in the JoyMouse directory.

cd ~/Desktop/joymouse-0.5
./configure
make
sudo make install

Once JoyMouse is installed, we need to modify our xorg.conf to add a new pointer device.

sudo nano /etc/X11/xorg.conf

Now go to the end of the file and you will want to insert the following lines.

Section "InputDevice"
        Identifier   "Joystick"
        Driver       "mouse"
        Option      "Protocol"     "ExplorerPS/2"
        Option      "Device"     "/dev/joymouse"
        Option      "SendCoreEvents"     "true"
        Option      "ZAxisMapping"    "4 5 6 7"
EndSection

Then go back up to the “ServerLayout” section of the file and in that section under your mouse input device, insert the following line.

InputDevice "Joystick"

When your finished, Ctrl+O, Enter, then Ctrl+X to save and exit. Now heres the thing; in order for this to work we need to create a pipe using the mkfifo command, but it needs to always be there for JoyMouse to work. The problem is that these pipes are not retained over reboots: meaning that you have to recreate them everytime you want to use JoyMouse. I have also read that if the pip does not exist, it may cause Xorg to fail to start. I have yet to find a good solution to this problem, but for now manual will have to do.

sudo mkfifo -m 0777 /dev/joymouse

Running the JoyMouse program is fairly simple, just keep in mind that when you assign axes, they are always in order. So for example, if you wanted to use the right joystick as your mouse you would use the following.

joymouse -M - -M - -M x -M y

We ignored (using a dash) the first two axes as those are left/right and up/down for the left joystick and assigned X and Y to the left/right and up/down on the right joystick respectively. However, if you wanted to use the left joystick as the mouse, the command would read like this.

joymouse -M x -M y

If you would like, you could add this joymouse command to your GNOME (or whatever desktop environment you prefer) startup programs. In GNOME this would be: System > Preferences > Sessions > Startup Programs. But as mentioned earlier, remember that you need the /dev/joymouse pipe to exist first. After that, your done. Test out the controller with several different games and or applications and tweak the settings to your liking.

For those of you who don’t know what SETI@Home optimizers are, they are essentially specialized versions of the standard version of the SETI@Home client which take advantage of extended floating-point instruction sets available to certain x86 (Intel, AMD, or the like) processors. Using these instruction sets allows optimized clients to complete work many times faster than it could before with the standard client. For example, prior to using an SSSE3 optimized client on my Intel Core 2 Quad Q6600 my recent average credit (RAC) on SETI was in the 500 range including one other active machine and now my RAC has spiked over 2,500 not including the other active machine.

Before we get started, you should make sure that all other active work units you have running are completed before replacing the standard client with an optimized one. Then you may choose which optimize client you will run. Keep in mind that currently, only Intel Core 2 based CPUs and a single VIA CPU are capable of running SSSE3 instructions. For more details on this you should refer to the SSSE3 wikipedia page. Otherwise, you will likely be able to run an SSE3 optimized client, unless your CPU is more than several years old, also refer to wikipedia for more information on this. If you’ve got an even older CPU, there are also clients for MMX, SSE, and SSE2.

Optionally you may check which instruction sets are supported by your CPU using the following command:

[maddog39@desktop ~]$ cat /proc/cpuinfo | grep flags | tail -n 1
flags		: fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe nx lm constant_tsc arch_perfmon pebs bts pni monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr lahf_lm

First thing we want to do is download the client for your respective CPU and kernel version (most likely SSE3 or SSSE3 and kernel 2.6) from this page and extract the tarball. If your using an older CPU requiring an older instruction set, see this page instead.

Before we actually drop in the optimized client, its probably best to suspend the SETI@Home project in BOINC for safe measure.

Now we get to physically install our new SETI@Home optimizer. In the folder you extracted from the tarball, you should find a binary (executable) and an app_info.xml file, either in the folder’s top directory or in a subsequent sub-folder.

You want to copy these files and launch nautilus (or your file manager of choice) as root and point it to the /var/lib/boinc folder. Hit Alt+F2 to bring up a run dialog and enter the command:

gksudo nautilus /var/lib/boinc/projects/setiathome.berkeley.edu

Paste the optimizer files into the directory and when comes up. Finally, you will need to restart the BOINC daemon. On my distribution, Arch Linux its:

sudo /etc/rc.d/boinc restart

Although if you are using Ubuntu, Debian, or a derivative its:

sudo /etc/init.d/boinc restart

Then, to start using your new SETI optimized client, you simply launch BOINC manager and resume the SETI@Home project. It should start downloading new workunits immediatley and your in business. I hope you found this article useful and keep in mind that I tried to keep it as easy as possible for the newer Linux users out there.

Download QOverclock 0.1

Download QOverclock 0.1 (Win32 Binary)

Basically you just stick the file in your home directory (or at your option in /usr/bin or /usr/local/bin) and add it to your auto-started applications in GNOME or KDE or put it in your xinitrc or whatever you want. For GNOME users I happen to know that you can do this from System > Preferences > Sessions > Startup Programs > Add. For windows users this script will never run because Banshee is *nix only as well as DBus (as far as I know). Enjoy!

Download pidgin_banshee_status.py

Now all we have to do is make a connection to Banshee via DBus and start calling methods. For this we will just use an interactive python interpreter which can be accessed by simply typing “python” at any command line prompt. Firstly, we will import the DBuslibrary.

import dbus

Next, we will make a connection to the session bus.

bus = dbus.SessionBus()

Then we will get Banshee’s PlayerEngine object which will let us control the player itself (Play, Pause, Next, Previous, Current Track, etc).

banshee = bus.get_object("org.bansheeproject.Banshee", "/org/bansheeproject/Banshee/PlayerEngine")

The first argument we pass, “org.bansheeproject.Banshee”, is the interface we want to connect to and “/org/bansheeproject/Banshee/PlayerEngine” is the path to the object that we want to use. Now we can start doing stuff with Banshee. You can pretty much take any of the methods listed in D-Feet and run them. For example:

banshee.Open("file:///home/maddog39/Music/Eisbrecher - Antikörper.mp3")

And to play the song…

banshee.Play()

Once you have had enough….

banshee.Pause()

Although note that you dont have to using the Open() method to use the Play() and Pause() methods, but Open() lets you open an arbitrary media file otherwise those other methods use the currently playing track. Now, to access properties you generally just take the name of the property and prepend ‘Get’ to it and make it a method. So for example:

banshee.GetCanPause()

Returns:

dbus.Boolean(False)

Or if we wanted to display all the information about the currently playing track we might do…

for key in currentTrack.keys():
	print key + ": " + str(currentTrack[key])

Which gives us:

album: Issues
rating: 0
name: Falling Away From Me
artist: Korn
URI: file:///home/maddog39/Music/Korn%20-%20Beating%20Me%20Down.mp3
length: 271.211
disc: 0
track-count: 16
year: 1999
track-number: 2

Another cool thing you can do with DBus is receive signals. What this allows us to do is run code when a given signal is triggered or received. We do this by connecting a python method with a signal on our bus. So if we wanted to do something every time Banshee changes its state (playing, paused, loading, loaded, etc) this is what would happen. We would first have to setup a main loop as it is required for a signals to function.

import gobject
from dbus.mainloop.glib import DBusGMainLoop
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)

Then we would create a callback method which would be run every time the signal is triggered.

def stateChanged(state):
	print "State Changed: %s" % state

Now we can add our signal receiver to our method.

bus.add_signal_receiver(stateChanged,
dbus_interface="org.bansheeproject.Banshee.PlayerEngine",
                        signal_name="StateChanged")

Finally, at the end of a script that uses signals we would want to run our main loop.

gobject.MainLoop().run()

Well thats pretty much it! Just keep in mind that this was not intended to be a tutorial but merely a guideline on how to do interact and do things with Banshee over DBus. So feel free to sit down and write some of your own scripts based on what you have learned here and I hope this helps. I have already written my own program to integrate Banshee into another application which I will talk about in another article. Enjoy!

So this is a simple little tutorial on how to write a basic “Hello World” bot using PyBotlib. The library itself is only a single file so I have not bothered to repackage it or write setup scripts as you will only need import that single file within your application. You may get the latest source code for the library at any time here (google code/SVN) or here (blog). So here we go…

Lets start by defining our bot class and its constructor.

import botlib
 
# Create a new class for our bot, extending the Bot class from botlib
class HelloWorldBot(botlib.Bot):
    def __init__(self, server, channel, nick, password=None):
        botlib.Bot.__init__(self, server, 6667, channel, nick)
 
        # Send nickserv password if available
        if password != None:
            self.protocol.privmsg("nickserv", "identify" % password)

Next we are going to want to override the __actions__ function of the Bot class which will handle all of our bots actions. This acts as essentially a main loop and is called infinitely until the bot is shutdown. In here we put code for our commands, responders, whatever other interaction with the IRC channel that we need.

    def __actions__(self):
        botlib.Bot.__actions__(self)
 
        # Create a Hello World responder/command
        if botlib.check_found(self.data, "!hello"):
            # Get the senders username
            username = self.get_username()
 
            # Send user a message in response
            self.protocol.privmsg(self.channel, "Hello %s!" % username)

So here, we have created a simple command called !hello which runs the code underneath its if statement when an instance of that command is found in the chat. Then we call the get_username() function of the Bot class (remember that we inherited from the Bot class) to get the user name of the person who initiated the command. After that, we simply send a message back to the channel using the equivalent function for IRC’s PRIVMSG command. Now all we to do is instantiate and run our new bot.

 if __name__ == "__main__":
    # Create new instance of our bot and run it
    HelloWorldBot("irc.wyldryde.org", "#maddog39", "HelloWorldBot").run()

Keep in mind that when you are instantiating Bot object, that because PyBotlib is entirely threaded, you can make as many instances of your bot as you would like. I do have a BotManager class in PyBotlib intended for managing sets of multiple bots on the same process however I have never actually tested it so your results may vary. Here is the script in its entirety.

import botlib
 
# Create a new class for our bot, extending the Bot class from botlib
class HelloWorldBot(botlib.Bot):
    def __init__(self, server, channel, nick, password=None):
        botlib.Bot.__init__(self, server, 6667, channel, nick)
 
        # Send nickserv password if availible
        if password != None:
            self.protocol.privmsg("nickserv", "identify" % password)
 
    def __actions__(self):
        botlib.Bot.__actions__(self)
 
        # Create a Hello World responder/command
        if botlib.check_found(self.data, "!hello"):
            # Get the senders username
            username = self.get_username()
 
            # Send user a message in response
            self.protocol.privmsg(self.channel, "Hello %s!" % username)
 
if __name__ == "__main__":
    # Create new instance of our bot and run it
    HelloWorldBot("irc.wyldryde.org", "#maddog39", "HelloWorldBot").run()

Finally, to run your new bot, simply issue the command:

python helloworldbot.py

At the terminal prompt or command prompt (windows). Also note that you must make sure that your botlib.py file is in the same directory as your bot. Have fun!

I realized that I had wasted several months of my time developing what I called a “framework” for PHP when it was really not very full featured and actually made things extremely hard for myself in the large scheme of things. After doing some homework, I had found really rich libraries that allowed me to do things beyond my wildest dreams before. Projects such as Smarty, jQuery, and TinyMCE just to name a few. What really gets me though is that many free (as in beer or potentially as in free speech) projects constantly fall behind because they take  forever to their own things such as rich text editors and ajax frameworks while their users are wondering why they don’t have the features they are looking for.

So  this is a call to all web developers out there. You really need to start reassessing  the libraries you write and think of how you could possibly use others’ great Open Source projects to assist you in the development of your application. Stop reinventing the wheel and start innovating, that’s what we are all about, right?

Download ProxyBot