def validate( self, v: typing.Any ) -> typing.Tuple[typing.Any, VldBaseException | None]: d = kw(self) if d.get("fixedtype", False) and not isinstance(v, str): return None, UnexpectedTypeException(name(self)) else: v = str(v) size = len(v) min_len = d.get("minlen", None) if min_len and size < min_len: return None, UnexpectedValueException(name(self)) max_len = d.get("maxlen", None) if max_len and max_len < size: return None, UnexpectedValueException(name(self)) regexp = d.get("regexp", None) if regexp and regexp.fullmatch(v): return v, None check = d.get("check", None) if check: return check(v) return v, None
def validate( self, v: typing.Any ) -> typing.Tuple[typing.Any, VldBaseException | None]: d = kw(self) if not isinstance(v, self.__class__.__types__): if not d.get("fixedtype", False): if len(self.__class__.__types__) == 1: cls = self.__class__.__types__[0] else: cls = decimal.Decimal try: v = cls(str(v)) except ValueError: return None, UnexpectedValueException(name(self)) else: return None, UnexpectedTypeException(name(self)) _min = d.get("minv", None) if _min is not None and v < _min: return None, UnexpectedValueException(name(self)) _max = d.get("maxv", None) if _max is not None and v > _max: return None, UnexpectedValueException(name(self)) _check = d.get("check", None) if _check: return _check(v) return v, None
def validate( self, v: typing.Any ) -> typing.Tuple[typing.Any, VldBaseException | None]: d = kw(self) _check = d.get("check", None) if _check: return _check(v) return v, None
def validate( self, v: typing.Any ) -> typing.Tuple[typing.Any, VldBaseException | None]: if v is None: return None, UnexpectedValueException(name(self)) d = kw(self) _check = d.get("check", None) if _check: return _check(v) return v, None
def validate( self, v: typing.Any ) -> typing.Tuple[typing.Any, VldBaseException | None]: d = kw(self) cls = d["enum"] if isinstance(v, (cls, )): return v, None try: return cls(v), None except ValueError: return None, UnexpectedValueException(name(self))
def validate( self, v: typing.Any ) -> typing.Tuple[typing.Any, VldBaseException | None]: if not isinstance(v, typing.Mapping): return None, UnexpectedTypeException(name(self)) d = kw(self) map_min_size = d.get("minsize", None) if map_min_size and len(v) < map_min_size: return None, UnexpectedValueException(name(self)) map_max_size = d.get("maxsize", None) if map_max_size and len(v) > map_max_size: return None, UnexpectedValueException(name(self)) key_ele = d.get("keyele", None) val_ele = d.get("valele", None) if key_ele or val_ele: if d.get("newcontainer", False): _m = {} for k, v in v.items(): _k, err = key_ele.validate(k) if err is not None: return None, err _v, err = val_ele.validate(v) if err is not None: return None, err _m[_k] = _v v = _m else: _v = [] for k, v in v.items(): _k, err = key_ele.validate(k) if err is not None: return None, err _v, err = val_ele.validate(v) if err is not None: return None, err if k is _k and v is _v: continue _v.append((_k, _v)) for a, b in _v: v[a] = b check = d.get("check", None) if check: return check(v) return v, None
def __init__(self, opts: Options = None): super(TimeField, self).__init__(opts) d = kw(self) cls = d.get("cls", None) if cls is None: d["cls"] = int elif cls not in [int, str, datetime.datetime]: raise ValueError(f"unsupported time class: `{cls}`") if "begin" in d: d["begin"] = make_time(d["begin"]) if "end" in d: d["end"] = make_time(d["end"])
def set_name(obj: Validator | Schema, name: str): d = kw(obj) d["name"] = name ele = d.get("ele", None) if ele: set_name(ele, f"[{name}]") return kele = d.get("key_ele", None) if kele: set_name(kele, f"{name}.key") vele = d.get("val_ele", None) if vele: set_name(vele, f"{name}.value")
def _init_schema(mcs, cls: typing.Type[Schema] | "Meta"): cls.__vlds__ = {} attrs = {} for k, v in vars(cls).items(): if not isinstance(v, Validator | Schema): attrs[k] = v continue name = kw(v).get("name", None) if not name: set_name(v, k) cls.__vlds__[k] = v for k in ["__meta__", "__doc__", "__vlds__"]: attrs.pop(k, None) attrs["__schema__"] = cls cls.__model__ = type(f"{cls.__name__}ProxyObject", (ProxyObj,), attrs)
def validate( self, v: typing.Any ) -> typing.Tuple[typing.Any, VldBaseException | None]: if not isinstance(v, TimeT): return None, UnexpectedTypeException(name(self)) d = kw(self) layout = d.get("layout", DateTimeLayout) t = make_time(v) if t is None: return None, UnexpectedValueException(name(self)) begin = d.get("begin", None) if begin and t < begin: return None, UnexpectedValueException(name(self)) end = d.get("end", None) if end and t > end: return None, UnexpectedValueException(name(self)) check = d.get("check", None) if check: return check(v) cls = d["cls"] if isinstance(v, (cls, )): return v, None if cls is int: return t, None if cls is str: if isinstance(v, datetime.datetime): return v.strftime(layout), None return datetime.datetime.fromtimestamp(v).strftime(layout), None # cls is datetime.datetime if isinstance(v, str): return datetime.datetime.strptime(v, layout), None return datetime.datetime.fromtimestamp(v), None
def validate( self, v: typing.Any ) -> typing.Tuple[typing.Any, VldBaseException | None]: if not isinstance(v, typing.List): return None, UnexpectedTypeException(name(self)) d = kw(self) seq_min_size = d.get("minsize", None) if seq_min_size and len(v) < seq_min_size: return None, UnexpectedValueException(name(self)) seq_max_size = d.get("maxsize", None) if seq_max_size and len(v) > seq_max_size: return None, UnexpectedValueException(name(self)) ele: Validator | None = d.get("ele", None) if ele: if d.get("newcontainer", False): _v = [] for idx, item in enumerate(v): _item, err = ele.validate(item) if err is not None: return None, err _v.append(_item) v = _v else: for idx, item in enumerate(v): _item, err = ele.validate(item) if err is not None: return None, err v[idx] = _item check = d.get("check", None) if check: return check(v) return v, None
def __init__(self, opts: Options = None): super().__init__(opts) d = kw(self) if "minlen" not in d: d["minlen"] = 1
def name(v: Validator): return kw(v)["name"]
def __init__(self, cls: typing.Type[enum.Enum], opts: Options = None): super().__init__(opts) d = kw(self) d["enum"] = cls