Python Argument Parser and Creater from Raw String/Text

README.md

Raw String Argument Parser

Example

parser = RawParser('example.py -x Xparam1 -y Yparam1-0,Yparam1-1 -y "Yparam 2" -z Zparam1 --zet=Zparam2 --zet="Zparam 3"')
parser.add_arg('-x')
parser.add_arg('-y', splitter=",")
parser.add_arg('-z', 'zet')
parser.parse_args()
print("Program Name: " + parser.get_program_name())
print(parser.x)
print(parser.y)
print(parser.zet)
zet = parser.get_arg('zet')
parser.add_value(zet, '"new zet param"')
parser.add_value('-a', '"new a value"')
print(parser.get_result_dict())
print(parser.get_line())

# Outputs
# Program Name: example
# Xparam1
# ['Yparam 2', 'Yparam1-0', 'Yparam1-1']
# ['Zparam1', 'Zparam 3', 'Zparam2']
# {'x': 'Xparam1', 'zet': ['Zparam1', 'Zparam 3', 'Zparam2', '"new zet param"'], 'y': ['Yparam 2', 'Yparam1-0', 'Yparam1-1'], 'a': '"new a value"'}
# example.py -x Xparam1 -y Yparam1-0,Yparam1-1 -y "Yparam 2" -z Zparam1 --zet=Zparam2 --zet="Zparam 3" -z "new zet param" -a "new a value"

raw_arg_parser.py

import re

# github.com/ahmetkotan
# ahmetkotan.com.tr

class Argument():
    def __init__(self, arg_key, arg_name=None, splitter=None):
        self.arg_key = arg_key
        self.splitter = splitter
        self.arg_name = arg_name

    def get_name(self, name=None):
        if name:
            return re.search("(\w+)", name).group(0)
        return self.arg_name if self.arg_name else re.search("(\w+)", self.arg_key).group(0)

    def get_arg_key(self):
        return self.arg_key

    def get_keys(self):
        if self.arg_name:
            return (self.arg_key, self.arg_name)
        return (self.arg_key)

    def __extract_values(self, pattern, line):
        extract_pattern = re.compile(pattern)
        values = [i.groupdict() for i in extract_pattern.finditer(line)]
        if values:
            values = [i['value'] for i in values if i['value'] != ' ' and i['value']]
            if self.splitter:
                values = [j for i in values for j in i.split(self.splitter)]
            return values
        else:
            return []

    def get_value(self, line):
        self.value_list = []

        pattern_list = [
            "\s+{arg_key}\s*\"(?P<value>.*?)\"".format(arg_key=self.arg_key),
            "\s+{arg_key}\s*\'(?P<value>.*?)\'".format(arg_key=self.arg_key),
            "\s+{arg_key}\s*(?P<value>[\w+,-]*)".format(arg_key=self.arg_key),
        ]

        if self.arg_name:
            pattern_list += [
                "\s+--{arg_name}=\"(?P<value>.*?)\"".format(arg_name=self.arg_name),
                "\s+--{arg_name}=\'(?P<value>.*?)\'".format(arg_name=self.arg_name),
                "\s+--{arg_name}=(?P<value>[\w+,-]*)".format(arg_name=self.arg_name),
            ]

        for pattern in pattern_list:
            self.value_list.extend(self.__extract_values(pattern, line))

        if len(self.value_list) == 1:
            return self.value_list[0]
        elif len(self.value_list) > 1:
            return self.value_list
        else:
            return None

    def __repr__(self):
        return "<Argument: %s>" % self.get_name()


class RawParser():
    def __init__(self, line=None):
        self.arg_list = []
        self.line = line
        self.result_list = {}
        self.program_name = ""

    def __getinitargs__(self):
        return ['arg_list', 'line', 'result_list', 'program_name']

    def set_line(self, line):
        self.line = line
        self.parse_args()
        return True

    def set_program_name(self, program_name):
        self.program_name = program_name
        return True

    def get_program_name(self):
        return self.program_name

    def get_line(self):
        return self.line

    def get_result_dict(self):
        return self.result_list

    def get_namespace(self):
        print(
            "Namespace(%s)" % "\n\t".join(["%s=%s"%(key, value) for key,value in self.result_list.items()])
        )

    def get_arg(self, arg_name):
        for i in self.arg_list:
            if arg_name in i.get_keys():
                return i

        return None

    def get_args(self):
        return self.arg_list

    def get_arg_list(self):
        return [i.get_name() for i in self.arg_list]

    def add_value(self, arg, value):
        if type(arg) == Argument:
            self.line += " %s %s" % (arg.get_arg_key(), value)
        else:
            if self.get_arg(arg):
                self.line += " %s %s" % (self.get_arg(arg).get_arg_key(), value)
            else:
                argm = self.add_arg(arg)
                self.line += " %s %s" % (argm.get_arg_key(), value)
        
        self.parse_args()

    def add_arg(self, arg_key, arg_name=None, splitter=None):
        argument = Argument(arg_key, arg_name, splitter)
        self.arg_list.append(argument)
        return argument

    def parse_args(self):
        self.program_name = re.search("^(\w+)", self.line).group(0)
        self.result_list = {}
        for arg in self.arg_list:
            value = arg.get_value(self.line)
            self.result_list[arg.get_name()] = value
            setattr(self, arg.get_name(), value)

        return self.get_result_dict()