def __init__(self, app=None, validator=None, mime_type=None, ignore_wrappers=False, binary_encoding=None): self.validator = None super(InProtocolBase, self).__init__(app=app, mime_type=mime_type, ignore_wrappers=ignore_wrappers, binary_encoding=binary_encoding) self.message = None self.validator = None self.set_validator(validator) if self.binary_encoding is None: self.binary_encoding = self.default_binary_encoding if mime_type is not None: self.mime_type = mime_type fsh = { Null: self.null_from_string, Time: self.time_from_string, Date: self.date_from_string, Uuid: self.uuid_from_string, File: self.file_from_string, Array: self.array_from_string, Double: self.double_from_string, String: self.string_from_string, AnyXml: self.any_xml_from_string, Boolean: self.boolean_from_string, Integer: self.integer_from_string, Unicode: self.unicode_from_string, Decimal: self.decimal_from_string, AnyHtml: self.any_html_from_string, DateTime: self.datetime_from_string, Duration: self.duration_from_string, ByteArray: self.byte_array_from_string, EnumBase: self.enum_base_from_string, ModelBase: self.model_base_from_string, Attachment: self.attachment_from_string, XmlAttribute: self.xmlattribute_from_string, ComplexModelBase: self.complex_model_base_from_string } self._from_string_handlers = cdict(fsh) self._from_unicode_handlers = cdict(fsh) self._datetime_dsmap = { None: self._datetime_from_string, 'sec': self._datetime_from_sec, 'sec_float': self._datetime_from_sec_float, 'msec': self._datetime_from_msec, 'msec_float': self._datetime_from_msec_float, 'usec': self._datetime_from_usec, }
def __init__(self, app=None, validator=None, xml_declaration=True, cleanup_namespaces=False): ProtocolBase.__init__(self, app, validator) self.xml_declaration = xml_declaration self.cleanup_namespaces = cleanup_namespaces self.serialization_handlers = cdict({ AnyXml: xml_to_parent_element, Alias: alias_to_parent_element, Fault: fault_to_parent_element, AnyDict: dict_to_parent_element, EnumBase: enum_to_parent_element, ModelBase: base_to_parent_element, ByteArray: binary_to_parent_element, Attachment: binary_to_parent_element, ComplexModelBase: complex_to_parent_element, }) self.deserialization_handlers = cdict({ AnyXml: xml_from_element, Fault: fault_from_element, AnyDict: dict_from_element, EnumBase: enum_from_element, ModelBase: base_from_element, Unicode: unicode_from_element, ByteArray: binary_from_element, Attachment: binary_from_element, ComplexModelBase: complex_from_element, Iterable: iterable_from_element, Array: array_from_element, }) self.log_messages = (logger.level == logging.DEBUG)
def __init__(self, app=None, validator=None, mime_type=None, ignore_uncap=False): self.__app = None self.validator = None self.set_app(app) self.event_manager = EventManager(self) self.set_validator(validator) self.ignore_uncap = ignore_uncap if mime_type is not None: self.mime_type = mime_type self._to_string_handlers = cdict({ ModelBase: lambda cls, value: cls.to_string(value), Time: time_to_string, Uuid: uuid_to_string, Null: null_to_string, Double: double_to_string, AnyXml: any_xml_to_string, Unicode: unicode_to_string, Boolean: boolean_to_string, Decimal: decimal_to_string, Integer: integer_to_string, AnyHtml: any_html_to_string, DateTime: datetime_to_string, Duration: duration_to_string, ByteArray: byte_array_to_string, Attachment: attachment_to_string, ComplexModelBase: complex_model_base_to_string, }) self._to_string_iterable_handlers = cdict({ File: file_to_string_iterable, ByteArray: byte_array_to_string_iterable, ModelBase: lambda prot, cls, value: cls.to_string_iterable(value), SimpleModel: simple_model_to_string_iterable, ComplexModelBase: complex_model_to_string_iterable, }) self._from_string_handlers = cdict({ Null: null_from_string, Time: time_from_string, Date: date_from_string, Uuid: uuid_from_string, File: file_from_string, Double: double_from_string, String: string_from_string, AnyXml: any_xml_from_string, Boolean: boolean_from_string, Integer: integer_from_string, Unicode: unicode_from_string, Decimal: decimal_from_string, AnyHtml: any_html_from_string, DateTime: datetime_from_string, Duration: duration_from_string, ByteArray: byte_array_from_string, Attachment: attachment_from_string, ComplexModelBase: complex_model_base_from_string })
def __init__(self, app=None, validator=None, mime_type=None, ignore_uncap=False): self.__app = None self.validator = None self.set_app(app) self.event_manager = EventManager(self) self.set_validator(validator) self.ignore_uncap = ignore_uncap if mime_type is not None: self.mime_type = mime_type self._to_string_handlers = cdict({ ModelBase: lambda cls, value: cls.to_string(value), Time: time_to_string, Uuid: uuid_to_string, Null: null_to_string, Double: double_to_string, AnyXml: any_xml_to_string, Unicode: unicode_to_string, Boolean: boolean_to_string, Decimal: decimal_to_string, Integer: integer_to_string, AnyHtml: any_html_to_string, DateTime: datetime_to_string, Duration: duration_to_string, ByteArray: byte_array_to_string, Attachment: attachment_to_string, ComplexModelBase: complex_model_base_to_string, }) self._to_string_iterable_handlers = cdict({ File: file_to_string_iterable, ByteArray: byte_array_to_string_iterable, ModelBase: lambda prot, cls, value: cls.to_string_iterable(value), SimpleModel: simple_model_to_string_iterable, }) self._from_string_handlers = cdict({ Null: null_from_string, Time: time_from_string, Date: date_from_string, Uuid: uuid_from_string, File: file_from_string, Double: double_from_string, String: string_from_string, AnyXml: any_xml_from_string, Boolean: boolean_from_string, Integer: integer_from_string, Unicode: unicode_from_string, Decimal: decimal_from_string, AnyHtml: any_html_from_string, DateTime: datetime_from_string, Duration: duration_from_string, ByteArray: byte_array_from_string, Attachment: attachment_from_string, ComplexModelBase: complex_model_base_from_string })
def __init__(self, app=None, validator=None, xml_declaration=True, cleanup_namespaces=True, encoding='UTF-8', pretty_print=False): ProtocolBase.__init__(self, app, validator) self.xml_declaration = xml_declaration self.cleanup_namespaces = cleanup_namespaces self.encoding = encoding self.pretty_print = pretty_print self.serialization_handlers = cdict({ AnyXml: xml_to_parent_element, Alias: alias_to_parent_element, Fault: fault_to_parent_element, AnyDict: dict_to_parent_element, AnyHtml: html_to_parent_element, EnumBase: enum_to_parent_element, ModelBase: base_to_parent_element, ByteArray: byte_array_to_parent_element, Attachment: attachment_to_parent_element, XmlAttribute: xmlattribute_to_parent_element, ComplexModelBase: complex_to_parent_element, }) self.deserialization_handlers = cdict({ AnyXml: xml_from_element, Fault: fault_from_element, AnyDict: dict_from_element, EnumBase: enum_from_element, ModelBase: base_from_element, Unicode: unicode_from_element, ByteArray: byte_array_from_element, Attachment: attachment_from_element, ComplexModelBase: complex_from_element, Alias: alias_from_element, Iterable: iterable_from_element, Array: array_from_element, }) self.log_messages = (logger.level == logging.DEBUG) self.parser = etree.XMLParser(remove_comments=True)
def __new__(cls, cls_name, cls_bases, cls_dict): for dkey in ("_to_string_handlers", "_to_string_iterable_handlers", "_from_string_handlers", '_to_dict_handlers'): d = cdict() for b in cls_bases: d_base = getattr(b, dkey, cdict()) d.update(d_base) d.update(cdict(cls_dict.get(dkey, {}))) cls_dict[dkey] = d return type(object).__new__(cls, cls_name, cls_bases, cls_dict)
def __init__( self, app=None, validator=None, xml_declaration=True, cleanup_namespaces=True, encoding="UTF-8", pretty_print=False, ): ProtocolBase.__init__(self, app, validator) self.xml_declaration = xml_declaration self.cleanup_namespaces = cleanup_namespaces self.encoding = encoding self.pretty_print = pretty_print self.serialization_handlers = cdict( { AnyXml: xml_to_parent_element, Alias: alias_to_parent_element, Fault: fault_to_parent_element, AnyDict: dict_to_parent_element, AnyHtml: html_to_parent_element, EnumBase: enum_to_parent_element, ModelBase: base_to_parent_element, ByteArray: byte_array_to_parent_element, Attachment: attachment_to_parent_element, ComplexModelBase: complex_to_parent_element, } ) self.deserialization_handlers = cdict( { AnyXml: xml_from_element, Fault: fault_from_element, AnyDict: dict_from_element, EnumBase: enum_from_element, ModelBase: base_from_element, Unicode: unicode_from_element, ByteArray: byte_array_from_element, Attachment: attachment_from_element, ComplexModelBase: complex_from_element, Alias: alias_from_element, Iterable: iterable_from_element, Array: array_from_element, } ) self.log_messages = logger.level == logging.DEBUG self.parser = etree.XMLParser(remove_comments=True)
def test_cdict(self): from spyne.util.cdict import cdict class A(object): pass class B(A): pass class E(B): pass class F(E): pass class C(object): pass class D: pass d = cdict({A: "fun", object: "base", F: 'zan'}) assert d[A] == 'fun' assert d[B] == 'fun' assert d[C] == 'base' assert d[F] == 'zan' try: d[D] except KeyError: pass else: raise Exception("Must fail.")
def __init__(self, app=None, validator=None, mime_type=None, ignore_uncap=False, ignore_wrappers=False, polymorphic=True): super(ToParentMixin, self).__init__(app=app, validator=validator, mime_type=mime_type, ignore_uncap=ignore_uncap, ignore_wrappers=ignore_wrappers) self.polymorphic = polymorphic self.use_global_null_handler = True self.serialization_handlers = cdict({ ModelBase: self.base_to_parent, AnyXml: self.xml_to_parent, AnyUri: self.anyuri_to_parent, ImageUri: self.imageuri_to_parent, AnyDict: self.dict_to_parent, AnyHtml: self.html_to_parent, Any: self.any_to_parent, Fault: self.fault_to_parent, EnumBase: self.enum_to_parent, ByteArray: self.byte_array_to_parent, ComplexModelBase: self.complex_to_parent, SchemaValidationError: self.schema_validation_error_to_parent, })
def __init__(self, text_field=None, id_field=None, type=None, hidden_fields=None, label=True, null_str='[NULL]'): """A widget that renders complex objects as links. :param text_field: The name of the field containing a human readable string that represents the object. :param id_field: The name of the field containing the unique identifier of the object. :param type: If not `None`, overrides the object type being rendered. Useful for e.g. combining multiple fields to one field. :param hidden_fields: A sequence of field names that will be rendered as hidden <input> tags. :param label: If ``True``, a ``<label>`` tag is generated for the relevant widget id. """ super(ComplexRenderWidget, self).__init__(label=label) self.id_field = id_field self.text_field = text_field self.hidden_fields = hidden_fields self.type = type self.null_str = null_str self.serialization_handlers = cdict({ ComplexModelBase: self.complex_model_to_parent, })
def __init__(self, *args, **kwargs): super(PasswordWidget, self).__init__(*args, **kwargs) self.serialization_handlers = cdict({ Unicode: self.unicode_to_parent, ComplexModelBase: self.complex_model_to_parent, })
def __init__(self, app=None, validator=None, mime_type=None, ignore_uncap=False, ignore_wrappers=False): super(ToParentMixin, self).__init__(app=app, validator=validator, mime_type=mime_type, ignore_uncap=ignore_uncap, ignore_wrappers=ignore_wrappers) self.serialization_handlers = cdict({ AnyXml: self.xml_to_parent, Fault: self.fault_to_parent, AnyDict: self.dict_to_parent, AnyHtml: self.html_to_parent, EnumBase: self.enum_to_parent, ModelBase: self.base_to_parent, ByteArray: self.byte_array_to_parent, ComplexModelBase: self.complex_to_parent, SchemaValidationError: self.schema_validation_error_to_parent, })
def __init__(self, app=None, ignore_uncap=False, ignore_wrappers=False, cloth=None, attr_name='spyne_id', root_attr_name='spyne', cloth_parser=None, polymorphic=True, hier_delim='.', asset_paths={}): super(HtmlForm, self).__init__(app=app, ignore_uncap=ignore_uncap, ignore_wrappers=ignore_wrappers, cloth=cloth, attr_name=attr_name, root_attr_name=root_attr_name, cloth_parser=cloth_parser, polymorphic=polymorphic) self.serialization_handlers = cdict({ Date: self.date_to_parent, Time: self.time_to_parent, Array: self.array_type_to_parent, Integer: self.integer_to_parent, Unicode: self.unicode_to_parent, Decimal: self.decimal_to_parent, Boolean: self.boolean_to_parent, Duration: self.duration_to_parent, DateTime: self.datetime_to_parent, ComplexModelBase: self.complex_model_to_parent, }) self.hier_delim = hier_delim self.asset_paths = { ('jquery',): [_jstag("/assets/jquery/1.11.1/jquery.min.js")], ('jquery-ui',): [_jstag("/assets/jquery-ui/1.11.0/jquery-ui.min.js")], ('jquery-timepicker',): [ _jstag("/assets/jquery-timepicker/jquery-ui-timepicker-addon.js"), _csstag("/assets/jquery-timepicker/jquery-ui-timepicker-addon.css"), ], } self.asset_paths.update(asset_paths) self.use_global_null_handler = False
def __init__(self, app=None, validator=None, mime_type=None, ignore_uncap=False, ignore_wrappers=False, polymorphic=True): super(ToClothMixin, self).__init__(app=app, validator=validator, mime_type=mime_type, ignore_uncap=ignore_uncap, ignore_wrappers=ignore_wrappers) self.polymorphic = polymorphic self.rendering_handlers = cdict({ ModelBase: self.model_base_to_cloth, AnyXml: self.xml_to_cloth, AnyHtml: self.html_to_cloth, ComplexModelBase: self.complex_to_cloth, })
def __init__(self, label=True, type=None, hidden=False): super(SimpleReadableNumberWidget, self).__init__( label=label, type=type, hidden=hidden) self.serialization_handlers = cdict({ Decimal: self.decimal_to_parent, Integer: self.integer_to_parent, })
def __init__(self, label=True, type=None, hidden=False): super(SimpleRenderWidget, self).__init__(label=label) self.type = type self.hidden = hidden self.serialization_handlers = cdict({ ModelBase: self.model_base_to_parent, ComplexModelBase: self.not_supported, })
def __init__(self, app=None, ignore_uncap=False, ignore_wrappers=False, cloth=None, cloth_parser=None, polymorphic=True, doctype="<!DOCTYPE html>", root_tag='div', child_tag='div', field_name_attr='class', field_name_tag=None, field_name_class='field_name', before_first_root=None): """Protocol that returns the response object according to the "html microformat" specification. See https://en.wikipedia.org/wiki/Microformats for more info. The simple flavour is like the XmlDocument protocol, but returns data in <div> or <span> tags. :param app: A spyne.application.Application instance. :param root_tag: The type of the root tag that encapsulates the return data. :param child_tag: The type of the tag that encapsulates the fields of the returned object. :param field_name_attr: The name of the attribute that will contain the field names of the complex object children. """ super(HtmlMicroFormat, self).__init__(app=app, ignore_uncap=ignore_uncap, ignore_wrappers=ignore_wrappers, cloth=cloth, cloth_parser=cloth_parser, polymorphic=polymorphic, hier_delim=None, doctype=doctype) if six.PY2: text_type = basestring else: text_type = str assert isinstance(root_tag, text_type) assert isinstance(child_tag, text_type) assert isinstance(field_name_attr, text_type) assert field_name_tag is None or isinstance(field_name_tag, text_type) self.root_tag = root_tag self.child_tag = child_tag self.field_name_attr = field_name_attr self.field_name_tag = field_name_tag if field_name_tag is not None: self.field_name_tag = E(field_name_tag) self._field_name_class = field_name_class if before_first_root is not None: self.event_manager.add_listener("before_first_root", before_first_root) self.serialization_handlers = cdict({ Array: self.array_to_parent, AnyUri: self.anyuri_to_parent, AnyHtml: self.html_to_parent, ImageUri: self.imageuri_to_parent, ByteArray: self.not_supported, ModelBase: self.model_base_to_parent, ComplexModelBase: self.complex_model_to_parent, })
def __init__(self, app=None, ignore_uncap=False, ignore_wrappers=False, cloth=None, cloth_parser=None, polymorphic=True, doctype="<!DOCTYPE html>", root_tag='div', child_tag='div', field_name_attr='class', field_name_tag=None, field_name_class='field_name', before_first_root=None): """Protocol that returns the response object according to the "html microformat" specification. See https://en.wikipedia.org/wiki/Microformats for more info. The simple flavour is like the XmlDocument protocol, but returns data in <div> or <span> tags. :param app: A spyne.application.Application instance. :param root_tag: The type of the root tag that encapsulates the return data. :param child_tag: The type of the tag that encapsulates the fields of the returned object. :param field_name_attr: The name of the attribute that will contain the field names of the complex object children. """ super(HtmlMicroFormat, self).__init__(app=app, ignore_uncap=ignore_uncap, ignore_wrappers=ignore_wrappers, cloth=cloth, cloth_parser=cloth_parser, polymorphic=polymorphic, hier_delim=None, doctype=doctype) if six.PY2: text_type = basestring else: text_type = str assert isinstance(root_tag, text_type) assert isinstance(child_tag, text_type) assert isinstance(field_name_attr, text_type) assert field_name_tag is None or isinstance(field_name_tag, text_type) self.root_tag = root_tag self.child_tag = child_tag self.field_name_attr = field_name_attr self.field_name_tag = field_name_tag if field_name_tag is not None: self.field_name_tag = E(field_name_tag) self._field_name_class = field_name_class if before_first_root is not None: self.event_manager.add_listener("before_first_root", before_first_root) self.serialization_handlers = cdict({ Array: self.array_to_parent, AnyUri: self.any_uri_to_parent, AnyHtml: self.any_html_to_parent, ImageUri: self.imageuri_to_parent, ByteArray: self.not_supported, ModelBase: self.model_base_to_parent, ComplexModelBase: self.complex_model_to_parent, })
def __init__(self, href, hidden_input=False, label=True): super(HrefWidget, self).__init__(label=label) self.href = href self.hidden_input = hidden_input self.serialization_handlers = cdict({ ModelBase: self.model_base_to_parent, ComplexModelBase: self.not_supported, })
def __init__(self, label=True, type=None, hidden=False): super(SimpleRenderWidget, self).__init__(label=label) self.type = type self.hidden = hidden self.serialization_handlers = cdict({ ModelBase: self.model_base_to_parent, AnyHtml: self.any_html_to_parent, AnyUri: self.any_uri_to_parent, ComplexModelBase: self.complex_model_to_parent, })
def __init__(self, *args, **kwargs): super(HtmlRowTable, self).__init__(*args, **kwargs) self.serialization_handlers = cdict({ ModelBase: self.model_base_to_parent, AnyUri: self.anyuri_to_parent, ImageUri: self.imageuri_to_parent, ByteArray: self.not_supported, ComplexModelBase: self.complex_model_to_parent, Array: self.array_to_parent, })
def __init__(self, *args, **kwargs): super(HtmlRowTable, self).__init__(*args, **kwargs) self.serialization_handlers = cdict({ ModelBase: self.model_base_to_parent, AnyUri: self.any_uri_to_parent, ImageUri: self.imageuri_to_parent, ByteArray: self.not_supported, ComplexModelBase: self.complex_model_to_parent, Array: self.array_to_parent, })
def __init__(self, app=None, validator=None, mime_type=None, ignore_uncap=False, ignore_wrappers=False): super(ToClothMixin, self).__init__(app=app, validator=validator, mime_type=mime_type, ignore_uncap=ignore_uncap, ignore_wrappers=ignore_wrappers) self.rendering_handlers = cdict({ ModelBase: self.model_base_to_cloth, AnyXml: self.element_to_cloth, AnyHtml: self.element_to_cloth, ComplexModelBase: self.complex_to_cloth, })
def __init__(self, label=True, type=None, hidden=False, locale='en_US.utf8'): super(SimpleReadableNumberWidget, self).__init__( label=label, type=type, hidden=hidden) self.locale = locale self.serialization_handlers = cdict({ Decimal: self.decimal_to_parent, Integer: self.integer_to_parent, ComplexModelBase: self.complex_model_to_parent, })
def test_cdict(self): d = cdict({A: "fun", object: "base"}) assert d[A] == 'fun' assert d[B] == 'fun' assert d[C] == 'base' try: d[D] except KeyError: pass else: raise Exception("Must fail.")
class BaseDjangoFieldMapper(object): """Abstrace base class for field mappers.""" _VALIDATOR_HANDLERS = cdict({ MinLengthValidator: _handle_minlength, MaxLengthValidator: _handle_maxlength, }) @staticmethod def is_field_nullable(field, **kwargs): """Return True if django field is nullable.""" return field.null @staticmethod def is_field_blank(field, **kwargs): """Return True if django field is blank.""" return field.blank def map(self, field, **kwargs): """Map field to spyne model. :param field: Django Field instance :param kwargs: Extra params to configure spyne model :returns: tuple (field attribute name, mapped spyne model) """ params = kwargs.copy() self._process_validators(field.validators, params) nullable = self.is_field_nullable(field, **kwargs) blank = self.is_field_blank(field, **kwargs) required = not (field.has_default() or blank or field.primary_key) if field.has_default(): params['default'] = field.get_default() spyne_model = self.get_spyne_model(field, **kwargs) customized_model = spyne_model(nullable=nullable, min_occurs=int(required), **params) return (field.attname, customized_model) def get_spyne_model(self, field, **kwargs): """Return spyne model for given Django field.""" raise NotImplementedError def _process_validators(self, validators, params): for v in validators: handler = self._VALIDATOR_HANDLERS.get(type(v)) if handler: handler(v, params)
def __init__(self, app=None, ignore_uncap=False, ignore_wrappers=False, cloth=None, attr_name='spyne_id', root_attr_name='spyne', cloth_parser=None, root_tag='div', child_tag='div', field_name_attr='class', field_name_tag=None, field_name_class='field_name'): """Protocol that returns the response object according to the "html microformat" specification. See https://en.wikipedia.org/wiki/Microformats for more info. The simple flavour is like the XmlDocument protocol, but returns data in <div> or <span> tags. :param app: A spyne.application.Application instance. :param validator: The validator to use. Ignored. :param root_tag: The type of the root tag that encapsulates the return data. :param child_tag: The type of the tag that encapsulates the fields of the returned object. :param field_name_attr: The name of the attribute that will contain the field names of the complex object children. """ super(HtmlMicroFormat, self).__init__(app=app, ignore_uncap=ignore_uncap, ignore_wrappers=ignore_wrappers, cloth=cloth, attr_name=attr_name, root_attr_name=root_attr_name, cloth_parser=cloth_parser) assert root_tag in ('div', 'span') assert child_tag in ('div', 'span') assert field_name_attr in ('class', 'id') assert field_name_tag in (None, 'span', 'div') self.root_tag = root_tag self.child_tag = child_tag self.field_name_attr = field_name_attr self.field_name_tag = field_name_tag if field_name_tag is not None: self.field_name_tag = E(field_name_tag) self._field_name_class = field_name_class self.serialization_handlers = cdict({ ModelBase: self.model_base_to_parent, AnyUri: self.anyuri_to_parent, AnyHtml: self.anyhtml_to_parent, ImageUri: self.imageuri_to_parent, ByteArray: self.not_supported, Attachment: self.not_supported, ComplexModelBase: self.complex_model_to_parent, Array: self.array_to_parent, })
def __init__(self, app=None, mime_type=None, ignore_uncap=False, ignore_wrappers=False, polymorphic=True): super(ToClothMixin, self).__init__(app=app, mime_type=mime_type, ignore_uncap=ignore_uncap, ignore_wrappers=ignore_wrappers) self.polymorphic = polymorphic self.rendering_handlers = cdict({ ModelBase: self.model_base_to_cloth, AnyXml: self.xml_to_cloth, Any: self.any_to_cloth, AnyHtml: self.html_to_cloth, AnyUri: self.anyuri_to_cloth, ComplexModelBase: self.complex_to_cloth, })
def __init__(self, app=None, ignore_uncap=False, ignore_wrappers=False, cloth=None, attr_name='spyne_id', root_attr_name='spyne', cloth_parser=None, can_add=True, can_remove=True): super(HtmlFormTable, self).__init__(app=app, ignore_uncap=ignore_uncap, ignore_wrappers=ignore_wrappers, cloth=cloth, attr_name=attr_name, root_attr_name=root_attr_name, cloth_parser=cloth_parser) self.serialization_handlers = cdict({ ModelBase: self.model_base_to_parent, }) self.prot_form = HtmlForm() self.can_add = can_add self.can_remove = can_remove
def __init__(self, app=None, ignore_uncap=False, ignore_wrappers=False, cloth=None, cloth_parser=None, polymorphic=True, hier_delim='.', doctype=None, label=True, asset_paths={}, placeholder=None, input_class=None, input_div_class=None, input_wrapper_class=None, label_class=None, action=None, method='POST', before_form=None): super(HtmlForm, self).__init__(app=app, doctype=doctype, ignore_uncap=ignore_uncap, ignore_wrappers=ignore_wrappers, cloth=cloth, cloth_parser=cloth_parser, polymorphic=polymorphic, hier_delim=hier_delim, label=label, asset_paths=asset_paths, placeholder=placeholder, input_class=input_class, input_div_class=input_div_class, input_wrapper_class=input_wrapper_class, label_class=label_class, action=action, method=method, before_form=before_form) self.serialization_handlers = cdict({ Date: self._check_simple(self.date_to_parent), Time: self._check_simple(self.time_to_parent), Uuid: self._check_simple(self.uuid_to_parent), Fault: self.fault_to_parent, Array: self.array_type_to_parent, AnyXml: self._check_simple(self.anyxml_to_parent), Integer: self._check_simple(self.integer_to_parent), Unicode: self._check_simple(self.unicode_to_parent), AnyHtml: self._check_simple(self.anyhtml_to_parent), Decimal: self._check_simple(self.decimal_to_parent), Boolean: self._check_simple(self.boolean_to_parent), Duration: self._check_simple(self.duration_to_parent), DateTime: self._check_simple(self.datetime_to_parent), ComplexModelBase: self.complex_model_to_parent, }) self.hier_delim = hier_delim self.asset_paths = { ('jquery',): [_jstag("/assets/jquery/1.11.1/jquery.min.js")], ('jquery-ui',): [_jstag("/assets/jquery-ui/1.11.0/jquery-ui.min.js")], ('jquery-timepicker',): [ _jstag("/assets/jquery-timepicker/jquery-ui-timepicker-addon.js"), _csstag("/assets/jquery-timepicker/jquery-ui-timepicker-addon.css"), ], } self.asset_paths.update(asset_paths) self.use_global_null_handler = False self.simple = SimpleRenderWidget(label=label)
def __init__(self, app=None, validator=None, root_tag='div', child_tag='div', field_name_attr='class', field_name_tag=None, field_name_class='field_name'): """Protocol that returns the response object as a html microformat. See https://en.wikipedia.org/wiki/Microformats for more info. The simple flavour is like the XmlDocument protocol, but returns data in <div> or <span> tags. :param app: A spyne.application.Application instance. :param validator: The validator to use. Ignored. :param root_tag: The type of the root tag that encapsulates the return data. :param child_tag: The type of the tag that encapsulates the fields of the returned object. :param field_name_attr: The name of the attribute that will contain the field names of the complex object children. :param field_type_attr: The name of the attribute that will contain the type names of the complex object children. :param with_field_names: Also return field names in the field tags inside separate tags. """ HtmlBase.__init__(self, app, validator) assert root_tag in ('div', 'span') assert child_tag in ('div', 'span') assert field_name_attr in ('class', 'id') assert field_name_tag in (None, 'span', 'div') self.__root_tag = root_tag self.__child_tag = child_tag self.__field_name_attr = field_name_attr self._field_name_tag = field_name_tag if field_name_tag is not None: self._field_name_tag = getattr(E, field_name_tag) self._field_name_class = field_name_class self.serialization_handlers = cdict({ ModelBase: self.serialize_model_base, ByteArray: not_supported, Attachment: not_supported, ComplexModelBase: self.serialize_complex_model, Array: self.serialize_array, })
def __init__(self, app=None, validator=None, mime_type=None, ignore_uncap=False, ignore_wrappers=False, polymorphic=True): super(ToParentMixin, self).__init__(app=app, validator=validator, mime_type=mime_type, ignore_uncap=ignore_uncap, ignore_wrappers=ignore_wrappers) self.polymorphic = polymorphic self.use_global_null_handler = True self.serialization_handlers = cdict({ ModelBase: self.base_to_parent, AnyXml: self.xml_to_parent, AnyUri: self.anyuri_to_parent, AnyHtml: self.anyhtml_to_parent, ImageUri: self.imageuri_to_parent, AnyDict: self.dict_to_parent, AnyHtml: self.html_to_parent, Fault: self.fault_to_parent, EnumBase: self.enum_to_parent, ByteArray: self.byte_array_to_parent, ComplexModelBase: self.complex_to_parent, SchemaValidationError: self.schema_validation_error_to_parent, })
def __init__(self, app=None, validator=None, root_tag='div', child_tag='div', field_name_attr='class', skip_depth=0): """Protocol that returns the response object as a html microformat. See https://en.wikipedia.org/wiki/Microformats for more info. The simple flavour is like the XmlDocument protocol, but returns data in <div> or <span> tags. :param app: A spyne.application.Application instance. :param validator: The validator to use. Ignored. :param root_tag: The type of the root tag that encapsulates the return data. :param child_tag: The type of the tag that encapsulates the fields of the returned object. :param field_name_attr: The name of the attribute that will contain the field names of the complex object children. :param field_type_attr: The name of the attribute that will contain the type names of the complex object children. """ HtmlBase.__init__(self, app, validator, skip_depth) assert root_tag in ('div', 'span') assert child_tag in ('div', 'span') assert field_name_attr in ('class', 'id') self.__root_tag = root_tag self.__child_tag = child_tag self.__field_name_attr = field_name_attr self.serialization_handlers = cdict({ ModelBase: self.serialize_model_base, ByteArray: not_supported, Attachment: not_supported, ComplexModelBase: self.serialize_complex_model, Array: self.serialize_array, })
def _decode_pa_dict(d): """Decodes dict passed to prot_attrs. >>> _decode_pa_dict({}) cdict({}) >>> _decode_pa_dict({1: 2)}) cdict({1: 2}) >>> _decode_pa_dict({(1,2): 3)}) cdict({1: 3, 2: 3}) """ retval = cdict() for k, v in d.items(): if isinstance(k, tuple): for subk in k: retval[subk] = v for k, v in d.items(): if not isinstance(k, tuple): retval[k] = v return retval
def __init__( self, app=None, validator=None, root_tag="div", child_tag="div", field_name_attr="class", skip_depth=0 ): """Protocol that returns the response object as a html microformat. See https://en.wikipedia.org/wiki/Microformats for more info. The simple flavour is like the XmlObject protocol, but returns data in <div> or <span> tags. :param app: A spyne.application.Application instance. :param validator: The validator to use. Ignored. :param root_tag: The type of the root tag that encapsulates the return data. :param child_tag: The type of the tag that encapsulates the fields of the returned object. :param field_name_attr: The name of the attribute that will contain the field names of the complex object children. :param field_type_attr: The name of the attribute that will contain the type names of the complex object children. """ HtmlBase.__init__(self, app, validator, skip_depth) assert root_tag in ("div", "span") assert child_tag in ("div", "span") assert field_name_attr in ("class", "id") self.__root_tag = root_tag self.__child_tag = child_tag self.__field_name_attr = field_name_attr self.serialization_handlers = cdict( { ModelBase: self.serialize_model_base, ByteArray: not_supported, Attachment: not_supported, ComplexModelBase: self.serialize_complex_model, } )
def __init__(self, app=None, ignore_uncap=False, ignore_wrappers=False, cloth=None, attr_name='spyne_id', root_attr_name='spyne', cloth_parser=None): super(HtmlFormTable, self).__init__(app=app, ignore_uncap=ignore_uncap, ignore_wrappers=ignore_wrappers, cloth=cloth, attr_name=attr_name, root_attr_name=root_attr_name, cloth_parser=cloth_parser) self.serialization_handlers = cdict({ ModelBase: self.model_base_to_parent, }) self.prot_form = HtmlForm()
def __init__(self, app=None, validator=None, replace_null_with_default=True, xml_declaration=True, cleanup_namespaces=True, encoding=None, pretty_print=False, attribute_defaults=False, dtd_validation=False, load_dtd=False, no_network=True, ns_clean=False, recover=False, remove_blank_text=False, remove_pis=True, strip_cdata=True, resolve_entities=False, huge_tree=False, compact=True, binary_encoding=None, parse_xsi_type=True, polymorphic=False, ): super(XmlDocument, self).__init__(app, validator, binary_encoding=binary_encoding) self.xml_declaration = xml_declaration self.cleanup_namespaces = cleanup_namespaces self.replace_null_with_default = replace_null_with_default if encoding is None: self.encoding = 'UTF-8' else: self.encoding = encoding self.polymorphic = polymorphic self.pretty_print = pretty_print self.parse_xsi_type = parse_xsi_type self.serialization_handlers = cdict({ AnyXml: self.xml_to_parent, Any: self.xml_to_parent, Fault: self.fault_to_parent, AnyDict: self.dict_to_parent, AnyHtml: self.html_to_parent, EnumBase: self.enum_to_parent, XmlData: self.xmldata_to_parent, ModelBase: self.modelbase_to_parent, ByteArray: self.byte_array_to_parent, Attachment: self.attachment_to_parent, XmlAttribute: self.xmlattribute_to_parent, ComplexModelBase: self.complex_to_parent, SchemaValidationError: self.schema_validation_error_to_parent, }) self.deserialization_handlers = cdict({ AnyHtml: self.html_from_element, AnyXml: self.xml_from_element, Any: self.xml_from_element, Array: self.array_from_element, Fault: self.fault_from_element, AnyDict: self.dict_from_element, EnumBase: self.enum_from_element, ModelBase: self.base_from_element, Unicode: self.unicode_from_element, Iterable: self.iterable_from_element, ByteArray: self.byte_array_from_element, Attachment: self.attachment_from_element, ComplexModelBase: self.complex_from_element, }) self.parser_kwargs = dict( attribute_defaults=attribute_defaults, dtd_validation=dtd_validation, load_dtd=load_dtd, no_network=no_network, ns_clean=ns_clean, recover=recover, remove_blank_text=remove_blank_text, remove_comments=True, remove_pis=remove_pis, strip_cdata=strip_cdata, resolve_entities=resolve_entities, huge_tree=huge_tree, compact=compact, encoding=encoding, )
from spyne.util.etreeconv import dict_to_etree from spyne.util.six import string_types from spyne.protocol.xml import XmlDocument _prot = XmlDocument() XSD = lambda s: '{%s}%s' % (_ns_xsd, s) # In Xml Schema, some customizations do not need a class to be extended -- they # are specified in-line in the parent class definition, like nullable or # min_occurs. The dict below contains list of parameters that do warrant a # proper subclass definition for each type. This must be updated as the Xml # Schema implementation makes progress. ATTR_NAMES = cdict({ ModelBase: set(['values']), Decimal: set(['pattern', 'gt', 'ge', 'lt', 'le', 'values', 'total_digits', 'fraction_digits']), Integer: set(['pattern', 'gt', 'ge', 'lt', 'le', 'values', 'total_digits']), Unicode: set(['values', 'min_len', 'max_len', 'pattern']), }) def xml_attribute_add(cls, name, element, document): element.set('name', name) element.set('type', cls.type.get_type_name_ns(document.interface)) if cls._use is not None: element.set('use', cls._use) d = cls.type.Attributes.default if d is not None: element.set('default', _prot.to_string(cls.type, d))
def __init__(self, app=None, mime_type=None, ignore_uncap=False, ignore_wrappers=False, binary_encoding=None): super(OutProtocolBase, self).__init__(app=app, mime_type=mime_type, ignore_wrappers=ignore_wrappers) self.ignore_uncap = ignore_uncap self.message = None self.binary_encoding = binary_encoding if self.binary_encoding is None: self.binary_encoding = self.default_binary_encoding if mime_type is not None: self.mime_type = mime_type self._to_bytes_handlers = cdict({ ModelBase: self.model_base_to_bytes, File: self.file_to_bytes, Time: self.time_to_bytes, Uuid: self.uuid_to_bytes, Null: self.null_to_bytes, Double: self.double_to_bytes, AnyXml: self.any_xml_to_bytes, Unicode: self.unicode_to_bytes, Boolean: self.boolean_to_bytes, Decimal: self.decimal_to_bytes, Integer: self.integer_to_bytes, AnyHtml: self.any_html_to_bytes, DateTime: self.datetime_to_bytes, Duration: self.duration_to_bytes, ByteArray: self.byte_array_to_bytes, XmlAttribute: self.xmlattribute_to_bytes, ComplexModelBase: self.complex_model_base_to_bytes, }) self._to_unicode_handlers = cdict({ ModelBase: self.model_base_to_unicode, File: self.file_to_unicode, Time: self.time_to_bytes, Uuid: self.uuid_to_bytes, Null: self.null_to_bytes, Double: self.double_to_bytes, AnyXml: self.any_xml_to_unicode, AnyUri: self.any_uri_to_unicode, AnyDict: self.any_dict_to_unicode, AnyHtml: self.any_html_to_unicode, Unicode: self.unicode_to_unicode, Boolean: self.boolean_to_bytes, Decimal: self.decimal_to_bytes, Integer: self.integer_to_bytes, # FIXME: Would we need a to_unicode for localized dates? DateTime: self.datetime_to_bytes, Duration: self.duration_to_bytes, ByteArray: self.byte_array_to_unicode, XmlAttribute: self.xmlattribute_to_unicode, ComplexModelBase: self.complex_model_base_to_bytes, }) self._to_bytes_iterable_handlers = cdict({ File: self.file_to_bytes_iterable, ByteArray: self.byte_array_to_bytes_iterable, ModelBase: self.model_base_to_bytes_iterable, SimpleModel: self.simple_model_to_bytes_iterable, ComplexModelBase: self.complex_model_to_bytes_iterable, })
MAP = cdict({ ModelBase: cdict({ object: lambda _: _, bytes: lambda _: _.strip(), unicode: lambda _: _.strip(), }), Decimal: cdict({ int: lambda _: D(_), bytes: lambda s: None if s.strip() == '' else D(s.strip()), unicode: lambda s: None if s.strip() == u'' else D(s.strip()), }), Integer: cdict({ int: lambda _: _, bytes: lambda s: None if s.strip() == '' else int(s.strip()), unicode: lambda s: None if s.strip() == u'' else int(s.strip()), }), Date: cdict({ object: lambda _: _, bytes: lambda s: None if s.strip() in ('', '0000-00-00') else _prot.date_from_string(Date, s.strip()), unicode: lambda s: None if s.strip() in (u'', u'0000-00-00') else _prot.date_from_string(Date, s.strip()), }), DateTime: cdict({ object: lambda _: _, bytes: lambda s: None if s.strip() in ('', '0000-00-00 00:00:00') else _prot.datetime_from_string( DateTime, s.strip()), unicode: lambda s: None if s.strip() in (u'', u'0000-00-00 00:00:00') else _prot.datetime_from_string( DateTime, s.strip()), }), IpAddress: cdict({ object: lambda _: _, bytes: lambda s: None if s.strip() == '' else s.strip(), unicode: lambda s: None if s.strip() == u'' else s.strip(), }) })
from spyne import Integer, ModelBase from spyne.util.cdict import cdict MAP = cdict({ ModelBase: cdict({ object: lambda _: _, basestring: lambda _: _ }), Integer: cdict({ int: lambda _: _, basestring: lambda s: None if s == '' else int(s), }) }) def dynamic_init(cls, **kwargs): fti = cls.get_flat_type_info(cls) retval = cls() for k, v in fti.items(): if k in kwargs: subval = kwargs[k] t = MAP[v] setattr(retval, k, t[type(subval)](subval)) return retval
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # import argparse import os.path from gettext import gettext from decimal import Decimal as D from spyne import Boolean, Unicode, Integer, Decimal, ComplexModelBase, Array from spyne.protocol import get_cls_attrs from spyne.util import six from spyne.util.cdict import cdict ARGTYPE_MAP = cdict({ Integer: int, Decimal: D, }) config_overrides = set() class ArgumentParser(argparse.ArgumentParser): def parse_args(self, args=None, namespace=None): args, argv = self.parse_known_args(args, namespace) if len(argv) > 0: newargv = [] for a in argv: if a.startswith("--assets-"): opt, val = a.split("=", 2) val = os.path.abspath(val)
def __init__(self, app=None, validator=None, mime_type=None, ignore_uncap=False, ignore_wrappers=False): self.__app = None self.set_app(app) self.validator = None self.set_validator(validator) self.event_manager = EventManager(self) self.ignore_uncap = ignore_uncap self.ignore_wrappers = ignore_wrappers self.message = None if mime_type is not None: self.mime_type = mime_type self._to_string_handlers = cdict({ ModelBase: self.model_base_to_string, Time: self.time_to_string, Uuid: self.uuid_to_string, Null: self.null_to_string, Double: self.double_to_string, AnyXml: self.any_xml_to_string, Unicode: self.unicode_to_string, Boolean: self.boolean_to_string, Decimal: self.decimal_to_string, Integer: self.integer_to_string, AnyHtml: self.any_html_to_string, DateTime: self.datetime_to_string, Duration: self.duration_to_string, ByteArray: self.byte_array_to_string, Attachment: self.attachment_to_string, XmlAttribute: self.xmlattribute_to_string, ComplexModelBase: self.complex_model_base_to_string, }) self._to_string_iterable_handlers = cdict({ File: self.file_to_string_iterable, ByteArray: self.byte_array_to_string_iterable, ModelBase: self.model_base_to_string_iterable, SimpleModel: self.simple_model_to_string_iterable, ComplexModelBase: self.complex_model_to_string_iterable, }) self._from_string_handlers = cdict({ Null: self.null_from_string, Time: self.time_from_string, Date: self.date_from_string, Uuid: self.uuid_from_string, File: self.file_from_string, Double: self.double_from_string, String: self.string_from_string, AnyXml: self.any_xml_from_string, Boolean: self.boolean_from_string, Integer: self.integer_from_string, Unicode: self.unicode_from_string, Decimal: self.decimal_from_string, AnyHtml: self.any_html_from_string, DateTime: self.datetime_from_string, Duration: self.duration_from_string, ByteArray: self.byte_array_from_string, ModelBase: self.model_base_from_string, Attachment: self.attachment_from_string, ComplexModelBase: self.complex_model_base_from_string }) self._datetime_dsmap = { None: self._datetime_from_string, 'sec': self._datetime_from_sec, 'sec_float': self._datetime_from_sec_float, 'msec': self._datetime_from_msec, 'msec_float': self._datetime_from_msec_float, 'usec': self._datetime_from_usec, }
from spyne.interface import InterfaceDocumentBase from spyne.interface.xml_schema.model import byte_array_add from spyne.interface.xml_schema.model import simple_add from spyne.interface.xml_schema.model import complex_add from spyne.interface.xml_schema.model import fault_add from spyne.interface.xml_schema.model import enum_add from spyne.interface.xml_schema.model import simple_get_restriction_tag from spyne.interface.xml_schema.model import unicode_get_restriction_tag from spyne.interface.xml_schema.model import Tget_range_restriction_tag _add_handlers = cdict({ object: lambda interface, cls, tags: None, ByteArray: byte_array_add, SimpleModel: simple_add, ComplexModelBase: complex_add, Fault: fault_add, EnumBase: enum_add, }) _get_restriction_tag_handlers = cdict({ object: lambda self, cls: None, SimpleModel: simple_get_restriction_tag, Unicode: unicode_get_restriction_tag, Decimal: Tget_range_restriction_tag(Decimal), DateTime: Tget_range_restriction_tag(DateTime),
class ProtocolBase(object): """This is the abstract base class for all protocol implementations. Child classes can implement only the required subset of the public methods. An output protocol must implement :func:`serialize` and :func:`create_out_string`. An input protocol must implement :func:`create_in_document`, :func:`decompose_incoming_envelope` and :func:`deserialize`. The ProtocolBase class supports the following events: * ``before_deserialize``: Called before the deserialization operation is attempted. * ``after_deserialize``: Called after the deserialization operation is finished. * ``before_serialize``: Called before after the serialization operation is attempted. * ``after_serialize``: Called after the serialization operation is finished. The arguments the constructor takes are as follows: :param app: The application this protocol belongs to. :param validator: The type of validation this protocol should do on incoming data. :param mime_type: The mime_type this protocol should set for transports that support this. This is a quick way to override the mime_type by default instead of subclassing the releavant protocol implementation. :param skip_depth: Number of wrapper classes to ignore. This is typically one of (0, 1, 2) but higher numbers may also work for your case. :param ignore_uncap: Silently ignore cases when the protocol is not capable of serializing return values instead of raising a TypeError. """ __metaclass__ = ProtocolBaseMeta allowed_http_verbs = None mime_type = 'application/octet-stream' SOFT_VALIDATION = type("Soft", (object, ), {}) REQUEST = type("Request", (object, ), {}) RESPONSE = type("Response", (object, ), {}) type = set() """Set that contains keywords about a protocol.""" default_binary_encoding = None _to_string_handlers = cdict({ ModelBase: lambda cls, value: cls.to_string(value), Null: null_to_string, AnyXml: any_xml_to_string, Unicode: unicode_to_string, Decimal: decimal_to_string, Double: double_to_string, Integer: integer_to_string, Time: time_to_string, DateTime: datetime_to_string, Duration: duration_to_string, Boolean: boolean_to_string, ByteArray: byte_array_to_string, Attachment: attachment_to_string, ComplexModelBase: complex_model_base_to_string, }) _to_string_iterable_handlers = cdict({ ModelBase: lambda prot, cls, value: cls.to_string_iterable(value), SimpleModel: lambda prot, cls, value: (prot._to_string_handlers[cls](cls, value), ), ByteArray: byte_array_to_string_iterable, File: file_to_string_iterable, }) _from_string_handlers = cdict({ Null: null_from_string, AnyXml: any_xml_from_string, Unicode: unicode_from_string, String: string_from_string, Decimal: decimal_from_string, Double: double_from_string, Integer: integer_from_string, Time: time_from_string, DateTime: datetime_from_string, Date: date_from_string, Duration: duration_from_string, Boolean: boolean_from_string, ByteArray: byte_array_from_string, File: file_from_string, Attachment: attachment_from_string, ComplexModelBase: complex_model_base_from_string }) _to_dict_handlers = cdict({ ModelBase: lambda cls, value: cls.to_dict(value), ComplexModelBase: complex_model_base_to_dict, Fault: fault_to_dict, }) def __init__(self, app=None, validator=None, mime_type=None, skip_depth=0, ignore_uncap=False): self.__app = None self.validator = None self.set_app(app) self.event_manager = EventManager(self) self.set_validator(validator) self.skip_depth = skip_depth self.ignore_uncap = ignore_uncap if mime_type is not None: self.mime_type = mime_type @property def app(self): return self.__app def set_app(self, value): assert self.__app is None, "One protocol instance should belong to one " \ "application instance." self.__app = value def create_in_document(self, ctx, in_string_encoding=None): """Uses ``ctx.in_string`` to set ``ctx.in_document``.""" def decompose_incoming_envelope(self, ctx, message): """Sets the ``ctx.method_request_string``, ``ctx.in_body_doc``, ``ctx.in_header_doc`` and ``ctx.service`` properties of the ctx object, if applicable. """ def deserialize(self, ctx): """Takes a MethodContext instance and a string containing ONE document instance in the ``ctx.in_string`` attribute. Returns the corresponding native python object in the ctx.in_object attribute. """ def serialize(self, ctx): """Takes a MethodContext instance and the object to be serialized in the ctx.out_object attribute. Returns the corresponding document structure in the ctx.out_document attribute. """ def create_out_string(self, ctx, out_string_encoding=None): """Uses ctx.out_document to set ctx.out_string""" def validate_document(self, payload): """Method to be overriden to perform any sort of custom input validation on the parsed input document. """ def generate_method_contexts(self, ctx): """Generates MethodContext instances for every callable assigned to the given method handle. The first element in the returned list is always the primary method context whereas the rest are all auxiliary method contexts. """ call_handles = self.get_call_handles(ctx) if len(call_handles) == 0: raise ResourceNotFoundError('Method %r not found.' % ctx.method_request_string) retval = [] for sc, d in call_handles: c = copy(ctx) assert d != None c.descriptor = d c.service_class = sc retval.append(c) return retval def get_call_handles(self, ctx): """Method to be overriden to perform any sort of custom method mapping using any data in the method context. Returns a list of contexts. Can return multiple contexts if a method_request_string matches more than one function. (This is called the fanout mode.) """ name = ctx.method_request_string if not name.startswith("{"): name = '{%s}%s' % (self.app.interface.get_tns(), name) call_handles = self.app.interface.service_method_map.get(name, []) return call_handles def fault_to_http_response_code(self, fault): """Special function to convert native Python exceptions to Http response codes. """ if isinstance(fault, RequestTooLongError): return HTTP_413 if isinstance(fault, ResourceNotFoundError): return HTTP_404 if isinstance(fault, RequestNotAllowed): return HTTP_405 if isinstance(fault, Fault) and (fault.faultcode.startswith('Client.') or fault.faultcode == 'Client'): return HTTP_400 else: return HTTP_500 def set_validator(self, validator): """You must override this function if you want your protocol to support validation.""" assert validator is None self.validator = None @classmethod def from_string(cls, class_, string): handler = cls._from_string_handlers[class_] return handler(class_, string) @classmethod def to_string(cls, class_, value): handler = cls._to_string_handlers[class_] return handler(class_, value) @classmethod def to_string_iterable(cls, class_, value): handler = cls._to_string_iterable_handlers[class_] return handler(cls, class_, value) @classmethod def to_dict(cls, class_, value): handler = cls._to_dict_handlers[class_] return handler(class_, value)
def __init__( self, app=None, validator=None, xml_declaration=True, cleanup_namespaces=True, encoding=None, pretty_print=False, attribute_defaults=False, dtd_validation=False, load_dtd=False, no_network=True, ns_clean=False, recover=False, remove_blank_text=False, remove_pis=True, strip_cdata=True, resolve_entities=False, huge_tree=False, compact=True, ): super(XmlDocument, self).__init__(app, validator) self.xml_declaration = xml_declaration self.cleanup_namespaces = cleanup_namespaces if encoding is None: self.encoding = 'UTF-8' else: self.encoding = encoding self.pretty_print = pretty_print self.serialization_handlers = cdict({ AnyXml: self.xml_to_parent, Fault: self.fault_to_parent, AnyDict: self.dict_to_parent, AnyHtml: self.html_to_parent, EnumBase: self.enum_to_parent, ModelBase: self.base_to_parent, ByteArray: self.byte_array_to_parent, Attachment: self.attachment_to_parent, XmlAttribute: self.xmlattribute_to_parent, ComplexModelBase: self.complex_to_parent, SchemaValidationError: self.schema_validation_error_to_parent, }) self.deserialization_handlers = cdict({ AnyXml: self.xml_from_element, Array: self.array_from_element, Fault: self.fault_from_element, AnyDict: self.dict_from_element, EnumBase: self.enum_from_element, ModelBase: self.base_from_element, Unicode: self.unicode_from_element, Iterable: self.iterable_from_element, ByteArray: self.byte_array_from_element, Attachment: self.attachment_from_element, ComplexModelBase: self.complex_from_element, }) self.log_messages = (logger.level == logging.DEBUG) self.parser_kwargs = dict( attribute_defaults=attribute_defaults, dtd_validation=dtd_validation, load_dtd=load_dtd, no_network=no_network, ns_clean=ns_clean, recover=recover, remove_blank_text=remove_blank_text, remove_comments=True, remove_pis=remove_pis, strip_cdata=strip_cdata, resolve_entities=resolve_entities, huge_tree=huge_tree, compact=compact, encoding=encoding, )
_prot = XmlDocument() XSD = lambda s: '{%s}%s' % (_ns_xsd, s) # In Xml Schema, some customizations do not need a class to be extended -- they # are specified in-line in the parent class definition, like nullable or # min_occurs. The dict below contains list of parameters that do warrant a # proper subclass definition for each type. This must be updated as the Xml # Schema implementation makes progress. ATTR_NAMES = cdict({ ModelBase: set(['values']), Decimal: set([ 'pattern', 'gt', 'ge', 'lt', 'le', 'values', 'total_digits', 'fraction_digits' ]), Integer: set(['pattern', 'gt', 'ge', 'lt', 'le', 'values', 'total_digits']), Unicode: set(['values', 'min_len', 'max_len', 'pattern']), }) def xml_attribute_add(cls, name, element, document): element.set('name', name) element.set('type', cls.type.get_type_name_ns(document.interface)) if cls._use is not None: element.set('use', cls._use)
MAP = cdict({ ModelBase: cdict({ object: lambda _: _, bytes: lambda _: _.strip(), unicode: lambda _: _.strip(), }), Decimal: cdict({ D: lambda d: d, int: lambda i: D(i), bytes: lambda s: None if s.strip() == '' else D(s.strip()), unicode: lambda s: None if s.strip() == u'' else D(s.strip()), }), Boolean: cdict({ D: lambda d: _bool_from_int(int(d)), int: _bool_from_int, bytes: _bool_from_bytes, unicode: _bool_from_str, }), Integer: cdict({ D: lambda _: _, int: lambda _: _, bytes: lambda s: None if s.strip() == '' else int(s.strip()), unicode: lambda s: None if s.strip() == u'' else int(s.strip()), }), Date: cdict({ date: lambda _: _, datetime: lambda _: _.date(), object: lambda _:_, bytes: lambda s: None if s.strip() in ('', '0000-00-00') else _prot.date_from_unicode(Date, s.strip()), unicode: lambda s: None if s.strip() in (u'', u'0000-00-00') else _prot.date_from_unicode(Date, s.strip()), }), DateTime: cdict({ date: lambda _: datetime(date.year, date.month, date.day), datetime: lambda _: _, object: lambda _:_, bytes: lambda s: None if s.strip() in ('', '0000-00-00 00:00:00') else _prot.datetime_from_unicode(DateTime, s.strip()), unicode: lambda s: None if s.strip() in (u'', u'0000-00-00 00:00:00') else _prot.datetime_from_unicode(DateTime, s.strip()), }), IpAddress: cdict({ object: lambda _: _, bytes: lambda s: None if s.strip() == '' else s.strip(), unicode: lambda s: None if s.strip() == u'' else s.strip(), }) })
def __init__(self, app=None, validator=None, replace_null_with_default=True, xml_declaration=True, cleanup_namespaces=True, encoding=None, pretty_print=False, attribute_defaults=False, dtd_validation=False, load_dtd=False, no_network=True, ns_clean=False, recover=False, remove_blank_text=False, remove_pis=True, strip_cdata=True, resolve_entities=False, huge_tree=False, compact=True, binary_encoding=None, parse_xsi_type=True, polymorphic=False, ): super(XmlDocument, self).__init__(app, validator, binary_encoding=binary_encoding) self.validation_schema = None self.xml_declaration = xml_declaration self.cleanup_namespaces = cleanup_namespaces self.replace_null_with_default = replace_null_with_default if encoding is None: self.encoding = 'UTF-8' else: self.encoding = encoding self.polymorphic = polymorphic self.pretty_print = pretty_print self.parse_xsi_type = parse_xsi_type self.serialization_handlers = cdict({ Any: self.any_to_parent, Fault: self.fault_to_parent, EnumBase: self.enum_to_parent, AnyXml: self.any_xml_to_parent, XmlData: self.xmldata_to_parent, AnyDict: self.any_dict_to_parent, AnyHtml: self.any_html_to_parent, ModelBase: self.modelbase_to_parent, ByteArray: self.byte_array_to_parent, ComplexModelBase: self.complex_to_parent, XmlAttribute: self.xmlattribute_to_parent, SchemaValidationError: self.schema_validation_error_to_parent, }) self.deserialization_handlers = cdict({ AnyHtml: self.html_from_element, AnyXml: self.xml_from_element, Any: self.xml_from_element, Array: self.array_from_element, Fault: self.fault_from_element, AnyDict: self.dict_from_element, EnumBase: self.enum_from_element, ModelBase: self.base_from_element, Unicode: self.unicode_from_element, Iterable: self.iterable_from_element, ByteArray: self.byte_array_from_element, ComplexModelBase: self.complex_from_element, }) self.parser_kwargs = dict( attribute_defaults=attribute_defaults, dtd_validation=dtd_validation, load_dtd=load_dtd, no_network=no_network, ns_clean=ns_clean, recover=recover, remove_blank_text=remove_blank_text, remove_comments=True, remove_pis=remove_pis, strip_cdata=strip_cdata, resolve_entities=resolve_entities, huge_tree=huge_tree, compact=compact, encoding=encoding, )
def __init__(self, app=None, mime_type=None, ignore_uncap=False, ignore_wrappers=False, binary_encoding=None): super(OutProtocolBase, self).__init__(app=app, mime_type=mime_type, ignore_wrappers=ignore_wrappers) self.ignore_uncap = ignore_uncap self.message = None self.binary_encoding = binary_encoding if self.binary_encoding is None: self.binary_encoding = self.default_binary_encoding if mime_type is not None: self.mime_type = mime_type self._to_bytes_handlers = cdict({ ModelBase: self.model_base_to_bytes, File: self.file_to_bytes, Time: self.time_to_bytes, Uuid: self.uuid_to_bytes, Null: self.null_to_bytes, Double: self.double_to_bytes, AnyXml: self.any_xml_to_bytes, Unicode: self.unicode_to_bytes, Boolean: self.boolean_to_bytes, Decimal: self.decimal_to_bytes, Integer: self.integer_to_bytes, AnyHtml: self.any_html_to_bytes, DateTime: self.datetime_to_bytes, Duration: self.duration_to_bytes, ByteArray: self.byte_array_to_bytes, Attachment: self.attachment_to_bytes, XmlAttribute: self.xmlattribute_to_bytes, ComplexModelBase: self.complex_model_base_to_bytes, }) self._to_unicode_handlers = cdict({ ModelBase: self.model_base_to_unicode, File: self.file_to_unicode, Time: self.time_to_bytes, Uuid: self.uuid_to_bytes, Null: self.null_to_bytes, Double: self.double_to_bytes, AnyXml: self.any_xml_to_unicode, Unicode: self.unicode_to_unicode, Boolean: self.boolean_to_bytes, Decimal: self.decimal_to_bytes, Integer: self.integer_to_bytes, AnyHtml: self.any_html_to_unicode, # FIXME: Would we need a to_unicode for localized dates? DateTime: self.datetime_to_bytes, Duration: self.duration_to_bytes, ByteArray: self.byte_array_to_unicode, XmlAttribute: self.xmlattribute_to_unicode, ComplexModelBase: self.complex_model_base_to_bytes, }) self._to_bytes_iterable_handlers = cdict({ File: self.file_to_bytes_iterable, ByteArray: self.byte_array_to_bytes_iterable, ModelBase: self.model_base_to_bytes_iterable, SimpleModel: self.simple_model_to_bytes_iterable, ComplexModelBase: self.complex_model_to_bytes_iterable, })
def __init__(self, app=None, validator=None, mime_type=None, ignore_uncap=False, ignore_wrappers=False, binary_encoding=None): self.validator = None self.set_validator(validator) self.__app = None self.set_app(app) self._attrcache = WeakKeyDictionary() self.event_manager = EventManager(self) self.ignore_uncap = ignore_uncap self.ignore_wrappers = ignore_wrappers self.message = None self.binary_encoding = binary_encoding if self.binary_encoding is None: self.binary_encoding = self.default_binary_encoding if mime_type is not None: self.mime_type = mime_type self._to_string_handlers = cdict({ ModelBase: self.model_base_to_string, File: self.file_to_string, Time: self.time_to_string, Uuid: self.uuid_to_string, Null: self.null_to_string, Double: self.double_to_string, AnyXml: self.any_xml_to_string, Unicode: self.unicode_to_string, Boolean: self.boolean_to_string, Decimal: self.decimal_to_string, Integer: self.integer_to_string, AnyHtml: self.any_html_to_string, DateTime: self.datetime_to_string, Duration: self.duration_to_string, ByteArray: self.byte_array_to_string, Attachment: self.attachment_to_string, XmlAttribute: self.xmlattribute_to_string, ComplexModelBase: self.complex_model_base_to_string, }) self._to_unicode_handlers = cdict({ ModelBase: self.model_base_to_unicode, File: self.file_to_unicode, Time: self.time_to_string, Uuid: self.uuid_to_string, Null: self.null_to_string, Double: self.double_to_string, AnyXml: self.any_xml_to_unicode, Unicode: self.unicode_to_unicode, Boolean: self.boolean_to_string, Decimal: self.decimal_to_string, Integer: self.integer_to_string, AnyHtml: self.any_html_to_unicode, # FIXME: Would we need a to_unicode for localized dates? DateTime: self.datetime_to_string, Duration: self.duration_to_string, ByteArray: self.byte_array_to_unicode, XmlAttribute: self.xmlattribute_to_unicode, ComplexModelBase: self.complex_model_base_to_string, }) self._to_string_iterable_handlers = cdict({ File: self.file_to_string_iterable, ByteArray: self.byte_array_to_string_iterable, ModelBase: self.model_base_to_string_iterable, SimpleModel: self.simple_model_to_string_iterable, ComplexModelBase: self.complex_model_to_string_iterable, }) fsh = { Null: self.null_from_string, Time: self.time_from_string, Date: self.date_from_string, Uuid: self.uuid_from_string, File: self.file_from_string, Array: self.array_from_string, Double: self.double_from_string, String: self.string_from_string, AnyXml: self.any_xml_from_string, Boolean: self.boolean_from_string, Integer: self.integer_from_string, Unicode: self.unicode_from_string, Decimal: self.decimal_from_string, AnyHtml: self.any_html_from_string, DateTime: self.datetime_from_string, Duration: self.duration_from_string, ByteArray: self.byte_array_from_string, EnumBase: self.enum_base_from_string, ModelBase: self.model_base_from_string, Attachment: self.attachment_from_string, XmlAttribute: self.xmlattribute_from_string, ComplexModelBase: self.complex_model_base_from_string } self._from_string_handlers = cdict(fsh) self._from_unicode_handlers = cdict(fsh) self._datetime_dsmap = { None: self._datetime_from_string, 'sec': self._datetime_from_sec, 'sec_float': self._datetime_from_sec_float, 'msec': self._datetime_from_msec, 'msec_float': self._datetime_from_msec_float, 'usec': self._datetime_from_usec, }