SAMP Python command parser

import types, inspect
try:
    import samp
except ImportError:
    pass

t_unauthorized='You are not allowed to use this command'
t_unauthd_color=0xFF1111FF
_cmd_list = dict()
current_cmd = None

def cmd(command, raw=False, requires=None, convert=None, unauthorized_text=t_unauthorized, unauthd_color=t_unauthd_color):
    """function decorator for command functions

    Arguments:
    function:
        Command name as a string or a tuple of multiple aliases
        If there is no command name passed, the command's name will be the function's name
    raw:
        whether the cmdtext should be passed as the raw string (True) or parsed as a whitespace-seperated tuple
    requires:
        function object or a tuple with multiple function objects,
        which are called with a playerid and should return True if the player is allowed to use that command
    convert:
        contains a dictionary of callable objects, that take a string and return any other type, which is
        called for the given command parameter, for example the following will parse prm1 as int:
        @cmd("test", convert=dict(prm1=int))
        def cmd_test(playerid, prm1):
            pass
    unauthorized_text:
        a string which is sent to the player, if he/she/it is not allowed to use the command (see requires)
    unauthd_color:
        a color code which is used for sending the unauthorized message

    Example usages:
    >>> @cmd
    ... def testcmd(playerid, arg1):
    ...     pass

    >>> @cmd("testcmd", requires=samp.IsPlayerAdmin)
    ... def cmd_test(playerid, arg1):
    ...     pass
    """

    ret_obj = True
    # get command names
    cmd_names = []
    if type(command) == str:
        cmd_names.append(command) # directly add this string as the name
    elif hasattr(command, '__iter__'):
        cmd_names.extend(command) # extend the list with the iterable object
    elif hasattr(command, '__call__'): # in that case we (should) have a decorator @cmd, where the function object is passed here
        cmd_names.append(command.func_name)
        ret_obj = False # in that case we don't have to return the cmd_obj instance
    else: # invalid parameter
        raise TypeError('invalid type: command')

    inst = _cmd_obj(cmd_names, raw, requires, convert, unauthorized_text, unauthd_color)
    if not ret_obj:
        # set function in inst and return command
        inst.function = command
        inst.read_function_data()
        return command
    return inst


class _cmd_obj(object):
    def __init__(self, aliases, raw, requires, convert, unauthorized_text, unauthd_color):
        # we always have a list of command names in aliases
        # iterate through all strings and add the commands
        for alias in aliases:
            _cmd_list[(alias if alias[0] != '/' else alias[1:])] = self # strip leading slash if there is one

        self.function = None
        self.raw = raw
        self.requires = requires if hasattr(requires, '__iter__') else (requires,)
        self.convert = convert if type(convert) == dict else dict()
        self.unauthorized_text = unauthorized_text
        self.unauthd_color = unauthd_color

    def __call__(self, funcobj):
        if self.function == None:
            # in this case, we have a @cmd(...) decorator -> the function object is passed here
            self.function = funcobj
            self.read_function_data()
        return funcobj

    def read_function_data(self):
        """
        reads parameter count and type of the function parameters
        """
        args = None
        # read parameter info, depending on what callable type it is
        if type(self.function) == types.FunctionType:
            args = inspect.getargspec(self.function)
        else:
            args = inspect.getargspec(self.function.__call__)
            # check if there is a self parameter
            try: args.args.remove('self')
            except ValueError: pass
        # set parameter count
        if args.varargs != None:# or args.keywords != None: # keyword arguments wouldn't make any sense here
            # unlimited parameter count
            self.param_count = -1
        else:
            self.param_count = len(args.args) - 1
        # save the argument names for the convert parameter
        self.args = args.args

def handle_command(playerid, cmdtext):
    """This function handles a command sent by a player and has to be called in OnPlayerCommandText

    >>> @cmd
    ... def test(pid, prm1, prm2):
    ...     print('called')
    >>> @cmd("t2", convert=dict(prm1=int))
    ... def t2(pid, prm1):
    ...     print(type(prm1))
    >>> handle_command(0, "/test prm1 prm2")
    called
    True
    >>> handle_command(0, "/t2 5")
    <type 'int'>
    True
    >>> handle_command(1, "/nocmd")
    False
    """
    # split cmdtext
    prt = cmdtext.split()
    cmdname = prt[0][1:]
    # find the cmd instance
    if not cmdname in _cmd_list:
        return False # command does not exist
    cmd = _cmd_list[cmdname]
    if cmd.function == None:
        raise AttributeError("command has no callable object assigned: [%d]: %s" % (playerid, cmdtext))

    # check if this user is authorized to use this command
    for req in cmd.requires:
        try:
            if not req(playerid): # it's the user's fault if he doesn't pass callable objects
                samp.SendClientMessage(playerid, cmd.unauthd_color, cmd.unauthorized_text)
                return True
        except TypeError: pass

    if cmd.param_count != -1 and len(prt) - 1 > cmd.param_count: # too many parameters passed -> cut out
        prt = prt[:-(len(prt) - cmd.param_count - 1)]

    # convert parameters
    for p in xrange(len(prt)):
        if cmd.args[p] in cmd.convert: # check if this parameter exists
            try: # call the converter
                prt[p] = cmd.convert[cmd.args[p]](prt[p])
            except: pass # we don't know which exceptions are thrown if conversion fails, so always drop it

    # call the function object
    cmd.function(playerid, *prt[1:] if not cmd.raw else cmdtext)

    return True

# doctest
if __name__ == "__main__":
    # mock for samp module with needed functions for doctests
    class samp(object):
        @staticmethod
        def IsPlayerAdmin(playerid):
            return True if playerid % 2 else False
        @staticmethod
        def SendClientMessage(playerid, color, text):
            return None

    import doctest
    doctest.testmod()