View difference between Paste ID: 46DLNY1A and 0yrTkafF

 #!/usr/bin/env python
 
 """Charitum.py: an extensible IRC bot"""
 
-# ----------------------------------------------------------------------------
+
-# "THE BEER-WARE LICENSE" (Revision 42):
+
-# <[email protected]> wrote this file. As long as you retain this notice you
+
-# can do whatever you want with this stuff. If we meet some day, and you think
+__version__ = "1.4.2"
-# this stuff is worth it, you can buy me a beer in return. S0lll0s
+
-# ----------------------------------------------------------------------------
+
 import sys
 import signal
 import time
 from ircutils import bot, format, protocol
-__version__ = "1.4.4"
+
 ############################## EVENTS ###############################
 
 # event handling seems to be broken
 
 def callback_shutdown( signal, frame ):
-import urllib2
+
-import urllib
+
         sys.exit( 0 )
 
 ############################# UTILS #################################
 
 def format_command( command, received ):
         """ Returns the fitting 'command' based on 'received'.
                 received is either channel or private"""
         if received == "channel":
                 return "!" + command.lower()
         return command.upper()
 
 ############################# COMMANDS ##############################
 
 def cmd_exec( self, command, params, event, received="channel" ):
         """ {0}!X!- Execute an IRC command:
                 {0} <COMMAND> <[PARAMS]>!X!- Execute the IRC command <COMMAND> with parameters <PARAMS>"""
 
         self.execute( params[0].upper(), ' '.join( params[1:] ).strip() )
         if received == "private":
                 self.send_message( event.source, "Executed" + format.bold( params[0].upper() + ' '.join( params[1:] ) ) )
 
 def cmd_say( self, command, params, event, received="channel" ):
         """ {0}!X!- Say a Text:
-        """ {0}!X!- Execute an IRC command
+
                 {0} <CHANNEL> <TEXT>!X!- Say <TEXT> in channel <CHANNEL> (/msg only)"""
 
         if received == "private":
                 self.send_message( params[0], ' '.join( params[1:] ).strip() )
         else:
                 self.send_message( event.target, ' '.join( params ).strip() )
 
-        """ {0}!X!- Say a Text
+
         """ {0}!X!- Update the Voice/HOP/OP info manually:
                 {0}!X!- Update the Voice/HOP/OP info manually"""
 
         self.execute( "NAMES", event.target )
 
 def cmd_help( self, command, params, event, received="channel" ):
         """ {0}!X!- Help for commands:
                 {0}!X!- List commands
                 {0} <COMMAND>!X!- Help for <COMMAND>"""
-        """ {0}!X!- Update the Voice/HOP/OP info manually
+
         if len( params ) < 1:
                 self.send_message( event.source, "List of commands:" )
                 for cmd in self.commands:
                         self.send_message( event.source, format.color( "## ", format.LIME_GREEN ) + '{:<20} {}'.format( *self.commands[ cmd ][1].__doc__.format( format.bold( format_command( cmd, received ) ) ).splitlines()[0].strip().split( "!X!", 1 ) ) ) # split and justify
                 return
-        """ {0}!X!- Help for commands
+
                 self.send_message( event.source, "Usage info for command {0}:".format( format.bold( params[0] ) ) )
                 for line in self.commands[ params[0].lower() ][1].__doc__.format( *[ format.bold( format_command( c, received ) ) for c in params ] ).splitlines():
                         self.send_message( event.source, format.color( "## ", format.LIME_GREEN ) + '{:<35} {}'.format( *line.strip().split( "!X!", 1 ) ) ) # split and justify
         else:
                 self.send_message( event.source, "Unkown Command {0}.".format( format.bold( params[0] ) ) )
 
 def cmd_shout( self, command, params, event, received="channel" ):
         """ {0}!X!- Shout a Text:
                 {0} <TEXT>!X!- Shout <TEXT> in current channel
                 {0} <CHANNEL> <TEXT>!X!- Shout <TEXT> in channel <CHANNEL> (/msg only)"""
 
         colors = [ format.GREEN, format.RED, format.AQUA, format.YELLOW, format.PINK, format.PURPLE, format.TEAL, format.LIGHT_GRAY ]
         if received == "private":
                 for color, bg in [(x,y) for x in colors for y in colors]:
                         self.send_message( params[0], format.color( ' '.join( params[1:] ).strip(), color, bg ) )
                         time.sleep( 0.5 )
-        """ {0}!X!- Shout a Text
+
                 for color, bg in [(x,y) for x in colors for y in colors]:
                         self.send_message( event.target, format.color( ' '.join( params ).strip() , color, bg ) )
                         time.sleep( 0.5 )
 
 def cmd_op( self, command, params, event, received="channel" ):
         """{0}!X!- Make an user OP:
                 {0}!X!- Get OP yourself
                 {0} <USER>!X!- Make <USER> OP
                 {0} <CHANNEL>!X!- Get OP yourself (/msg)
                 {0} <CHANNEL> <USER>!X!- Make <USER> OP (/msg)"""
 
         user = event.source
         if received == "private":
                 if len( params ) > 1:
-        """{0}!X!- Make an user OP
+
                 self.execute( "OP", params[0] + " " + user )
         else:
                 if len( params ) > 0:
                         user = params[0]
                 self.execute( "OP", event.target + " " + user )
 
 def cmd_kick( self, command, params, event, received="channel" ):
         """{0}!X!- Kick an user:
                 {0} <USER>!X!- Kick <USER>
-                self.execute( "MODE", params[0], "+o:", user )
+
 
         if len( params ) < 1 or [0] == "Charitum":
                 return
-                self.execute( "MODE", event.target, "+o:", user )
+
         channel = event.target
         if len( params ) > 1:
-        """{0}!X!- Kick an user
+
         self.execute( "KICK", channel + " " + params[0] )
 
 ############################### BOT #################################
