You need to run ‘mvpybot.py 0′ because start.py is broken now. Substitute the zero with a different server number if you want to connect to a different server.

#!/usr/bin/python

def register():
 registerfunction('ping', ping)
 addhelp('ping', help_ping)

def ping():
 outstuff=''
 print "ping called"
 if (len(cmd)<2):
  return('PRIVMSG %s :Incorrect usage. Syntax: ping (4|6) <address>.' %(channel))
 else:
  if cmd[1]=='4' or cmd[1]=='6':
   if cmd[1]=='4':

    output=syscmd(['ping','-c','5','-i','0.2',cmd[2]])
    outsplit=output.split('\n')
    outparts=outsplit[-3:-1]
    for part in outparts:
     outstuff+='PRIVMSG %s :%s\n' %(channel,part) 

   if cmd[1]=='6':

    output=syscmd(['ping6','-c','5','-i','0.2',cmd[2]])
    outsplit=output.split('\n')
    outparts=outsplit[-3:-1]
    for part in outparts:
     outstuff+='PRIVMSG %s :%s\n' %(channel,part)
  return(outstuff)
  else:
   return('PRIVMSG %s :Error: protocol must be either 4 or 6' %channel)

def help_ping():
 return('PRIVMSG %s :Pings an internet address. Usage: ping (4|6) <address>.' %(channel))

A plugin’s register() function is called when the plugin is loaded. It can use registerfunction(), addlistener(), and addhelp(). You can use each function as many times as you want, in case you have multiple functions and/or listeners, or if you want to include help with your plugin.

Read more to find out how to use the new plugin features.

Function Usage

registerfunction() usage:

registerfunction('command', function)

where ‘command’ is the command that the user would use to access this function, and “function” is the actual python function that you have defined in your module. See the ping example above for a usage example.

addlistener() usage:

addlistener('type', function)

For addlistener(), ‘type’ is a string denoting the type of event to call the function on, such as “any” or “privmsg”. “function” works the same as with registerfunction().

addhelp() usage:

addhelp('command', function)

‘command’ is the command that the user will access help on (eg, if ‘command’ was ‘mycommand’, the user would use ‘help mycommand’ to read the help.) Function works the same as the others.

Other Notes

All plugins go in the “modules” folder now. There are no longer separate folders for different types of plugins.

I have not yet rewritten the on-the-fly module management commands (enabling, disabling, reloading, etc) so you will not be able to use these with the new system until I feel like rewriting them.

Lastly, I will be improving the plugin system, and I will try to make older plugins backwards-compatible, but the new system will make the plugin system more efficient. Instead of always having to scan for functions in plugins whenever a certain command is called, all function plugins will register in a list of plugins upon being loaded. This has the advantage of also allowing plugin authors to specify what functions are actual functions for the bot to use.

Now for the technical stuff. A listener is just a python file in the listeners folder, with functions defined in it. A function’s name should be botfunction_type, where type is the type of message to listen for (privmsg, join, part, etc) or it can be ‘any’ for all data received by the bot. Here is an example logger function:

#!/usr/bin/python

import time

enabled=1

logfile=open('log','a')
timestamp=time.strftime('[ Session starting at %y-%m-%d %H:%M:%S ]')
logfile.write(timestamp+'\n')
logfile.close()

def botfunction_any():
 logfile=open('log','a')
 timestamp=time.strftime('[%y-%m-%d %H:%M:%S] ')
 logfile.write(timestamp+line+'\n')
 logfile.close()

As you can see from the example, plugins can be quickly enabled or disabled by toggling the ‘enabled’ flag. Also, ‘line’ is passed to the plugin. Not that anything outside of function definitions will be run when the bot starts.

Listeners can use the ’socket’ variable to send data to the server, as shown in this example:

#!/usr/bin/python

enabled=0

def botfunction_privmsg():
 print "called"
 out="PRIVMSG %s :Botfunction_privmsg called" %(channel)
 print out
 socket.send(out+'\n')

Note that in the example, it uses botfunction_privmsg. To make listeners easier to write, the main program will automatically figure out these variables from privmsgs and pass them to the function:

info         #user info
msg          #the message
channel      #the channel the message was from (set to the sender for private messages)
sender       #the sender of the message
senderstuff  #info of the sender
isprivate    #whether or not the message was a private message as opposed to a channel message.

This only applies to privmsgs. All other events only get ’socket’ and ‘line’ passed and have to figure out everything from ‘line’

That’s all for now.

#!/usr/bin/python 

def test():
 return("PRIVMSG %s :test" %(channel))

This would make a function called test. The variables channel, sender, nick, cmd, and run are passed to the function. The functions syscmd() and getlevel() are also passed to the plugin.

The default plugins that are included with the bot are ping, for pinging addresses, testplugin, for testing the bot, yacas, for doing math with yacas (delete it if you don’t have yacas installed) and getlevel, for demonstrating the ability to use the getlevel function in a plugin.

I have also set up a page for the bot, see the links bar below the logo.

