class SessionSettings(types.Type):
cookie_name = validators.String(default='session_id')
cookie_age = validators.Integer(allow_null=True)
cookie_domain = validators.String(allow_null=True)
cookie_path = validators.String(default='/')
cookie_secure = validators.Boolean(default=False)
cookie_httponly = validators.Boolean(default=False)
class LogGame(types.Type):
season: int = validators.Number(
1, 11, description="Overwatch season from 1 to 11.")
sr: int = validators.Number(
0, 5000, description="You SR at the end of the game from 0 to 5000.")
map: str = validators.String(
enum=MAP_CHOICES,
allow_null=True,
description=f"Name of the map the game was played.",
)
heroes: List[str] = validators.Array(
items=validators.String(enum=HERO_CHOICES),
unique_items=True,
allow_null=True,
description=f"List of heroes name that you played for that game.",
)
comment: str = validators.String(
allow_null=True,
description="Free text field to leave a comment for that game.")
thrower_team: bool = validators.Boolean(
allow_null=True, description="If there was a thrower in your team.")
thrower_enemy_team: bool = validators.Boolean(
allow_null=True,
description="If there was a thrower in the enemy team.")
leaver_team: bool = validators.Boolean(
allow_null=True, description="If there was a leaver on your team.")
leaver_enemy_team: bool = validators.Boolean(
allow_null=True,
description="If there was a leaver on the enemy team.")
group_with: List[str] = validators.Array(
items=validators.String(),
allow_null=True,
unique_items=True,
description="List of people of you grouped with for this game.",
)
class CsrfSettings(types.Type):
CSRF_COOKIE_NAME = validators.String(default='csrftoken')
CSRF_COOKIE_AGE = validators.Integer(default=60 * 60 * 24 * 7 * 52)
CSRF_COOKIE_DOMAIN = validators.String(allow_null=True)
CSRF_COOKIE_PATH = validators.String(default='/')
CSRF_COOKIE_SECURE = validators.Boolean(default=False)
CSRF_COOKIE_HTTPONLY = validators.Boolean(default=False)
CSRF_HEADER_NAME = validators.String(default='HTTP_X_CSRFTOKEN')
CSRF_TOKEN_FIELD_NAME = validators.String(default='csrf_token')
CSRF_TRUSTED_ORIGINS = validators.Array(default=[])
class FeatureUpdate(types.Type):
version = validators.String(description="The feature number version.")
enabled = validators.Boolean()
deny = validators.Boolean()
services = validators.Array(
unique_items=True,
items=validators.Integer(),
allow_null=True,
description="Array with services allowed to access the feature.",
)
def generate_fields(self, url, method, handler):
fields = []
path_names = [
item.strip("{}").lstrip("+")
for item in re.findall("{[^}]*}", url)
]
parameters = inspect.signature(handler).parameters
for name, param in parameters.items():
if name in path_names:
schema = {
param.empty: None,
int: validators.Integer(),
float: validators.Number(),
str: validators.String(),
}[param.annotation]
field = Field(name=name, location="path", schema=schema)
fields.append(field)
elif param.annotation in (
param.empty,
int,
float,
bool,
str,
http.QueryParam,
):
if param.default is param.empty:
kwargs = {}
elif param.default is None:
kwargs = {"default": None, "allow_null": True}
else:
kwargs = {"default": param.default}
schema = {
param.empty: None,
int: validators.Integer(**kwargs),
float: validators.Number(**kwargs),
bool: validators.Boolean(**kwargs),
str: validators.String(**kwargs),
http.QueryParam: validators.String(**kwargs),
}[param.annotation]
field = Field(name=name, location="query", schema=schema)
fields.append(field)
elif issubclass(param.annotation, types.Type):
if method in ("GET", "DELETE"):
for (
name,
validator,
) in param.annotation.validator.properties.items():
field = Field(name=name,
location="query",
schema=validator)
fields.append(field)
else:
field = Field(name=name,
location="body",
schema=param.annotation.validator)
fields.append(field)
return fields
def resolve(self, parameter: inspect.Parameter,
path_params: ValidatedPathParams,
query_params: ValidatedQueryParams):
params = path_params if (parameter.name
in path_params) else query_params
has_default = parameter.default is not parameter.empty
allow_null = parameter.default is None
param_validator = {
parameter.empty: validators.Any(),
str: validators.String(allow_null=allow_null),
int: validators.Integer(allow_null=allow_null),
float: validators.Number(allow_null=allow_null),
bool: validators.Boolean(allow_null=allow_null)
}[parameter.annotation]
validator = validators.Object(
properties=[(parameter.name, param_validator)],
required=[] if has_default else [parameter.name])
try:
params = validator.validate(params, allow_coerce=True)
except validators.ValidationError as exc:
raise exceptions.NotFound(exc.detail)
return params.get(parameter.name, parameter.default)
class BaseExtractionJSONParams(CoercingType):
"""Common extraction parameters validator"""
domains = validators.Array(
items=DomainValidator(enum=list(TAG_DOMAINS.keys())),
unique_items=True,
description=
'List of domains to search, if not provided ALL domains will be included',
allow_null=True,
)
offset = validators.Integer(minimum=0,
allow_null=True,
description='The paging offset')
limit = validators.Integer(
minimum=1,
maximum=10000,
default=10,
allow_null=True,
description='The paging limit.',
)
min_score = validators.Number(
minimum=0.1,
allow_null=True,
description=
'The minimum search score required. No default is applied when not provided. '
'Ignored when `constant_score` is on.',
)
constant_score = validators.Boolean(
default=True,
allow_null=False,
description=
'Disables relevance scoring when `True`. All results will have score `1`.',
)
class Case(types.Type):
"""
# 条件表
"""
name = validators.String(max_length=255, title=u"条件名称")
desc = validators.String(allow_null=True, title=u'条件描述')
sql = validators.String(title=u'条件sql')
no_data_pass = validators.Boolean(default=True, title=u'无数据满足')
class PuppyOutputType(types.Type):
id = validators.Number(title="id", description="ID")
name = validators.String(title="name", description="Name")
number = validators.Integer(title="number", description="Number")
time = validators.DateTime(title="time", description="Time")
float = validators.Number(title="float",
description="Float",
allow_null=True)
bool = validators.Boolean(title="bool", description="Boolean")
class Device(types.Type):
id = validators.Integer(allow_null=True, minimum=1, maximum=999)
device_model = validators.String(enum=list(DEVICE_MODELS))
ip_address = validators.String(default='127.0.0.1')
remote_access_type = validators.String(
enum=['ssh', 'telnet', 'http', 'https'], default='ssh')
login = validators.String(default='cisco')
password = validators.String(default='cisco', min_length=5)
secret = validators.String(default='cisco', min_length=5)
apc = validators.Boolean(default=False)
free_access_to_site = validators.Boolean(default=True)
start_date = validators.Date(default=DEFAULT_DATE)
company_name = validators.String(allow_null=True)
city = validators.String(allow_null=True)
city_address = validators.String(allow_null=True)
owner = validators.String(allow_null=True)
phone = validators.String(min_length=12, max_length=12)
email = validators.String(allow_null=True)
class PuppyInputType(types.Type):
name = validators.String(title="name", description="Name")
number = validators.Integer(title="number",
description="Number",
default=0)
time = validators.DateTime(title="time", description="Time")
float = validators.Number(title="float",
description="Float",
allow_null=True)
bool = validators.Boolean(title="bool",
description="Boolean",
default=False)
def generate_fields(self, url, method, handler):
fields = []
path_names = [
item.strip('{}').lstrip('+')
for item in re.findall('{[^}]*}', url)
]
parameters = inspect.signature(handler).parameters
for name, param in parameters.items():
if name in path_names:
schema = {
param.empty: None,
int: validators.Integer(),
float: validators.Number(),
str: validators.String()
}[param.annotation]
field = Field(name=name, location='path', schema=schema)
fields.append(field)
elif param.annotation in (param.empty, int, float, bool, str,
http.QueryParam):
if param.default is param.empty:
kwargs = {}
elif param.default is None:
kwargs = {'default': None, 'allow_null': True}
else:
kwargs = {'default': param.default}
schema = {
param.empty: None,
int: validators.Integer(**kwargs),
float: validators.Number(**kwargs),
bool: validators.Boolean(**kwargs),
str: validators.String(**kwargs),
http.QueryParam: validators.String(**kwargs),
}[param.annotation]
field = Field(name=name, location='query', schema=schema)
fields.append(field)
elif issubclass(param.annotation, types.Type):
if method in ('GET', 'DELETE'):
for name, validator in param.annotation.validator.properties.items(
):
field = Field(name=name,
location='query',
schema=validator)
fields.append(field)
else:
field = Field(name=name,
location='body',
schema=param.annotation.validator)
fields.append(field)
return fields
class InternetAccessBlock(BaseBlock):
BLOCK_TYPE = "internet_access"
wifi = validators.Boolean()
@classmethod
def from_es(cls, es_poi, lang):
properties = es_poi.get("properties", {})
wifi = properties.get("wifi")
internet_access = properties.get("internet_access")
has_wifi = wifi in ("yes",
"free") or internet_access in ("wlan", "wifi",
"yes")
if not has_wifi:
return None
return cls(wifi=has_wifi)
class PatientUpdateSchema(types.Type):
nom = validators.String(max_length=MAX_LENGTH["nom"], default="")
prenom = validators.String(max_length=MAX_LENGTH["prenom"], default="")
ddn = validators.Date(default="")
sexe = validators.String(enum=SEXE, default=None, allow_null=True)
rue = validators.String(description="rue",
max_length=MAX_LENGTH["rue"],
default="")
cp = validators.Integer(description="Code Postal",
default=None,
allow_null=True)
ville = validators.String(description="Ville",
max_length=MAX_LENGTH["ville"],
default="")
tel = validators.String(description="Numéro de Téléphone",
max_length=MAX_LENGTH["tel"],
default="")
email = validators.String(description="email",
max_length=MAX_LENGTH["email"],
default="")
alive = validators.Boolean(description="vivant ?",
default=None,
allow_null=True)
class OpeningHourBlock(BaseBlock):
BLOCK_TYPE = 'opening_hours'
STATUSES = ['open', 'closed']
status = validators.String(enum=STATUSES)
next_transition_datetime = validators.String(allow_null=True)
seconds_before_next_transition = validators.Integer(allow_null=True)
is_24_7 = validators.Boolean()
raw = validators.String()
days = validators.Array(items=DaysType)
@classmethod
def init_class(cls, status, next_transition_datetime, time_before_next, oh,
poi_dt, raw):
if raw == '24/7' or oh.is_24_7:
return cls(status=status,
next_transition_datetime=None,
seconds_before_next_transition=None,
is_24_7=True,
raw=oh.field,
days=get_days(cls, oh, poi_dt))
if all(r.status == 'closed' for r in oh.rules):
# Ignore opening_hours such as "Apr 1-Sep 30: off", causing overflow
return None
return cls(status=status,
next_transition_datetime=next_transition_datetime,
seconds_before_next_transition=time_before_next,
is_24_7=oh.is_24_7,
raw=oh.field,
days=get_days(cls, oh, poi_dt))
@classmethod
def from_es(cls, es_poi, lang):
return parse_time_block(cls, es_poi, lang,
es_poi.get_raw_opening_hours())
validators.String() | validators.Array(items=validators.String())),
('enum', validators.Array(unique_items=True, min_items=1)),
('definitions',
validators.Object(
additional_properties=validators.Ref('JSONSchema'))),
# String
('minLength', validators.Integer(minimum=0)),
('maxLength', validators.Integer(minimum=0)),
('pattern', validators.String(format='regex')),
('format', validators.String()),
# Numeric
('minimum', validators.Number()),
('maximum', validators.Number()),
('exclusiveMinimum', validators.Boolean()),
('exclusiveMaximum', validators.Boolean()),
('multipleOf', validators.Number(minimum=0.0, exclusive_minimum=True)),
# Object
('properties',
validators.Object(additional_properties=validators.Ref('JSONSchema'))
),
('minProperties', validators.Integer(minimum=0)),
('maxProperties', validators.Integer(minimum=0)),
('patternProperties',
validators.Object(
additional_properties=validators.Ref('JSONSchema'))),
('additionalProperties',
validators.Ref('JSONSchema') | validators.Boolean()),
('required',
class Env(types.Type):
debug = validators.Boolean(default=True),
udp_ip = validators.String(default=os.environ['UDP_IP'] if os.
environ['UDP_IP'] else '172.17.10.20')
udp_port = validators.Number(default=int(os.environ['UDP_PORT']) if os.
environ['UDP_PORT'] else 10001)
("tags", validators.Array(items=validators.String())),
("summary", validators.String()),
("description", validators.String(format="textarea")),
("externalDocs", validators.Ref("ExternalDocumentation")),
("operationId", validators.String()),
(
"parameters",
validators.Array(items=validators.Ref("Parameter")),
), # TODO: | ReferenceObject
(
"requestBody",
REQUESTBODY_REF | validators.Ref("RequestBody"),
), # TODO: RequestBody | ReferenceObject
("responses", validators.Ref("Responses")),
# TODO: 'callbacks'
("deprecated", validators.Boolean()),
("security",
validators.Array(validators.Ref("SecurityRequirement"))),
("servers", validators.Array(items=validators.Ref("Server"))),
],
pattern_properties={"^x-": validators.Any()},
additional_properties=False,
),
"ExternalDocumentation":
validators.Object(
properties=[
("description", validators.String(format="textarea")),
("url", validators.String(format="url")),
],
pattern_properties={"^x-": validators.Any()},
additional_properties=False,
class LightState(types.Type):
is_on = validators.Boolean(default=False,
description="Should the lights be on")
def generate_fields(self, url, method, handler):
if not self.documented:
return []
fields = []
for name, param in signature(handler).parameters.items():
if issubclass(param.annotation, _PathParam):
if issubclass(param.annotation, int):
validator_cls = validators.Integer
elif issubclass(param.annotation, float):
validator_cls = validators.Number
elif issubclass(param.annotation, str):
validator_cls = validators.String
else:
raise exceptions.ConfigurationError(
f"Cannot handle {name} of {handler}")
location = 'path'
schema = validator_cls()
field = Field(name=name, location=location, schema=schema)
fields.append(field)
elif issubclass(param.annotation, _QueryParam):
if param.default is param.empty:
kwargs = {}
elif param.default is None:
# TODO handle Optional
kwargs = {'default': None, 'allow_null': True}
else:
kwargs = {'default': param.default}
if issubclass(param.annotation, int):
validator_cls = validators.Integer
elif issubclass(param.annotation, float):
validator_cls = validators.Number
elif issubclass(param.annotation, str):
validator_cls = validators.String
elif getattr(param.annotation, '__bool__', None):
validator_cls = validators.Boolean
else:
raise exceptions.ConfigurationError(
f"Cannot handle {name} of {handler}")
location = 'query'
schema = validator_cls(**kwargs)
field = Field(name=name, location=location, schema=schema)
fields.append(field)
elif issubclass(param.annotation, _BodyData):
location = 'body'
schema = validators.Object()
field = Field(name=name, location=location, schema=schema)
fields.append(field)
elif issubclass(param.annotation, ParamData):
raise exceptions.ConfigurationError(
f"{param.annotation} do not support documentation.")
else:
# fallback to original generate_fields() method
path_names = [
item.strip('{}').lstrip('+')
for item in re.findall('{[^}]*}', url)
]
if name in path_names:
schema = {
param.empty: None,
int: validators.Integer(),
float: validators.Number(),
str: validators.String()
}[param.annotation]
field = Field(name=name, location='path', schema=schema)
fields.append(field)
elif param.annotation in (param.empty, int, float, bool, str,
http.QueryParam):
if param.default is param.empty:
kwargs = {}
elif param.default is None:
kwargs = {'default': None, 'allow_null': True}
else:
kwargs = {'default': param.default}
schema = {
param.empty: None,
int: validators.Integer(**kwargs),
float: validators.Number(**kwargs),
bool: validators.Boolean(**kwargs),
str: validators.String(**kwargs),
http.QueryParam: validators.String(**kwargs),
}[param.annotation]
field = Field(name=name, location='query', schema=schema)
fields.append(field)
elif issubclass(param.annotation, types.Type):
if method in ('GET', 'DELETE'):
items = param.annotation.validator.properties.items()
for name, validator in items:
field = Field(name=name,
location='query',
schema=validator)
fields.append(field)
else:
field = Field(name=name,
location='body',
schema=param.annotation.validator)
fields.append(field)
return fields
class OpeningHourBlock(BaseBlock):
BLOCK_TYPE = 'opening_hours'
status = validators.String(enum=['open', 'closed'])
next_transition_datetime = validators.String(allow_null=True)
seconds_before_next_transition = validators.Integer(allow_null=True)
is_24_7 = validators.Boolean()
raw = validators.String()
days = validators.Array(items=DaysType)
@classmethod
def from_es(cls, es_poi, lang):
raw = es_poi.get('properties', {}).get('opening_hours')
if raw is None:
return None
poi_coord = get_coord(es_poi)
poi_lat = poi_coord[0]
poi_lon = poi_coord[1]
is247 = raw == '24/7'
poi_tzname = tz.tzNameAt(poi_lat, poi_lon, forceTZ=True)
poi_tz = get_tz(poi_tzname, poi_lat, poi_lon)
poi_location = (poi_lat, poi_lon, poi_tzname, 24)
if poi_tz is None:
logger.info("No timezone found for poi %s", es_poi.get('id'))
return None
try:
oh = hoh.OHParser(raw, location=poi_location)
except HOHError:
logger.info("Failed to parse OSM opening_hour field",
exc_info=True)
return None
poi_dt = UTC.localize(datetime.utcnow()).astimezone(poi_tz)
if oh.is_open(poi_dt.replace(tzinfo=None)):
status = 'open'
else:
status = 'closed'
if is247:
return cls(status=status,
next_transition_datetime=None,
seconds_before_next_transition=None,
is_24_7=is247,
raw=oh.field,
days=cls.get_days(oh, dt=poi_dt))
# The current version of the hoh lib doesn't allow to use the next_change() function
# with an offset aware datetime.
# This is why we replace the timezone info until this problem is fixed in the library.
try:
nt = oh.next_change(dt=poi_dt.replace(tzinfo=None))
except HOHError:
logger.info(
"HOHError: Failed to compute next transition for poi %s",
es_poi.get('id'),
exc_info=True)
return None
# Then we localize the next_change transition datetime in the local POI timezone.
next_transition = poi_tz.localize(nt.replace(tzinfo=None))
next_transition = cls.round_dt_to_minute(next_transition)
next_transition_datetime = next_transition.isoformat()
delta = next_transition - poi_dt
time_before_next = int(delta.total_seconds())
return cls(status=status,
next_transition_datetime=next_transition_datetime,
seconds_before_next_transition=time_before_next,
is_24_7=is247,
raw=oh.field,
days=cls.get_days(oh, dt=poi_dt))
@staticmethod
def round_dt_to_minute(dt):
dt += timedelta(seconds=30)
return dt.replace(second=0, microsecond=0)
@staticmethod
def round_time_to_minute(t):
dt = datetime.combine(date(2000, 1, 1), t)
rounded = OpeningHourBlock.round_dt_to_minute(dt)
return rounded.time()
@classmethod
def get_days(cls, oh_parser, dt):
last_monday = dt.date() - timedelta(days=dt.weekday())
days = []
for x in range(0, 7):
day = last_monday + timedelta(days=x)
oh_day = oh_parser.get_day(day)
periods = oh_day.opening_periods()
day_value = {
'dayofweek': day.isoweekday(),
'local_date': day.isoformat(),
'status': 'open' if len(periods) > 0 else 'closed',
'opening_hours': []
}
for beginning_dt, end_dt in periods:
if beginning_dt.date() < day:
continue
beginning = cls.round_time_to_minute(beginning_dt.time())
end = cls.round_time_to_minute(end_dt.time())
day_value['opening_hours'].append({
'beginning':
beginning.strftime('%H:%M'),
'end':
end.strftime('%H:%M')
})
days.append(day_value)
return days
'Operation':
validators.Object(
properties=[
('tags', validators.Array(items=validators.String())),
('summary', validators.String()),
('description', validators.String(format='textarea')),
('externalDocs', validators.Ref('ExternalDocumentation')),
('operationId', validators.String()),
('consumes', validators.Array(items=validators.String())),
('produces', validators.Array(items=validators.String())),
('parameters',
validators.Array(items=validators.Ref('Parameter'))
), # TODO: | ReferenceObject
('responses', validators.Ref('Responses')),
('schemes', validators.Array(items=validators.String())),
('deprecated', validators.Boolean()),
('security',
validators.Array(validators.Ref('SecurityRequirement'))),
],
pattern_properties={
'^x-': validators.Any(),
},
additional_properties=False,
),
'ExternalDocumentation':
validators.Object(properties=[
('description', validators.String(format='textarea')),
('url', validators.String(format='url')),
],
pattern_properties={
'^x-': validators.Any(),
def load_type(typename, struct, allow_null):
attrs = {"allow_null": True} if allow_null else {}
if typename == "string":
if "minLength" in struct:
attrs["min_length"] = struct["minLength"]
if "maxLength" in struct:
attrs["max_length"] = struct["maxLength"]
if "pattern" in struct:
attrs["pattern"] = struct["pattern"]
if "format" in struct:
attrs["format"] = struct["format"]
return validators.String(**attrs)
if typename in ["number", "integer"]:
if "minimum" in struct:
attrs["minimum"] = struct["minimum"]
if "maximum" in struct:
attrs["maximum"] = struct["maximum"]
if "exclusiveMinimum" in struct:
attrs["exclusive_minimum"] = struct["exclusiveMinimum"]
if "exclusiveMaximum" in struct:
attrs["exclusive_maximum"] = struct["exclusiveMaximum"]
if "multipleOf" in struct:
attrs["multiple_of"] = struct["multipleOf"]
if "format" in struct:
attrs["format"] = struct["format"]
if typename == "integer":
return validators.Integer(**attrs)
return validators.Number(**attrs)
if typename == "boolean":
return validators.Boolean(**attrs)
if typename == "object":
if "properties" in struct:
attrs["properties"] = dict_type(
[(key, decode(value)) for key, value in struct["properties"].items()]
)
if "required" in struct:
attrs["required"] = struct["required"]
if "minProperties" in struct:
attrs["min_properties"] = struct["minProperties"]
if "maxProperties" in struct:
attrs["max_properties"] = struct["maxProperties"]
if "required" in struct:
attrs["required"] = struct["required"]
if "patternProperties" in struct:
attrs["pattern_properties"] = dict_type(
[
(key, decode(value))
for key, value in struct["patternProperties"].items()
]
)
if "additionalProperties" in struct:
if isinstance(struct["additionalProperties"], bool):
attrs["additional_properties"] = struct["additionalProperties"]
else:
attrs["additional_properties"] = decode(struct["additionalProperties"])
return validators.Object(**attrs)
if typename == "array":
if "items" in struct:
if isinstance(struct["items"], list):
attrs["items"] = [decode(item) for item in struct["items"]]
else:
attrs["items"] = decode(struct["items"])
if "additionalItems" in struct:
if isinstance(struct["additionalItems"], bool):
attrs["additional_items"] = struct["additionalItems"]
else:
attrs["additional_items"] = decode(struct["additionalItems"])
if "minItems" in struct:
attrs["min_items"] = struct["minItems"]
if "maxItems" in struct:
attrs["max_items"] = struct["maxItems"]
if "uniqueItems" in struct:
attrs["unique_items"] = struct["uniqueItems"]
return validators.Array(**attrs)
assert False
("$ref", validators.String()),
("type", validators.String() | validators.Array(items=validators.String())),
("enum", validators.Array(unique_items=True, min_items=1)),
(
"definitions",
validators.Object(additional_properties=validators.Ref("JSONSchema")),
),
# String
("minLength", validators.Integer(minimum=0)),
("maxLength", validators.Integer(minimum=0)),
("pattern", validators.String(format="regex")),
("format", validators.String()),
# Numeric
("minimum", validators.Number()),
("maximum", validators.Number()),
("exclusiveMinimum", validators.Boolean()),
("exclusiveMaximum", validators.Boolean()),
("multipleOf", validators.Number(minimum=0.0, exclusive_minimum=True)),
# Object
(
"properties",
validators.Object(additional_properties=validators.Ref("JSONSchema")),
),
("minProperties", validators.Integer(minimum=0)),
("maxProperties", validators.Integer(minimum=0)),
(
"patternProperties",
validators.Object(additional_properties=validators.Ref("JSONSchema")),
),
("additionalProperties", validators.Ref("JSONSchema") | validators.Boolean()),
(
class Prisoner(types.Type): bracelet_ip = validators.String(max_length=100) wanted = validators.Boolean(default=False) username = validators.String(max_length=30) latitude = validators.Number(maximum=90, minimum=-90) longitude = validators.Number(maximum=180, minimum=-180)
class EventLogPlugin(types.Type):
name = validators.String(max_length=100)
rating = validators.Integer(minimum=1, maximum=5)
in_stock = validators.Boolean(default=False)
size = validators.String(enum=['small', 'medium', 'large'])
from apistar import types, validators
SETTINGS_VALIDATOR = validators.Object(
properties={
'enforce_https': validators.Boolean(default=False),
'mode': validators.String(
default='proxy',
enum=['proxy', 'redirect'],
),
},
default={
'enforce_https': False,
'mode': 'proxy',
},
)
class RouteWithoutSource(types.Type):
target = validators.String()
settings = SETTINGS_VALIDATOR
class Route(types.Type):
source = validators.String()
target = validators.String()
settings = SETTINGS_VALIDATOR
'Operation':
validators.Object(
properties=[
('tags', validators.Array(items=validators.String())),
('summary', validators.String()),
('description', validators.String(format='textarea')),
('externalDocs', validators.Ref('ExternalDocumentation')),
('operationId', validators.String()),
('consumes', validators.Array(items=validators.String())),
('produces', validators.Array(items=validators.String())),
('parameters',
validators.Array(items=validators.Ref('Parameter'))
), # TODO: | ReferenceObject
('responses', validators.Ref('Responses')),
('schemes', validators.Array(items=validators.String())),
('deprecated', validators.Boolean()),
('security',
validators.Array(validators.Ref('SecurityRequirement'))),
],
pattern_properties={
'^x-': validators.Any(),
},
additional_properties=False,
),
'ExternalDocumentation':
validators.Object(properties=[
('description', validators.String(format='textarea')),
('url', validators.String(format='url')),
],
pattern_properties={
'^x-': validators.Any(),
def load_type(typename, struct, allow_null):
attrs = {'allow_null': True} if allow_null else {}
if typename == 'string':
if 'minLength' in struct:
attrs['min_length'] = struct['minLength']
if 'maxLength' in struct:
attrs['max_length'] = struct['maxLength']
if 'pattern' in struct:
attrs['pattern'] = struct['pattern']
if 'format' in struct:
attrs['format'] = struct['format']
return validators.String(**attrs)
if typename in ['number', 'integer']:
if 'minimum' in struct:
attrs['minimum'] = struct['minimum']
if 'maximum' in struct:
attrs['maximum'] = struct['maximum']
if 'exclusiveMinimum' in struct:
attrs['exclusive_minimum'] = struct['exclusiveMinimum']
if 'exclusiveMaximum' in struct:
attrs['exclusive_maximum'] = struct['exclusiveMaximum']
if 'multipleOf' in struct:
attrs['multiple_of'] = struct['multipleOf']
if 'format' in struct:
attrs['format'] = struct['format']
if typename == 'integer':
return validators.Integer(**attrs)
return validators.Number(**attrs)
if typename == 'boolean':
return validators.Boolean(**attrs)
if typename == 'object':
if 'properties' in struct:
attrs['properties'] = dict_type([
(key, decode(value))
for key, value in struct['properties'].items()
])
if 'required' in struct:
attrs['required'] = struct['required']
if 'minProperties' in struct:
attrs['min_properties'] = struct['minProperties']
if 'maxProperties' in struct:
attrs['max_properties'] = struct['maxProperties']
if 'required' in struct:
attrs['required'] = struct['required']
if 'patternProperties' in struct:
attrs['pattern_properties'] = dict_type([
(key, decode(value))
for key, value in struct['patternProperties'].items()
])
if 'additionalProperties' in struct:
if isinstance(struct['additionalProperties'], bool):
attrs['additional_properties'] = struct['additionalProperties']
else:
attrs['additional_properties'] = decode(
struct['additionalProperties'])
return validators.Object(**attrs)
if typename == 'array':
if 'items' in struct:
if isinstance(struct['items'], list):
attrs['items'] = [decode(item) for item in struct['items']]
else:
attrs['items'] = decode(struct['items'])
if 'additionalItems' in struct:
if isinstance(struct['additionalItems'], bool):
attrs['additional_items'] = struct['additionalItems']
else:
attrs['additional_items'] = decode(struct['additionalItems'])
if 'minItems' in struct:
attrs['min_items'] = struct['minItems']
if 'maxItems' in struct:
attrs['max_items'] = struct['maxItems']
if 'uniqueItems' in struct:
attrs['unique_items'] = struct['uniqueItems']
return validators.Array(**attrs)
assert False