-        if len( params ) < 1 or params[0] == "Charitum":
+
 class Charitum( bot.SimpleBot ):
         commands = {}
         channelusers = {}
         access = dict( ( ([ '', '+', '%', '@', '&', '~' ])[num] , num ) for num in range( 6 ) )
 
-        self.execute( "KICK", channel, " ", params[0] )
+
                 """ Adds a new command. command and short are names for
                         the command, used as ![command/short] and [COMMAND/SHORT].
-def cmd_banner( self, command, params, event, received="channel" ):
+
-	"""{0}!X!- Print an ASCII Banner
+
-		{0} <BANNER>!X!- Print <BANNER>
+
-		{0} <BANNER> <CHANNEL>!X!- Print <BANNER> in <CHANNEL>"""
+
                         specifically targetting the command. Format your docstring
-	rec = event.target
+
-	if received == "private":
+
-		rec = event.source
+
-	if len( params ) > 1:
+
-		rec = params[1]
+
                 if short is not None:
-	banner = None
+
-	if params[0] == "text":
+                print "Added commmand", command, ", level", level, ", func", func.__name__
-		banner = ( format.BLUE, urllib2.urlopen( "https://artii.herokuapp.com/make?text=" + urllib.quote( " ".join(  params[2:] ) ) ).read().splitlines() )
+
-		print banner
+
-		print "https://artii.herokuapp.com/make?text=" +  " ".join(params[2:])
+
-	elif params[0] == "graffiti":
+
-		banner = ( format.BLUE, urllib2.urlopen( "https://artii.herokuapp.com/make?text=" + urllib.quote( " ".join( params[2:] ) ) + "&font=graffiti" ).read().splitlines() )
+
-		print "graf"
+
-	elif params[0] in banners:
+
-		banner = banners[params[0]]
+
-		print "file"
+
-	else:
+
-		self.send_message( rec, format.color( "ERROR:", format.RED ) + " Banner not found" )
+
-		print "none"
+
-		return
+
                 message = event.message.split()
-	for line in banner[1]:
+
-		self.send_message( rec, format.color( format.bold( line ), banner[0], format.BLACK ) )
+
-		time.sleep( 0.5 )
+
                 if len( command ) == 1: # skip single !'s and stuff
                         return
 
                 if command[0] == "!": # only handle commands directed to us...
                         command =  command[1:].lower()
                         if command in self.commands: # ... that exist
                                 self.execute( "NAMES", event.target ) # update permissions
                                 ( level, func ) = self.commands[ command ]
 
                                 for name in self.channelusers[ event.target ]:
                                         if protocol.strip_name_symbol( name ) == event.source: break # name is now event.target's name
 
                                 ulevel = 0
                                 if name[0] in self.access: # do not handle 'empty' users
                                         ulevel = self.access[ name[0] ]
 
                                 if  ulevel < self.access[ level ]:
                                         self.send_message( event.target, format.color( "ERROR:", format.RED ) + " You are not allowed to use the " + format.bold( command ) + " Command" )
                                         return
                                 func( self, command, params, event )
                         else:
                                 self.send_message( event.target, format.color( "ERROR:", format.RED ) + " Command " + format.bold( command ) +" not found" )
 
-                print "Added commmand " + command + ", level " + level + ", func " + func.__name__
+
         def on_private_message( self, event ):
                 message = event.message.split()
                 command = message[0].upper()
                 params  = message[1:]
 
                 if command.lower() in self.commands:
                         self.execute( "NAMES", "#ltfu" ) # update permissions
                         ( level, func ) = self.commands[ command.lower() ]
 
                         for name in self.channelusers[ "#ltfu" ]:
                                 if protocol.strip_name_symbol( name ) == event.source: break # name is now event.target's name
 
                         ulevel = 0
                         if name[0] in self.access: # do not handle 'empty' users
                                 ulevel = self.access[ name[0] ]
 
                         if ulevel < self.access[ level ]:
                                 self.send_message( event.source, format.color( "ERROR:", format.RED ) + " You are not allowed to use the " + format.bold( command ) + " Command" )
                                 return
                         func( self, command, params, event, received="private" ) # tell the function this was a private message and call it
                 else:
                         self.send_message( event.source, format.color( "ERROR:", format.RED ) + " Command " + format.bold( command ) +" not found" )
 
 ############################### RUN #################################
 
 if __name__ == "__main__":
         charitum = Charitum( "DudelZ" )
         charitum.connect( "irc.freenode.net", channel=["#ltfu"] )
 
 
         charitum.add_command( "execute", "~", cmd_exec, short="exec" )
         charitum.add_command( "say", "@", cmd_say, "!" )
         charitum.add_command( "shout", "@", cmd_shout, "!!" )
         charitum.add_command( "update", "", cmd_update, "upd" )
         #charitum.add_command( "kick", "@", cmd_kick )
         #charitum.add_command( "op", "@", cmd_op )
         charitum.add_command( "help", "", cmd_help )
 
         signal.signal( signal.SIGINT,  callback_shutdown ) # register graceful shutdown here
 
         charitum.start()