def parse_with_arg_common(self, cnt):
		test(self.name_alt == None, err.InvalidDoubleName, (cnt, self.name_alt))

		self.has_arg = True
		test(check.optarg_name(self.arg_name), err.InvalidArgName, (cnt, self.arg_name))

		self.arg_range = check.is_empty_or_none(self.arg_range)
Beispiel #2
0
    def parse_type_float(self, cnt):
        self.parse_with_arg_common(cnt)

        if self.arg_range != None:
            self.parse_numeric_range(cnt)

            for i in range(len(self.arg_range)):
                self.arg_range[i] == check.is_empty_or_none(self.arg_range[i])
                if isinstance(self.arg_range[i], int) or isinstance(
                        self.arg_range[i], long):
                    self.arg_range[i] = float(self.arg_range[i])
                test(check.is_float_or_none(self.arg_range[i]),
                     err.InvalidFloatRange, (cnt, self.arg_range))

            test(
                check.range_boundaries_are_valid(self.arg_range,
                                                 self.open_boundary),
                err.InvalidFloatRange, (cnt, self.arg_range))

            if len(self.arg_range) == 3 and self.arg_range[1] == None:
                self.arg_range = [self.arg_range[0], self.arg_range[2]]

            test(check.range_step_is_valid(self.arg_range),
                 err.InvalidFloatRange, (cnt, self.arg_range))

        self.set_numeric_default_val(cnt)
Beispiel #3
0
    def set_numeric_default_val(self, cnt):
        if self.arg_type == "INT":
            invalid_error = err.InvalidIntDefaultVal
            out_of_range_error = err.OutOfRangeIntDefaultVal
        elif self.arg_type == "FLOAT":
            invalid_error = err.InvalidFloatDefaultVal
            out_of_range_error = err.OutOfRangeFloatDefaultVal
        else:
            raise err.Bug(cnt, "")

        self.default_arg = check.is_empty_or_none(self.default_arg)
        if self.default_arg != None:
            try:
                if self.arg_type == "INT":
                    def_val = long(self.default_arg)
                elif self.arg_type == "FLOAT":
                    def_val = float(self.default_arg)
            except ValueError:
                raise invalid_error(cnt, self.default_arg)

            self.default_arg = self.default_arg.strip()

            test(
                check.is_in_range(def_val, self.arg_range, self.open_boundary),
                out_of_range_error, (cnt, def_val))
Beispiel #4
0
    def parse_with_arg_common(self, cnt):
        test(self.name_alt == None, err.InvalidDoubleName,
             (cnt, self.name_alt))

        self.has_arg = True
        test(check.optarg_name(self.arg_name), err.InvalidArgName,
             (cnt, self.arg_name))

        self.arg_range = check.is_empty_or_none(self.arg_range)
	def set_flag_default_val(self, cnt):
		invalid_error = err.InvalidFlagDefaultVal

		self.default_arg = check.is_empty_or_none(self.default_arg)
		if self.default_arg == None:
			self.default_arg = "false"

		test(check.is_bool_in_string(self.default_arg), invalid_error, (cnt, self.default_arg))

		self.default_arg = self.default_arg.lower()
Beispiel #6
0
    def set_flag_default_val(self, cnt):
        invalid_error = err.InvalidFlagDefaultVal

        self.default_arg = check.is_empty_or_none(self.default_arg)
        if self.default_arg == None:
            self.default_arg = "false"

        test(check.is_bool_in_string(self.default_arg), invalid_error,
             (cnt, self.default_arg))

        self.default_arg = self.default_arg.lower()
	def parse_type_int(self, cnt):
		self.parse_with_arg_common(cnt)

		if self.arg_range != None:
			self.parse_numeric_range(cnt)

			for i in range(len(self.arg_range)):
				self.arg_range[i] == check.is_empty_or_none(self.arg_range[i])
				test(check.is_int_or_none(self.arg_range[i]), err.InvalidIntRange, (cnt, self.arg_range))

			test(check.range_boundaries_are_valid(self.arg_range, self.open_boundary), err.InvalidIntRange, (cnt, self.arg_range))

			if len(self.arg_range) == 3 and self.arg_range[1] == None:
				self.arg_range = [self.arg_range[0], self.arg_range[2]]

			test(check.range_step_is_valid(self.arg_range), err.InvalidIntRange, (cnt, self.arg_range))

		self.set_numeric_default_val(cnt)
	def set_numeric_default_val(self, cnt):
		if self.arg_type == "INT":
			invalid_error = err.InvalidIntDefaultVal
			out_of_range_error = err.OutOfRangeIntDefaultVal
		elif self.arg_type == "FLOAT":
			invalid_error = err.InvalidFloatDefaultVal
			out_of_range_error = err.OutOfRangeFloatDefaultVal
		else:
			raise err.Bug(cnt, "")

		self.default_arg = check.is_empty_or_none(self.default_arg)
		if self.default_arg != None:
			try:
				if self.arg_type == "INT":
					def_val = long(self.default_arg)
				elif self.arg_type == "FLOAT":
					def_val = float(self.default_arg)
			except ValueError:
				raise invalid_error(cnt, self.default_arg)

			self.default_arg = self.default_arg.strip()

			test(check.is_in_range(def_val, self.arg_range, self.open_boundary), out_of_range_error, (cnt, def_val))
