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