I am currently writing a small, fast, small-footprint IRC bot in Python. More details as I finish the bot. The functions created so far:

• Help (Displays Help)
• Echo (Echo back a message)
• Say (Send a message to a channel)
• Spam (Send a message to a channel a specified amount of times)
• Join (Join a channel)
• Part (Part a channel)
• Authorization (username+password)
• Deauthorization
• User lookup
• Raw (Use raw IRC commands)
• Uptime (Display uptime)
• Math (Do math functions with Yacas)

Planned functions:

• Encrypted passwords
• Data storage, either in a text file or a MySQL DB
• Channel mode control

This bot is not meant to be a complex bot, it is intended to be a fast, light bot that can be easily reprogrammed.

To be more fair this time, I’ll start with Apple and set a budget accordingly, since Apples cheapest laptop at the time of writing is $999. I’ll start with that one.

The $999 Macbook has a 13″ screen and a 2.26Ghz C2D. Not a bad CPU for a laptop. It has only 2GB of RAM, which can be upgraded to 4 for $100, but seems substandard these days. Unfortunately, already being at the budget, I couldn’t get any upgrades.

Looking at Dell’s lineup, everything starts at under $1000 in the studio line. They have an i7 version of the studio 17, which would almost certainly beat everything else, but it was over budget. I decided to start with the basic Studio 17. I took an upgrade to 4GB of RAM and an upgrade to a 4650 from an Intel GPU. Getting an 802.11n card put me $75 under budget, so I upgraded to CPU to end up at exactly $999.

Now for HP. I went to “high performance” and started with the dv7t. I upgraded to 4GB of DDR3, took the free upgrade to a 320GB hard drive, upgraded to a 4650 1GB, and got 802.11n+bluetooth, which put me at $989.

On to Lenovo. The Y550 was under $1000 and had discrete graphics, so I went with the top model. It was $688, so I had some room to improve it. Also, it was clear that it was better than the other systems in some areas. I upgrade the wireless to 802.11n, upgraded to 4GB DDR3, and had $220 left to spend. I got a 500GB HDD, bluetooth, and still had money to spend. I upgraded the CPU to a 2.53GHz C2D, but this put me slightly over, so I downgraded to a 320GB HDD.

For the last laptop, I decided to go with a Sony. The Vaio SR started at $819, which should leave plenty of room for improvement.

As you can see, the Macbook has poor RAM capacity, but makes up for it with a decent graphics card and CPU. The Lenovo, Dell, and HP seem to be the best overall, whereas the Sony seems to have lack in certain areas. No DDR3, slowest CPU, and smallest hard drive. Overall, all the laptops seems to be more even, and it’s nice to see Apple doesn’t seem to be doing the usual price-gouging routine, at least not as much.

Note: this is not intended to be a buying guide. This is just for showing which brands will give you the best computer for your money.

Now, obviously, I won’t be able to get everything here. Since *nix users will tend to be power users, or will need to administrate other systems, I have included important command-line and system administration tools.

1. Bash

Windows equivalent: CMD and PowerShell.

Command prompt, aka cmd is the basic command line for Windows. It allows you to execute programs, pipe output, send output to files, etc. For relatively new Windows users, press Winkey-R (the equivalent of Alt-F2 is many desktop environments) and enter cmd. This launches the command line.

The other command line for Windows is PowerShell. PowerShell has a steep learning curve, but is much more powerful than the basic command line.

2. Telnet and SSH

Windows has a built-in basic telnet program which can be used in Command Prompt. The syntax is basically the same as the typically Unix implementation (telnet host [port]) but is not very feature-rich. A much better program is PuTTY. PuTTY is a free Telnet and SSH program, supporting many SSH features such as tunneling.

3. FTP, SCP, SFTP

WinSCP is a free file transfer client supporting FTP, SCP, and SFTP with a little PuTTY integration. It has a MC-like interface which is easy to use, especially for people who actually used MC.

4. Services management

Run services.msc to get to the Windows Services Manager. Here, you can do the things you would normally do with the stuff in /etc/init.d. You can start, stop, restart, and even pause some services. You can also set which services should start on startup, and which should be disabled.

5. su/sudo

The runas program allows you to run a program as another user. It is a command-line program, and I won’t go over it, because it prints a usage message when invoked. Basically, you specify a user and program, and enter the password for that user. The “administrator” user is not quite the same as “root”. “Local System” is equivalent to root. Especially with more recent versions of Windows, you will need to have elevated privileges in order to do certain things.

6. SELinux

Windows 6+ has a feature called User Account Control. It is quite annoying, but does add a layer of security. It can be configured to ask for a password, like how gksu would. By default it only makes you click a button, which isn’t security if, say, you’re away from your desk. Someone could still tamper with your computer by simply clicking. My advice: if you leave UAC turned on, make it ask for a password.

That’s all for now. I feel I have covered the basic things. Stay tuned for more.

Feedback is welcomed in the comments, along with any questions you might have.

This theme does not work well in IE6. If you have IE6 users visiting your site, you should probably tell them to upgrade.

roundicity-0.9-alpha.tar.gz