Beispiel #9
0
    def __init__(self, cnt, settings, name, arg_type, arg_name, arg_range,
                 default_arg, desc):
        self.settings = settings
        self.name = name
        self.short = ""
        self.force_noshort = False
        self.short_only = False
        self.arg_type = str(arg_type)
        self.is_array = False
        self.arg_name = str(arg_name)
        self.arg_range = str(arg_range)
        self.default_arg = str(default_arg)
        self.desc = str(desc)

        self.arg_range_compiled_regex = None
        self.open_boundary = [False, False]

        splitnamealt = str(name).split("|")
        test(
            len(splitnamealt) == 1 or len(splitnamealt) == 2,
            err.WrongSplitAltName, (cnt, name))

        self.name = splitnamealt[0]
        splitname = str(splitnamealt[0]).split(",")
        test(
            len(splitname) == 1 or len(splitname) == 2, err.WrongSplitName,
            (cnt, splitnamealt[0]))
        if len(splitname) > 1:
            self.name = splitname[0]
            self.short = splitname[1]
        elif len(self.name) == 1:
            self.short = self.name
            self.short_only = True

        test(check.var_name(self.name), err.InvalidName, (cnt, self.name))
        test(self.name != "help", err.ReservedOptName, (cnt, self.name))
        test(self.name != "version", err.ReservedOptName, (cnt, self.name))
        test(check.var_name_is_reserved(self.name), err.ReservedVarName,
             (cnt, self.name))

        test(
            check.optname_short(self.short)
            or check.directive_short(self.short), err.InvalidShortOpt,
            (cnt, self.short))
        self.short = check.is_empty_or_none(self.short)
        if self.short == "-":
            self.short = None
            self.force_noshort = True

        self.name_alt = None
        self.short_alt = ""
        self.force_noshort_alt = False
        self.short_only_alt = False
        if len(splitnamealt) == 2:
            self.name_alt = splitnamealt[1]
            splitname = str(splitnamealt[1]).split(",")
            test(
                len(splitname) == 1 or len(splitname) == 2, err.WrongSplitName,
                (cnt, splitnamealt[1]))
            if len(splitname) > 1:
                self.name_alt = splitname[0]
                self.short_alt = splitname[1]
            elif len(self.name_alt) == 1:
                self.short_alt = self.name_alt
                self.short_only_alt = True
            test(check.alt_opt_name(self.name_alt), err.InvalidName,
                 (cnt, self.name_alt))
            test(self.name_alt != "help", err.ReservedOptName,
                 (cnt, self.name_alt))
            test(self.name_alt != "version", err.ReservedOptName,
                 (cnt, self.name_alt))
            #test(check.var_name_is_reserved(self.name_alt), err.ReservedVarName, (cnt, self.name_alt))

            test(
                check.optname_short(self.short_alt)
                or check.directive_short(self.short_alt), err.InvalidShortOpt,
                (cnt, self.short_alt))
            if self.short_alt == "-":
                self.short_alt = None
                self.force_noshort_alt = True

        self.short_alt = check.is_empty_or_none(self.short_alt)

        self.arg_type = self.arg_type.upper()

        if self.arg_type in ["INT+", "FLOAT+", "STRING+"]:
            self.arg_type = self.arg_type[:-1]
            self.is_array = True

        if self.arg_type == "INT":
            self.parse_type_int(cnt)
        elif self.arg_type == "FLOAT":
            self.parse_type_float(cnt)
        elif self.arg_type == "STRING":
            self.parse_type_string(cnt)
        elif self.arg_type == "NONE" or self.arg_type == "":
            self.parse_type_flag(cnt)
        else:
            raise err.InvalidArgType(cnt, self.arg_type)

        self.opt_name = self.name.replace("_", "-")
        self.opt_name_alt = None
        if self.name_alt != None:
            self.opt_name_alt = self.name_alt.replace("_", "-")
	def __init__(self, cnt, settings, name, arg_type, arg_name, arg_range, default_arg, desc):
		self.settings = settings
		self.name = name
		self.short = ""
		self.force_noshort = False
		self.short_only = False
		self.arg_type = str(arg_type)
		self.is_array = False
		self.arg_name = str(arg_name)
		self.arg_range = str(arg_range)
		self.default_arg = str(default_arg)
		self.desc = str(desc)

		self.arg_range_compiled_regex = None
		self.open_boundary = [False, False]

		splitnamealt = str(name).split("|")
		test(len(splitnamealt) == 1 or len(splitnamealt) == 2, err.WrongSplitAltName, (cnt, name))

		self.name = splitnamealt[0]
		splitname = str(splitnamealt[0]).split(",")
		test(len(splitname) == 1 or len(splitname) == 2, err.WrongSplitName, (cnt, splitnamealt[0]))
		if len(splitname) > 1:
			self.name = splitname[0]
			self.short = splitname[1]
		elif len(self.name) == 1:
			self.short = self.name
			self.short_only = True

		test(check.var_name(self.name), err.InvalidName, (cnt, self.name))
		test(self.name != "help", err.ReservedOptName, (cnt, self.name))
		test(self.name != "version", err.ReservedOptName, (cnt, self.name))
		test(check.var_name_is_reserved(self.name), err.ReservedVarName, (cnt, self.name))

		test(check.optname_short(self.short) or check.directive_short(self.short), err.InvalidShortOpt, (cnt, self.short))
		self.short = check.is_empty_or_none(self.short)
		if self.short == "-":
			self.short = None
			self.force_noshort = True

		self.name_alt = None
		self.short_alt = ""
		self.force_noshort_alt = False
		self.short_only_alt = False
		if len(splitnamealt) == 2:
			self.name_alt = splitnamealt[1]
			splitname = str(splitnamealt[1]).split(",")
			test(len(splitname) == 1 or len(splitname) == 2, err.WrongSplitName, (cnt, splitnamealt[1]))
			if len(splitname) > 1:
				self.name_alt = splitname[0]
				self.short_alt = splitname[1]
			elif len(self.name_alt) == 1:
				self.short_alt = self.name_alt
				self.short_only_alt = True
			test(check.alt_opt_name(self.name_alt), err.InvalidName, (cnt, self.name_alt))
			test(self.name_alt != "help", err.ReservedOptName, (cnt, self.name_alt))
			test(self.name_alt != "version", err.ReservedOptName, (cnt, self.name_alt))
			#test(check.var_name_is_reserved(self.name_alt), err.ReservedVarName, (cnt, self.name_alt))

			test(check.optname_short(self.short_alt) or check.directive_short(self.short_alt), err.InvalidShortOpt, (cnt, self.short_alt))
			if self.short_alt == "-":
				self.short_alt = None
				self.force_noshort_alt = True

		self.short_alt = check.is_empty_or_none(self.short_alt)

		self.arg_type = self.arg_type.upper()

		if self.arg_type in ["INT+", "FLOAT+", "STRING+"]:
			self.arg_type = self.arg_type[:-1]
			self.is_array = True

		if self.arg_type == "INT":
			self.parse_type_int(cnt)
		elif self.arg_type == "FLOAT":
			self.parse_type_float(cnt)
		elif self.arg_type == "STRING":
			self.parse_type_string(cnt)
		elif self.arg_type == "NONE" or self.arg_type == "":
			self.parse_type_flag(cnt)
		else:
			raise err.InvalidArgType(cnt, self.arg_type)

		self.opt_name = self.name.replace("_","-")
		self.opt_name_alt = None
		if self.name_alt != None:
			self.opt_name_alt = self.name_alt.replace("_","-")