Produits Entr'ouvert » Passerelle

import jsonschema

from .logging import ignore_loggers

with ignore_loggers('xmlschema'):

    import xmlschema

def text_content(node):

    """Extract text content from node and all its children. Equivalent to

    xmlNodeGetContent from libxml."""

    if node is None:

        return ''

                mapped = self.transformer.type_map[xsd_element.type.name]

                if hasattr(self.transformer, 'encode_%s' % mapped):

                    obj = getattr(self.transformer, 'encode_%s' % mapped)(obj)

        return super(TransformConverter, self).element_encode(obj, xsd_element, level=level)

class JSONSchemaFromXMLSchema(object):

    SIMPLE_TYPE_MAPPING = {

    }

    def __init__(self, xml_schema, root_element):

        if not isinstance(xml_schema, xmlschema.XMLSchema):

            with ignore_loggers('xmlschema'):

                xml_schema = xmlschema.XMLSchema(xml_schema, converter=TransformConverter(transformer=self))

        self.xml_schema = xml_schema

        self.root_element = root_element

            if simple_type.white_space not in ('collapse', 'preserve'):

                raise NotImplementedError(simple_type)

            schema = OrderedDict(cls.simpletype_to_jsonschema(simple_type.base_type))

            for validator in simple_type.validators:

                if isinstance(validator, xmlschema.validators.XsdEnumerationFacets):

                    schema['enum'] = validator.enumeration

                elif (

                    isinstance(validator, xmlschema.validators.XsdMinLengthFacet)

                ):

                    schema['minLength'] = validator.value

                elif (

                    isinstance(validator, xmlschema.validators.XsdMaxLengthFacet)

                ):

                    schema['maxLength'] = validator.value

                elif (

                    isinstance(validator, xmlschema.validators.XsdLengthFacet)

                ):

                    schema['minLength'] = validator.value

                    schema['maxLength'] = validator.value

                elif isinstance(validator, xmlschema.validators.XsdMinInclusiveFacet):

                    schema['minimum'] = validator.value

                elif isinstance(validator, xmlschema.validators.XsdMaxInclusiveFacet):

                    schema['maximum'] = validator.value

                elif (

                    isinstance(validator, xmlschema.validators.XsdTotalDigitsFacet)

                ):

                    schema['exclusiveMaximum'] = 10**validator.value

                elif (

                    isinstance(validator, xmlschema.validators.XsdFractionDigitsFacet)

                ):

                    schema['multipleOf'] = 1 / 10.0**validator.value

                else:

                    raise NotImplementedError(validator)

            add_patterns()

            return schema

        if isinstance(simple_type, xmlschema.validators.XsdUnion):

            base_schema = cls.type_to_jsonschema(xmltype.base_type)

            if not xmltype.attributes:

                schema = base_schema

            else:

                cls.attributegroup_to_jsonschema(xmltype.attributes)

                schema['properties']['$'] = base_schema

            return schema

        else:

                raise NotImplementedError(xmltype)

            schema = OrderedDict({'type': 'object'})

            schema['additionalProperties'] = False

            if xmltype.attributes:

                cls.attributegroup_to_jsonschema(xmltype.attributes, schema)

            cls.group_to_jsonschema(xmltype.content_type, schema)

            return schema