"""Module implementing the parameter types code."""
import re
+import operator
from ganeti import compat
from ganeti import utils
return "(%s)" % text
-class _DescWrapper(object):
+class _WrapperBase(object):
__slots__ = [
"_fn",
"_text",
@param fn: Wrapped function
"""
+ assert text.strip()
+
self._text = text
self._fn = fn
def __call__(self, *args):
return self._fn(*args)
+
+class _DescWrapper(_WrapperBase):
+ """Wrapper class for description text.
+
+ """
def __str__(self):
return self._text
+class _CommentWrapper(_WrapperBase):
+ """Wrapper class for comment.
+
+ """
+ def __str__(self):
+ return "%s [%s]" % (self._fn, self._text)
+
+
def WithDesc(text):
"""Builds wrapper class with description text.
return compat.partial(_DescWrapper, text)
+def Comment(text):
+ """Builds wrapper for adding comment to description text.
+
+ @type text: string
+ @param text: Comment text
+ @return: Callable class
+
+ """
+ assert not frozenset(text).intersection("[]")
+
+ return compat.partial(_CommentWrapper, text)
+
+
def CombinationDesc(op, args, fn):
"""Build description for combinating operator.
TPositiveInt = \
TAnd(TInt, WithDesc("EqualGreaterZero")(lambda v: v >= 0))
+#: a maybe positive integer (positive integer or None)
+TMaybePositiveInt = TOr(TPositiveInt, TNone)
+
#: a strictly positive integer
TStrictPositiveInt = \
TAnd(TInt, WithDesc("GreaterThanZero")(lambda v: v > 0))
+#: a maybe strictly positive integer (strictly positive integer or None)
+TMaybeStrictPositiveInt = TOr(TStrictPositiveInt, TNone)
+
+#: a strictly negative integer (0 > value)
+TStrictNegativeInt = \
+ TAnd(TInt, WithDesc("LessThanZero")(compat.partial(operator.gt, 0)))
+
#: a positive float
TPositiveFloat = \
TAnd(TFloat, WithDesc("EqualGreaterZero")(lambda v: v >= 0.0))
#: Job ID
-TJobId = TOr(TPositiveInt,
- TRegex(re.compile("^%s$" % constants.JOB_ID_TEMPLATE)))
+TJobId = WithDesc("JobId")(TOr(TPositiveInt,
+ TRegex(re.compile("^%s$" %
+ constants.JOB_ID_TEMPLATE))))
#: Number
TNumber = TOr(TInt, TFloat)
+#: Relative job ID
+TRelativeJobId = WithDesc("RelativeJobId")(TStrictNegativeInt)
+
def TListOf(my_type):
"""Checks if a given value is a list with all elements of the same type.
return desc(TAnd(TList, lambda lst: compat.all(my_type(v) for v in lst)))
+TMaybeListOf = lambda item_type: TOr(TNone, TListOf(item_type))
+
+
def TDictOf(key_type, val_type):
"""Checks a dict type for the type of its key/values.