def make_schema(cls, **kwargs): """ Requires a class Returns a colander schema """ schema = SchemaNode(Mapping()) columns = make_columns(cls) map(lambda elem: columns.pop(elem), kwargs.get('excludes', [])) # remove the id from the form columns.pop('id') if 'type' in columns.keys(): columns.pop('type') if 'uuid' in columns.keys(): columns.pop('uuid') for k, v in columns.iteritems(): if isinstance(v, list): values = [] for elem in v[1]: values.append((elem[1], elem[2])) schema.add(SchemaNode( String(), widget=widget.SelectWidget(values=values), name=k )) else: schema.add(SchemaNode(v(), name=k)) return schema
def test_invalid(self): from colander import Invalid, SchemaNode n = SchemaNode(JobQuery.File(), name='filefield') with self.assertRaises(Invalid) as e: n.deserialize(12345) self.assertDictEqual(e.exception.asdict(), {'filefield': '12345 is not a cgi.FieldStorage'})
class ItemsValid(object): def __init__(self, field): fieldtype = field['type'] nodetype = registry.validation(fieldtype, **field) self.schema = SchemaNode(Sequence(), nodetype) def __call__(self, node, value): self.schema.deserialize(value)
def users(request): db = request.db # Schema schema = SchemaNode(Mapping(), SchemaNode(Integer(), name='id')) payload = schema.deserialize(request.json) users = User.by_params(db, **payload) return users
def user_by_key(request): db = request.db # Schema schema = SchemaNode(Mapping(), SchemaNode(String(), name='key_key')) payload = schema.deserialize(request.json) key = Key.by_key_key(db, payload['key_key']) if key: return key.user
def deserialize(self, cstruct=null): if cstruct: self.children = [] self.add(SchemaNode(String(), name='title', missing=drop)) self.add(SchemaNode(String(), name='description', missing=drop)) roles = [key for key in six.iterkeys(cstruct) if key not in ('title', 'description')] for key in roles: permSchema = SchemaNode(Mapping(unknown='raise'), name=key) for domain in ('definition', 'records', 'users', 'policy'): permSchema.add(self._crudSchema(domain)) self.add(permSchema) return super(PolicyValidator, self).deserialize(cstruct)
def apps_create(request): db = request.db schema = SchemaNode(Mapping(), SchemaNode(String(), name='name')) payload = schema.deserialize(request.json) app = App(created=datetime.datetime.now(), name=payload['name'], user=request.user) db.add(app) db.flush() return app
def add_post_data_subschemas(node: SchemaNode, kw: dict): """Add the resource sheet colander schemas that are 'creatable'.""" context = kw['context'] request = kw['request'] content_type = _get_resource_type_based_on_request_type(request) try: iresource = ContentType().deserialize(content_type) except colander.Invalid: return # the content type is validated later, so we just ignore errors registry = request.registry.content creates = registry.get_sheets_create(context, request, iresource) for sheet in creates: name = sheet.meta.isheet.__identifier__ is_mandatory = sheet.meta.create_mandatory missing = colander.required if is_mandatory else colander.drop schema = sheet.meta.schema_class(name=name, missing=missing) node.add(schema.bind(**kw))
def definition(cls): schema = SchemaNode(Mapping()) schema.add(SchemaNode(String(), name='name')) schema.add(SchemaNode(String(), name='description', missing='')) schema.add(SchemaNode(String(), name='type', validator=OneOf(registry.names))) return schema
def _crudSchema(self, domain): crudSchema = SchemaNode(Mapping(unknown='raise'), name=domain, missing=drop) crudSchema.add(SchemaNode(Boolean(), name='create', missing=drop)) crudSchema.add(SchemaNode(Boolean(), name='read', missing=drop)) crudSchema.add(SchemaNode(Boolean(), name='update', missing=drop)) crudSchema.add(SchemaNode(Boolean(), name='delete', missing=drop)) return crudSchema
def keys_add(request): db = request.db schema = SchemaNode(Mapping(), SchemaNode(String(), name='key_type'), SchemaNode(String(), name='key_key'), SchemaNode(String(), name='key_comment')) payload = schema.deserialize(request.json) key = Key.by_key_key(db, payload['key_key']) if not key: key = Key(created=datetime.datetime.now(), key_type=payload['key_type'], key_key=payload['key_key'], key_comment=payload['key_comment'], user=request.user) db.add(key) return key
class StatusSchema(MappingSchema): """Base status response schema""" status = SchemaNode(String(), title=_("Response status"), validator=OneOf(('success', 'error')))
def definition(cls): schema = SchemaNode(Mapping()) schema.add(SchemaNode(String(), name='name', validator=Regex(r'^[a-zA-Z][a-zA-Z0-9_\-]*$'))) schema.add(SchemaNode(String(), name='label', missing=u'')) schema.add(SchemaNode(String(), name='hint', missing=cls.hint)) schema.add(SchemaNode(Boolean(), name='required', missing=cls.required)) schema.add(SchemaNode(String(), name='type', validator=OneOf(registry.names))) return schema
class ComicSchema(MappingSchema): title = SchemaNode(String(encoding='utf-8'), validator=Length(max=64))
class DefaultSchema(MappingSchema): foo = SchemaNode(String(), type="str", location="querystring", missing="foo") bar = SchemaNode(String(), type="str", location="querystring", default="bar") class DefaultValueSchema(MappingSchema): foo = SchemaNode(Int(), type="int") bar = SchemaNode(Int(), type="int", missing=10) class QsSchema(MappingSchema): foo = SchemaNode(String(), type="str", location="querystring", missing=drop) class StrictQsSchema(StrictMappingSchema): foo = SchemaNode(String(), type="str", location="querystring", missing=drop) imperative_schema = SchemaNode(Mapping()) imperative_schema.add(SchemaNode(String(), name="foo", type="str")) imperative_schema.add(SchemaNode(String(), name="bar", type="str", location="body")) imperative_schema.add(SchemaNode(String(), name="baz", type="str", location="querystring")) class TestingSchemaWithHeader(MappingSchema): foo = SchemaNode(String(), type="str") bar = SchemaNode(String(), type="str", location="body") baz = SchemaNode(String(), type="str", location="querystring") qux = SchemaNode(String(), type="str", location="header") class PreserveUnkownSchema(MappingSchema): bar = SchemaNode(String(), type="str") @staticmethod def schema_type():
class RunningAverageSchema(base_schema.ObjType): 'Time series object schema' timeseries = TimeSeriesSchema(missing=drop) name = 'running average' past_hours_to_average = SchemaNode(Float(), missing=drop)
class MySchema(MappingSchema): name = SchemaNode(String()) title = SchemaNode(String()) cool = SchemaNode(Boolean(), default=True, missing=True) series = SeriesSchema()
class DatesSchema(SequenceSchema): date = SchemaNode(Date())
class ChemicalDispersionSchema(WeathererSchema): fraction_sprayed = SchemaNode(Float(), validator=Range(0, 1.0)) efficiency = SchemaNode(Float(), missing=drop, validator=Range(0, 1.0))
class SkimmerSchema(WeathererSchema): amount = SchemaNode(Float()) units = SchemaNode(String()) efficiency = SchemaNode(Float())
class VariableSchema(VariableSchemaBase): varname = SchemaNode( String(), missing=drop, read_only=True )
class GridSchema(base_schema.ObjTypeSchema): name = SchemaNode(String(), test_equal=False) #remove this once gridded stops using _def_count filename = FilenameSchema( isdatafile=True, test_equal=False, update=False )
class MergeSchema(MappingSchema): source_document_id = SchemaNode(Integer(), missing=required) target_document_id = SchemaNode(Integer(), missing=required)
class HalfLifeWeathererSchema(WeathererSchema): half_lives = SchemaNode(NumpyArray())
class ClaimsSchema(ClaimsObjectSchema): """Token claims schema""" sub = SchemaNode(String(), title=_("Principal ID")) iat = SchemaNode(Int(), title=_("Token issue timestamp, in seconds")) exp = SchemaNode(Int(), title=_("Token expiration timestamp, in seconds"))
class ClaimsObjectSchema(MappingSchema): """Claims getter schema""" obj = SchemaNode(String(), title=_("Token object"), validator=OneOf((ACCESS_OBJECT, REFRESH_OBJECT)), missing=drop)
class WindageSchema(TupleSchema): min_windage = SchemaNode(Float(), validator=Range(0, 1.0), default=0.01) max_windage = SchemaNode(Float(), validator=Range(0, 1.0), default=0.04) name = 'windage_range'
class SourceSchema(MappingSchema): url = SchemaNode(String(), validator=colander.url) active = SchemaNode(Boolean(), missing=False)
class SeriesSchema(MappingSchema): name = SchemaNode(String()) dates = DatesSchema()
class MediaSchema(MappingSchema): license = default_schema_node() url = SchemaNode(String(), validator=colander.url)
class UVTuple(DefaultTupleSchema): 'Tide object schema' u = SchemaNode(Float()) v = SchemaNode(Float())
class EventSchema(MappingSchema): id = SchemaNode(String(), missing=drop, validator=Length(1, SAFE_MAX_LENGTH)) provider_id = default_schema_node() title = SchemaNode(String(), missing='', validator=Length(1, SAFE_MAX_LENGTH)) email = SchemaNode(String(), validator=colander.Email()) firstname = default_schema_node() lastname = default_schema_node() telephone = default_schema_node() description = SchemaNode(String(), missing='') event_id = default_schema_node() email = SchemaNode(String(), missing='', validator=colander.Email()) firstname = default_schema_node() language = default_schema_node() lastname = default_schema_node() latlong = default_schema_node() price_information = default_schema_node() organiser = default_schema_node() performers = default_schema_node() press_url = SchemaNode(String(), missing='', validator=colander.url) source_id = default_schema_node() source = default_schema_node() target = default_schema_node() telephone = default_schema_node() url = SchemaNode(String(), missing='', validator=colander.url) location_name = default_schema_node() location_address = default_schema_node() location_post_code = default_schema_node() location_town = default_schema_node() location_capacity = default_schema_node() location_country = default_schema_node() start_time = SchemaNode(DateTime(default_tzinfo=None), preparer=remove_timezone) end_time = SchemaNode(DateTime(default_tzinfo=None), missing=None, preparer=remove_timezone) publication_start = SchemaNode(DateTime(default_tzinfo=None), missing=None, preparer=remove_timezone) publication_end = SchemaNode(DateTime(default_tzinfo=None), missing=None, preparer=remove_timezone) press_contact_email = SchemaNode(String(), missing='', validator=colander.Email()) press_contact_name = default_schema_node() press_contact_phone_number = default_schema_node() ticket_contact_email = SchemaNode(String(), missing='', validator=colander.Email()) ticket_contact_name = default_schema_node() ticket_contact_phone_number = default_schema_node() @instantiate(missing=[]) class videos(SequenceSchema): video = MediaSchema() @instantiate(missing=[]) class sounds(SequenceSchema): sound = MediaSchema() @instantiate(missing=[]) class images(SequenceSchema): image = MediaSchema() @instantiate(missing=[]) class tags(SequenceSchema): name = SchemaNode(String(), validator=Length(1, TAG_MAX_LENGTH)) @instantiate(missing=[]) class categories(SequenceSchema): name = SchemaNode(String(), validator=Length(1, TAG_MAX_LENGTH))
from deform import widget from deform.widget import MappingWidget, SequenceWidget registry = widget.default_resource_registry registry.set_js_resources( "magicsuggest", None, "c2cgeoportal_admin:node_modules/magicsuggest-alpine/magicsuggest-min.js") registry.set_css_resources( "magicsuggest", None, "c2cgeoportal_admin:node_modules/magicsuggest-alpine/magicsuggest-min.css") # temporary workaround for https://github.com/Pylons/deform/pull/369 widget.DateTimeInputWidget._pstruct_schema = SchemaNode( # pylint: disable=protected-access Mapping(), SchemaNode(widget._StrippedString(), name="date"), # pylint: disable=protected-access SchemaNode(widget._StrippedString(), name="time"), # pylint: disable=protected-access SchemaNode(widget._StrippedString(), name="date_submit", missing=""), # pylint: disable=protected-access SchemaNode(widget._StrippedString(), name="time_submit", missing=""), # pylint: disable=protected-access ) class ChildWidget(MappingWidget): template = "child" def serialize(self, field, cstruct, **kw): from c2cgeoportal_commons.models.main import TreeItem # pylint: disable=import-outside-toplevel if cstruct["treeitem_id"] == colander.null: kw["treeitem"] = TreeItem() else:
def default_schema_node(): return SchemaNode(String(), missing='', validator=Length(1, SAFE_MAX_LENGTH))
class Person(SequenceSchema): person = SchemaNode( String(), widget=ExtendedAutocompleteInputWidget( display_value=lambda field, person_id: PERSONS.get(person_id, ''), values='/ajax_search'))
def __init__(self, field): fieldtype = field['type'] nodetype = registry.validation(fieldtype, **field) self.schema = SchemaNode(Sequence(), nodetype)
def definition(cls, **kwargs): schema = SchemaNode(Mapping(unknown="preserve")) schema.add(SchemaNode(String(), name="label", missing=u"")) schema.add(SchemaNode(String(), name="type", validator=OneOf(["annotation"]))) return schema
def _add_node(schema: SchemaNode, node: SchemaNode, name: str): node = node.bind(**schema.bindings) node.name = name schema.add(node)
def definition(cls, **kwargs): schema = SchemaNode(Mapping(unknown="preserve")) if kwargs.get('named', True): schema.add(SchemaNode(String(), name='name', validator=Regex(r'^[a-zA-Z][a-zA-Z0-9_\-]*$'))) schema.add(SchemaNode(String(), name='label', missing=u'')) schema.add(SchemaNode(String(), name='hint', missing=cls.hint)) schema.add(SchemaNode(Boolean(), name='required', missing=cls.required)) schema.add(SchemaNode(String(), name='type', validator=OneOf(registry.names))) return schema
class LoginSchema(ClaimsSetterSchema): """Login schema""" login = SchemaNode(String(), title=_("Login")) password = SchemaNode(String(), title=_("Password"))
def _bind(self, schema: colander.SchemaNode) -> colander.SchemaNode: return schema.bind(context=self.context)
class TokensSchema(StatusSchema): """Tokens response schema""" accessToken = SchemaNode(String(), title=_("Access token")) refreshToken = SchemaNode(String(), title=_("Refresh token"))
class ErrorSchema(MappingSchema): """Base error schema""" status = SchemaNode(String(), title=_("Response status")) message = SchemaNode(String(), title=_("Error message"), missing=drop)
class DeviceIdsSchema(SequenceSchema): device_id = SchemaNode(String())
class tags(SequenceSchema): name = SchemaNode(String(), validator=Length(1, TAG_MAX_LENGTH))
class ClaimsSetterSchema(MappingSchema): """Claims setter schema""" claims = SchemaNode(PropertiesMapping(), title=_("Custom claims"), missing=drop)
bar = SchemaNode(String(), type='str') class StrictMappingSchema(MappingSchema): @staticmethod def schema_type(): return MappingSchema.schema_type(unknown='raise') class StrictSchema(StrictMappingSchema): foo = SchemaNode(String(), type='str', location="body", missing=drop) bar = SchemaNode(String(), type='str', location="body") class NestedSchema(MappingSchema): egg = StrictSchema(location='querystring') ham = StrictSchema(location='body') imperative_schema = SchemaNode(Mapping()) imperative_schema.add(SchemaNode(String(), name='foo', type='str')) imperative_schema.add(SchemaNode(String(), name='bar', type='str', location="body")) imperative_schema.add(SchemaNode(String(), name='baz', type='str', location="querystring")) class TestingSchemaWithHeader(MappingSchema): foo = SchemaNode(String(), type='str') bar = SchemaNode(String(), type='str', location="body") baz = SchemaNode(String(), type='str', location="querystring") qux = SchemaNode(String(), type='str', location="header") class MockRequest(object): def __init__(self, body, get=None): self.content_type = 'application/json'
class HalfLifeWeathererSchema(WeathererSchema): half_lives = SchemaNode(NumpyArray(), save=True, update=True)
def _bind(self, schema: colander.SchemaNode) -> colander.SchemaNode: return schema.bind(request=self.request)
class GeoSubmitSchema(MappingSchema): # The first portion of the GeoSubmitSchema is identical to the # Gelocate schema with the exception that the radioType validator # can accept one more radioType (lte) homeMobileCountryCode = SchemaNode( Integer(), missing=-1) homeMobileNetworkCode = SchemaNode( Integer(), missing=-1) # mapped to 'radio' for submit radioType = SchemaNode(String(), validator=OneOf(GEOSUBMIT_RADIO_TYPE_KEYS), missing='') carrier = SchemaNode(String(), missing='') cellTowers = CellTowersSchema(missing=()) wifiAccessPoints = WifiAccessPointsSchema(missing=()) # The fields below are extra fields which are not part of the # geolocate API, but are part of the submit schema # mapped to 'lat' for submit latitude = SchemaNode(Float(), missing=-255) # mapped to 'lon' for submit longitude = SchemaNode(Float(), missing=-255) # parsed and mapped to 'time' for submit timestamp = SchemaNode(Integer(), missing=0) # mapped to 'accuracy' for submit accuracy = SchemaNode(Float(), missing=0) # mapped to 'altitude' for submit altitude = SchemaNode(Float(), missing=0) # mapped to 'altitude_accuracy' for submit altitudeAccuracy = SchemaNode(Float(), missing=0) # radio is taken from radioType # cell is taken from cellTowers # wifi is taken from wifiAccessPoints heading = SchemaNode(Float(), missing=-1.0) speed = SchemaNode(Float(), missing=-1.0)