开源软件构建与测试

Changes of Revision 2

_service:tar_scm:python-xmlschema.spec Changed

@@ -1,11 +1,11 @@
 %global _empty_manifest_terminate_build 0
 Name:           python-xmlschema
-Version:        1.5.2
+Version:        1.9.2
 Release:        1
 Summary:        An XML Schema validator and decoder
 License:        MIT
 URL:            https://github.com/sissaschool/xmlschema
-Source0:        https://files.pythonhosted.org/packages/5e/45/3c66bbae8a6773bf1559e6eedb4b97b8c656dc4b22a7157b852d50a0b0b9/xmlschema-1.5.2.tar.gz
+Source0:        https://files.pythonhosted.org/packages/49/6e/abc3be7ab1deb38dcb5721b58fd9ab2451ace530a1d247c49b675efa90fc/xmlschema-1.9.2.tar.gz
 BuildArch:      noarch
 %description
 An XML Schema validator and decoder
@@ -29,6 +29,8 @@
 BuildRequires:  python3-memory-profiler
 BuildRequires:  python3-sphinx
 BuildRequires:  python3-sphinx_rtd_theme
+BuildRequires:  python3-flake8
+BuildRequires:  python3-mypy
 # General requires
 Requires:       python3-elementpath
 Requires:       python3-jinja2
@@ -38,6 +40,8 @@
 Requires:       python3-memory-profiler
 Requires:       python3-sphinx
 Requires:       python3-sphinx_rtd_theme
+Requires:       python3-flake8
+Requires:       python3-mypy
 %description -n python3-xmlschema
 An XML Schema validator and decoder
 
@@ -48,14 +52,14 @@
 An XML Schema validator and decoder
 
 %prep
-%autosetup -n xmlschema-1.5.2
+%autosetup -n xmlschema-%{version}
 
 %build
 %py3_build
 
-
 %install
 %py3_install
+
 install -d -m755 %{buildroot}/%{_pkgdocdir}
 if  -d doc ; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
 if  -d docs ; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
@@ -82,13 +86,16 @@
 mv %{buildroot}/filelist.lst .
 mv %{buildroot}/doclist.lst .
 
+
 %files -n python3-xmlschema -f filelist.lst
 %dir %{python3_sitelib}/*
 
-
 %files help -f doclist.lst
 %{_docdir}/*
 
 %changelog
+* Fri Jul 15 2022 OpenStack_SIG <openstack@openeuler.org> - 1.9.2-1
+- Upgrade package python3-xmlschema to version 1.9.2
+
 * Mon Jul 19 2021 OpenStack_SIG <openstack@openeuler.org> - 1.5.2-1
 - Package Spec generate

_service Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/validators/test_schema_class.py Deleted

@@ -1,729 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright (c), 2016-2020, SISSA (International School for Advanced Studies).
-# All rights reserved.
-# This file is distributed under the terms of the MIT License.
-# See the file 'LICENSE' in the root directory of the present
-# distribution, or http://opensource.org/licenses/MIT.
-#
-# @author Davide Brunato <brunato@sissa.it>
-#
-import unittest
-import logging
-import tempfile
-import warnings
-import pathlib
-import platform
-import glob
-import os
-import re
-from textwrap import dedent
-
-from xmlschema import XMLSchemaParseError, XMLSchemaIncludeWarning, XMLSchemaImportWarning
-from xmlschema.names import XML_NAMESPACE, LOCATION_HINTS, SCHEMAS_DIR, XSD_ELEMENT, XSI_TYPE
-from xmlschema.etree import etree_element
-from xmlschema.validators import XMLSchemaBase, XMLSchema11, XsdGlobals
-from xmlschema.testing import SKIP_REMOTE_TESTS, XsdValidatorTestCase
-from xmlschema.validators.schema import logger, XMLSchemaNotBuiltError
-
-
-class TestXMLSchema10(XsdValidatorTestCase):
-    TEST_CASES_DIR = os.path.join(os.path.dirname(__file__), '../test_cases')
-    maxDiff = None
-
-    def test_schema_validation(self):
-        schema = self.schema_class(self.vh_xsd_file)
-        self.assertEqual(schema.validation, 'strict')
-
-        schema = self.schema_class(self.vh_xsd_file, validation='lax')
-        self.assertEqual(schema.validation, 'lax')
-
-        schema = self.schema_class(self.vh_xsd_file, validation='skip')
-        self.assertEqual(schema.validation, 'skip')
-
-        with self.assertRaises(ValueError):
-            self.schema_class(self.vh_xsd_file, validation='none')
-
-    def test_schema_string_repr(self):
-        schema = self.schema_class(self.vh_xsd_file)
-        tmpl = "%s(name='vehicles.xsd', namespace='http://example.com/vehicles')"
-        self.assertEqual(str(schema), tmpl % self.schema_class.__name__)
-
-    def test_schema_copy(self):
-        schema = self.vh_schema.copy()
-        self.assertNotEqual(id(self.vh_schema), id(schema))
-        self.assertNotEqual(id(self.vh_schema.namespaces), id(schema.namespaces))
-        self.assertNotEqual(id(self.vh_schema.maps), id(schema.maps))
-
-    def test_schema_location_hints(self):
-        with warnings.catch_warnings(record=True):
-            warnings.simplefilter("always")
-            schema = self.schema_class(dedent("""\
-                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
-                    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-                    xsi:schemaLocation="http://xmlschema.test/ns schema.xsd">
-                  <xs:element name="root" />
-                </xs:schema>"""))
-
-        self.assertEqual(schema.schema_location, ("http://xmlschema.test/ns", "schema.xsd"))
-        self.assertIsNone(schema.no_namespace_schema_location)
-
-        schema = self.schema_class(dedent("""\
-            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
-                xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-                xsi:noNamespaceSchemaLocation="schema.xsd">
-              <xs:element name="root" />
-            </xs:schema>"""))
-
-        self.assertEqual(schema.schema_location, )
-        self.assertEqual(schema.no_namespace_schema_location, 'schema.xsd')
-
-    def test_target_prefix(self):
-        schema = self.schema_class(dedent("""\
-            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
-                targetNamespace="http://xmlschema.test/ns">
-              <xs:element name="root" />
-            </xs:schema>"""))
-
-        self.assertEqual(schema.target_prefix, '')
-
-        schema = self.schema_class(dedent("""\
-            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
-                xmlns:tns="http://xmlschema.test/ns"
-                targetNamespace="http://xmlschema.test/ns">
-              <xs:element name="root" />
-            </xs:schema>"""))
-
-        self.assertEqual(schema.target_prefix, 'tns')
-
-    def test_builtin_types(self):
-        self.assertIn('string', self.schema_class.builtin_types())
-
-        with self.assertRaises(XMLSchemaNotBuiltError):
-            self.schema_class.meta_schema.builtin_types()
-
-    def test_resolve_qname(self):
-        schema = self.schema_class(dedent("""\
-            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
-                xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">    
-              <xs:element name="root" />
-            </xs:schema>"""))
-
-        self.assertEqual(schema.resolve_qname('xs:element'), XSD_ELEMENT)
-        self.assertEqual(schema.resolve_qname('xsi:type'), XSI_TYPE)
-
-        self.assertEqual(schema.resolve_qname(XSI_TYPE), XSI_TYPE)
-        self.assertEqual(schema.resolve_qname('element'), 'element')
-        self.assertRaises(ValueError, schema.resolve_qname, '')
-        self.assertRaises(ValueError, schema.resolve_qname, 'xsi:a type ')
-        self.assertRaises(ValueError, schema.resolve_qname, 'xml::lang')
-
-    def test_global_group_definitions(self):
-        schema = self.check_schema("""
-            <xs:group name="wrong_child">
-              <xs:element name="foo"/>
-            </xs:group>""", validation='lax')
-        self.assertEqual(len(schema.errors), 1)
-
-        self.check_schema('<xs:group name="empty" />', XMLSchemaParseError)
-        self.check_schema('<xs:group name="empty"><xs:annotation/></xs:group>', XMLSchemaParseError)
-
-    def test_wrong_includes_and_imports(self):
-
-        with warnings.catch_warnings(record=True) as context:
-            warnings.simplefilter("always")
-            self.check_schema("""
-            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="ns">
-                <xs:include schemaLocation="example.xsd" />
-                <xs:import schemaLocation="example.xsd" />
-                <xs:redefine schemaLocation="example.xsd"/>
-                <xs:import namespace="http://missing.example.test/" />
-                <xs:import/>
-            </xs:schema>
-            """)
-            self.assertEqual(len(context), 3, "Wrong number of include/import warnings")
-            self.assertEqual(context0.category, XMLSchemaIncludeWarning)
-            self.assertEqual(context1.category, XMLSchemaIncludeWarning)
-            self.assertEqual(context2.category, XMLSchemaImportWarning)
-            self.assertTrue(str(context0.message).startswith("Include"))
-            self.assertTrue(str(context1.message).startswith("Redefine"))
-            self.assertTrue(str(context2.message).startswith("Import of namespace"))
-
-    def test_wrong_references(self):
-        # Wrong namespace for element type's reference
-        self.check_schema("""
-        <xs:element name="dimension" type="xs:dimensionType"/>
-        <xs:simpleType name="dimensionType">
-          <xs:restriction base="xs:short"/>
-        </xs:simpleType>
-        """, XMLSchemaParseError)
-
-    def test_annotations(self):
-        schema = self.check_schema("""
-            <xs:element name='foo'>
-                <xs:annotation />
-            </xs:element>""")
-        self.assertIsNotNone(schema.elements'foo'.annotation)
-
-        schema = self.check_schema("""
-        <xs:simpleType name='Magic'>
-            <xs:annotation>
-                <xs:documentation> stuff </xs:documentation>
-            </xs:annotation>
-            <xs:restriction base='xs:string'>
-                <xs:enumeration value='A'/>
-            </xs:restriction>
-        </xs:simpleType>""")
-        self.assertIsNotNone(schema.types"Magic".annotation)
-
-        self.check_schema("""
-        <xs:simpleType name='Magic'>
-            <xs:annotation />
-            <xs:annotation />
-            <xs:restriction base='xs:string'>
-                <xs:enumeration value='A'/>
-            </xs:restriction>
-        </xs:simpleType>""", XMLSchemaParseError)
-
-    def test_base_schemas(self):
-        xsd_file = os.path.join(SCHEMAS_DIR, 'XML/xml_minimal.xsd')
-        schema = self.schema_class(xsd_file)
-        self.assertEqual(schema.target_namespace, XML_NAMESPACE)
-
-    def test_root_elements(self):
-        schema = self.schema_class(dedent("""\
-            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"/>"""))
-        self.assertEqual(schema.root_elements, )
-
-        schema = self.schema_class(dedent("""\
-            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
-              <xs:element name="root" />
-            </xs:schema>"""))
-        self.assertEqual(schema.root_elements, schema.elements'root')
-
-        # Test issue #107 fix
-        schema = self.schema_class(dedent("""\
-            <?xml version="1.0" encoding="utf-8"?>
-            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
-                <xs:element name="root1" type="root"/>
-                <xs:element name="root2" type="root"/>
-                <xs:complexType name="root">
-                    <xs:sequence>
-                        <xs:element name="elementWithNoType"/>
-                    </xs:sequence>
-                </xs:complexType>
-            </xs:schema>"""))
-
-        self.assertEqual(set(schema.root_elements),
-                         {schema.elements'root1', schema.elements'root2'})
-
-    def test_simple_types(self):
-        self.assertListEqual(self.vh_schema.simple_types, )
-        self.assertGreater(len(self.st_schema.simple_types), 20)
-
-    def test_complex_types(self):
-        self.assertListEqual(self.vh_schema.complex_types,
-                             self.vh_schema.types'vehicleType')
-
-    def test_is_restriction_method(self):
-        # Test issue #111 fix
-        schema = self.schema_class(source=self.casepath('issues/issue_111/issue_111.xsd'))
-        extended_header_def = schema.types'extendedHeaderDef'
-        self.assertTrue(extended_header_def.is_derived(schema.types'blockDef'))
-
-    @unittest.skipIf(SKIP_REMOTE_TESTS, "Remote networks are not accessible.")
-    def test_remote_schemas_loading(self):
-        col_schema = self.schema_class("https://raw.githubusercontent.com/brunato/xmlschema/master/"
-                                       "tests/test_cases/examples/collection/collection.xsd",
-                                       timeout=300)
-        self.assertTrue(isinstance(col_schema, self.schema_class))
-        vh_schema = self.schema_class("https://raw.githubusercontent.com/brunato/xmlschema/master/"
-                                      "tests/test_cases/examples/vehicles/vehicles.xsd",
-                                      timeout=300)
-        self.assertTrue(isinstance(vh_schema, self.schema_class))
-
-    def test_schema_defuse(self):
-        vh_schema = self.schema_class(self.vh_xsd_file, defuse='always')
-        self.assertIsInstance(vh_schema.root, etree_element)
-        for schema in vh_schema.maps.iter_schemas():
-            self.assertIsInstance(schema.root, etree_element)
-
-    def test_logging(self):
-        self.schema_class(self.vh_xsd_file, loglevel=logging.ERROR)
-        self.assertEqual(logger.level, logging.WARNING)
-
-        with self.assertLogs('xmlschema', level='INFO') as ctx:
-            self.schema_class(self.vh_xsd_file, loglevel=logging.INFO)
-
-        self.assertEqual(logger.level, logging.WARNING)
-        self.assertEqual(len(ctx.output), 7)
-        self.assertIn("INFO:xmlschema:Include schema from 'types.xsd'", ctx.output)
-        self.assertIn("INFO:xmlschema:Resource 'types.xsd' is already loaded", ctx.output)
-
-        with self.assertLogs('xmlschema', level='DEBUG') as ctx:
-            self.schema_class(self.vh_xsd_file, loglevel=logging.DEBUG)
-
-        self.assertEqual(logger.level, logging.WARNING)
-        self.assertEqual(len(ctx.output), 19)
-        self.assertIn("INFO:xmlschema:Include schema from 'cars.xsd'", ctx.output)
-        self.assertIn("INFO:xmlschema:Resource 'cars.xsd' is already loaded", ctx.output)
-        self.assertIn("DEBUG:xmlschema:Schema targetNamespace is "
-                      "'http://example.com/vehicles'", ctx.output)
-        self.assertIn("INFO:xmlschema:Resource 'cars.xsd' is already loaded", ctx.output)
-
-        # With string argument
-        with self.assertRaises(ValueError) as ctx:
-            self.schema_class(self.vh_xsd_file, loglevel='all')
-        self.assertEqual(str(ctx.exception), "'all' is not a valid loglevel")
-
-        with self.assertLogs('xmlschema', level='INFO') as ctx:
-            self.schema_class(self.vh_xsd_file, loglevel='INFO')
-        self.assertEqual(len(ctx.output), 7)
-
-        with self.assertLogs('xmlschema', level='INFO') as ctx:
-            self.schema_class(self.vh_xsd_file, loglevel='  Info ')
-        self.assertEqual(len(ctx.output), 7)
-
-    def test_target_namespace(self):
-        schema = self.schema_class(dedent("""\
-            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
-                    targetNamespace="http://xmlschema.test/ns">
-                <xs:element name="root"/>
-            </xs:schema>"""))
-        self.assertEqual(schema.target_namespace, 'http://xmlschema.test/ns')
-
-        schema = self.schema_class(dedent("""\
-            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
-                <xs:element name="root"/>
-            </xs:schema>"""))
-        self.assertEqual(schema.target_namespace, '')
-
-        with self.assertRaises(XMLSchemaParseError) as ctx:
-            self.schema_class(dedent("""\
-                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
-                        targetNamespace="">
-                    <xs:element name="root"/>
-                </xs:schema>"""))
-
-        self.assertEqual(ctx.exception.message,
-                         "the attribute 'targetNamespace' cannot be an empty string")
-
-    def test_block_default(self):
-        schema = self.schema_class(dedent("""\
-            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
-                    blockDefault="extension restriction ">
-                <xs:element name="root"/>
-            </xs:schema>"""))
-        self.assertEqual(schema.block_default, 'extension restriction ')
-
-        schema = self.schema_class(dedent("""\
-            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
-                    blockDefault="#all">
-                <xs:element name="root"/>
-            </xs:schema>"""))
-        self.assertEqual(set(schema.block_default.split()),
-                         {'substitution', 'extension', 'restriction'})
-
-        with self.assertRaises(XMLSchemaParseError) as ctx:
-            self.schema_class(dedent("""\
-                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
-                        blockDefault="all">>
-                    <xs:element name="root"/>
-                </xs:schema>"""))
-
-        self.assertEqual(ctx.exception.message,
-                         "wrong value 'all' for attribute 'blockDefault'")
-
-        with self.assertRaises(XMLSchemaParseError) as ctx:
-            self.schema_class(dedent("""\
-                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
-                        blockDefault="#all restriction">>
-                    <xs:element name="root"/>
-                </xs:schema>"""))
-
-        self.assertEqual(ctx.exception.message,
-                         "wrong value '#all restriction' for attribute 'blockDefault'")
-
-    def test_final_default(self):
-        schema = self.schema_class(dedent("""\
-            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
-                    finalDefault="extension restriction ">
-                <xs:element name="root"/>
-            </xs:schema>"""))
-        self.assertEqual(schema.final_default, 'extension restriction ')
-
-        schema = self.schema_class(dedent("""\
-            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
-                    finalDefault="#all">
-                <xs:element name="root"/>
-            </xs:schema>"""))
-        self.assertEqual(set(schema.final_default.split()),
-                         {'list', 'union', 'extension', 'restriction'})
-
-        with self.assertRaises(XMLSchemaParseError) as ctx:
-            self.schema_class(dedent("""\
-                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
-                        finalDefault="all">>
-                    <xs:element name="root"/>
-                </xs:schema>"""))
-
-        self.assertEqual(ctx.exception.message,
-                         "wrong value 'all' for attribute 'finalDefault'")
-
-    def test_use_fallback(self):
-        source = dedent("""\
-            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
-                <xs:element name="root"/>
-            </xs:schema>""")
-
-        schema = self.schema_class(source)
-        self.assertEqual(schema.fallback_locations, LOCATION_HINTS)
-        schema = self.schema_class(source, use_fallback=False)
-        self.assertEqual(schema.fallback_locations, {})
-
-    def test_global_maps(self):
-        source = dedent("""\
-                    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
-                        <xs:element name="root"/>
-                    </xs:schema>""")
-        col_schema = self.schema_class(self.col_xsd_file)
-
-        with self.assertRaises(TypeError) as ctx:
-            self.schema_class(self.col_schema, global_maps=col_schema)
-        self.assertIn("'global_maps' argument must be", str(ctx.exception))
-
-        schema = self.schema_class(source, global_maps=col_schema.maps)
-        self.assertIs(col_schema.maps, schema.maps)
-
-    def test_version_control(self):
-        schema = self.schema_class(dedent("""
-            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
-                <xs:element name="root">
-                    <xs:complexType>
-                        <xs:attribute name="a" use="required"/>
-                        <xs:assert test="@a > 300" vc:minVersion="1.1" 
-                            xmlns:vc="http://www.w3.org/2007/XMLSchema-versioning"/>
-                    </xs:complexType>
-                </xs:element>
-            </xs:schema>"""))
-        self.assertEqual(len(schema.root00), 1 if schema.XSD_VERSION == '1.0' else 2)
-
-        schema = self.schema_class(dedent("""
-            <xs:schema vc:minVersion="1.1" elementFormDefault="qualified" 
-                    xmlns:xs="http://www.w3.org/2001/XMLSchema" 
-                    xmlns:vc="http://www.w3.org/2007/XMLSchema-versioning">
-                <xs:element name="root"/>
-            </xs:schema>"""))
-        self.assertEqual(len(schema.root), 0 if schema.XSD_VERSION == '1.0' else 1)
-
-    def test_xsd_version_compatibility_property(self):
-        self.assertEqual(self.vh_schema.xsd_version, self.vh_schema.XSD_VERSION)
-
-    def test_explicit_locations(self):
-        source = dedent("""\
-            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
-                <xs:element name="root"/>
-            </xs:schema>""")
-
-        locations = {'http://example.com/vehicles': self.vh_xsd_file}
-        schema = self.schema_class(source, locations=locations)
-        self.assertEqual(len(schema.maps.namespaces'http://example.com/vehicles'), 4)
-
-    def test_use_meta_property(self):
-        self.assertTrue(self.vh_schema.use_meta)
-        self.assertTrue(self.col_schema.use_meta)
-
-        meta_schema = self.schema_class.meta_schema
-
-        schema = self.schema_class(dedent("""\
-            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
-                <xs:element name="foo"/>
-            </xs:schema>"""), use_meta=False)
-        self.assertIsNot(meta_schema, schema.meta_schema)
-        self.assertFalse(schema.use_meta)
-
-    def test_other_schema_root_attributes(self):
-        self.assertIsNone(self.vh_schema.id)
-        self.assertIsNone(self.vh_schema.version)
-
-        schema = self.schema_class(dedent("""\
-            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" id="foo" version="2.0">
-                <xs:element name="foo"/>
-            </xs:schema>"""))
-        self.assertEqual(schema.id, 'foo')
-        self.assertEqual(schema.version, '2.0')
-
-    def test_change_maps_attribute(self):
-        schema = self.schema_class(dedent("""\
-            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
-                <xs:element name="root"/>
-            </xs:schema>"""))
-
-        with self.assertRaises(ValueError) as ctx:
-            schema.meta_schema.maps = XsdGlobals(schema, schema.validation)
-        self.assertEqual(str(ctx.exception),
-                         "cannot change the global maps instance of a meta-schema")
-
-        self.assertTrue(schema.built)
-        maps, schema.maps = schema.maps, XsdGlobals(schema, schema.validation)
-        self.assertIsNot(maps, schema.maps)
-        self.assertFalse(schema.built)
-        schema.maps = maps
-        self.assertTrue(schema.built)
-
-    def test_listed_and_reversed_elements(self):
-        schema = self.schema_class(dedent("""\
-            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
-                <xs:element name="elem1"/>
-                <xs:element name="elem2"/>
-                <xs:element name="elem3"/>
-            </xs:schema>"""))
-
-        elements = list(schema)
-        self.assertListEqual(elements, schema.elements'elem1',
-                                        schema.elements'elem2',
-                                        schema.elements'elem3')
-        elements.reverse()
-        self.assertListEqual(elements, list(reversed(schema)))
-
-    def test_export_errors__issue_187(self):
-        with self.assertRaises(ValueError) as ctx:
-            self.vh_schema.export(target=self.vh_dir)
-
-        self.assertIn("target directory", str(ctx.exception))
-        self.assertIn("is not empty", str(ctx.exception))
-
-        with self.assertRaises(ValueError) as ctx:
-            self.vh_schema.export(target=self.vh_xsd_file)
-
-        self.assertIn("target", str(ctx.exception))
-        self.assertIn("is not a directory", str(ctx.exception))
-
-        with self.assertRaises(ValueError) as ctx:
-            self.vh_schema.export(target=self.vh_xsd_file + '/target')
-
-        self.assertIn("target parent", str(ctx.exception))
-        self.assertIn("is not a directory", str(ctx.exception))
-
-        with tempfile.TemporaryDirectory() as dirname:
-            with self.assertRaises(ValueError) as ctx:
-                self.vh_schema.export(target=dirname + 'subdir/target')
-
-            self.assertIn("target parent directory", str(ctx.exception))
-            self.assertIn("does not exist", str(ctx.exception))
-
-    def test_export_same_directory__issue_187(self):
-        with tempfile.TemporaryDirectory() as dirname:
-            self.vh_schema.export(target=dirname)
-
-            for filename in os.listdir(dirname):
-                with pathlib.Path(dirname).joinpath(filename).open() as fp:
-                    exported_schema = fp.read()
-                with pathlib.Path(self.vh_dir).joinpath(filename).open() as fp:
-                    original_schema = fp.read()
-
-                if platform.system() == 'Windows':
-                    exported_schema = re.sub(r'\s+', '', exported_schema)
-                    original_schema = re.sub(r'\s+', '', original_schema)
-
-                self.assertEqual(exported_schema, original_schema)
-
-        self.assertFalse(os.path.isdir(dirname))
-
-    def test_export_another_directory__issue_187(self):
-        vh_schema_file = self.casepath('issues/issue_187/issue_187_1.xsd')
-        vh_schema = self.schema_class(vh_schema_file)
-
-        with tempfile.TemporaryDirectory() as dirname:
-            vh_schema.export(target=dirname)
-
-            path = pathlib.Path(dirname).joinpath('examples/vehicles/*.xsd')
-            for filename in glob.iglob(pathname=str(path)):
-                with pathlib.Path(dirname).joinpath(filename).open() as fp:
-                    exported_schema = fp.read()
-
-                basename = os.path.basename(filename)
-                with pathlib.Path(self.vh_dir).joinpath(basename).open() as fp:
-                    original_schema = fp.read()
-
-                if platform.system() == 'Windows':
-                    exported_schema = re.sub(r'\s+', '', exported_schema)
-                    original_schema = re.sub(r'\s+', '', original_schema)
-
-                self.assertEqual(exported_schema, original_schema)
-
-            with pathlib.Path(dirname).joinpath('issue_187_1.xsd').open() as fp:
-                exported_schema = fp.read()
-            with open(vh_schema_file) as fp:
-                original_schema = fp.read()
-
-            if platform.system() == 'Windows':
-                exported_schema = re.sub(r'\s+', '', exported_schema)
-                original_schema = re.sub(r'\s+', '', original_schema)
-
-            self.assertNotEqual(exported_schema, original_schema)
-            self.assertEqual(
-                exported_schema,
-                original_schema.replace('../..', dirname.replace('\\', '/'))
-            )
-
-        self.assertFalse(os.path.isdir(dirname))
-
-    @unittest.skipIf(SKIP_REMOTE_TESTS, "Remote networks are not accessible.")
-    def test_export_remote__issue_187(self):
-        vh_schema_file = self.casepath('issues/issue_187/issue_187_2.xsd')
-        vh_schema = self.schema_class(vh_schema_file)
-
-        with tempfile.TemporaryDirectory() as dirname:
-            vh_schema.export(target=dirname)
-
-            with pathlib.Path(dirname).joinpath('issue_187_2.xsd').open() as fp:
-                exported_schema = fp.read()
-            with open(vh_schema_file) as fp:
-                original_schema = fp.read()
-
-            if platform.system() == 'Windows':
-                exported_schema = re.sub(r'\s+', '', exported_schema)
-                original_schema = re.sub(r'\s+', '', original_schema)
-
-            self.assertEqual(exported_schema, original_schema)
-
-        self.assertFalse(os.path.isdir(dirname))
-
-        with tempfile.TemporaryDirectory() as dirname:
-            vh_schema.export(target=dirname, only_relative=False)
-            path = pathlib.Path(dirname).joinpath('brunato/xmlschema/master/tests/test_cases/'
-                                                  'examples/vehicles/*.xsd')
-
-            for filename in glob.iglob(pathname=str(path)):
-                with pathlib.Path(dirname).joinpath(filename).open() as fp:
-                    exported_schema = fp.read()
-
-                basename = os.path.basename(filename)
-                with pathlib.Path(self.vh_dir).joinpath(basename).open() as fp:
-                    original_schema = fp.read()
-                self.assertEqual(exported_schema, original_schema)
-
-            with pathlib.Path(dirname).joinpath('issue_187_2.xsd').open() as fp:
-                exported_schema = fp.read()
-            with open(vh_schema_file) as fp:
-                original_schema = fp.read()
-
-            if platform.system() == 'Windows':
-                exported_schema = re.sub(r'\s+', '', exported_schema)
-                original_schema = re.sub(r'\s+', '', original_schema)
-
-            self.assertNotEqual(exported_schema, original_schema)
-            self.assertEqual(
-                exported_schema,
-                original_schema.replace('https://raw.githubusercontent.com',
-                                        dirname.replace('\\', '/') + '/raw.githubusercontent.com')
-            )
-
-        self.assertFalse(os.path.isdir(dirname))
-
-
-class TestXMLSchema11(TestXMLSchema10):
-
-    schema_class = XMLSchema11
-
-    def test_default_attributes(self):
-        schema = self.schema_class(dedent("""\
-                    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
-                            defaultAttributes="attrs">
-                        <xs:element name="root"/>
-                        <xs:attributeGroup name="attrs">
-                            <xs:attribute name="a"/>
-                        </xs:attributeGroup>
-                    </xs:schema>"""))
-        self.assertIs(schema.default_attributes, schema.attribute_groups'attrs')
-
-        with self.assertRaises(XMLSchemaParseError) as ctx:
-            self.schema_class(dedent("""\
-                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
-                        defaultAttributes="attrs">
-                    <xs:element name="root"/>
-                </xs:schema>"""))
-        self.assertIn("'attrs' doesn't match an attribute group", ctx.exception.message)
-
-        with self.assertRaises(XMLSchemaParseError) as ctx:
-            self.schema_class(dedent("""\
-                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
-                        defaultAttributes="x:attrs">
-                    <xs:element name="root"/>
-                </xs:schema>"""))
-        self.assertEqual("prefix 'x' not found in namespace map", ctx.exception.message)
-
-
-class TestXMLSchemaMeta(unittest.TestCase):
-
-    def test_wrong_version(self):
-        with self.assertRaises(ValueError) as ctx:
-            class XMLSchema12(XMLSchemaBase):
-                XSD_VERSION = '1.2'
-                meta_schema = os.path.join(SCHEMAS_DIR, 'XSD_1.1/XMLSchema.xsd')
-
-            assert issubclass(XMLSchema12, XMLSchemaBase)
-
-        self.assertEqual(str(ctx.exception), "XSD_VERSION must be '1.0' or '1.1'")
-
-    def test_missing_builders(self):
-        with self.assertRaises(ValueError) as ctx:
-            class XMLSchema12(XMLSchemaBase):
-                XSD_VERSION = '1.1'
-                meta_schema = os.path.join(SCHEMAS_DIR, 'XSD_1.1/XMLSchema.xsd')
-
-            assert issubclass(XMLSchema12, XMLSchemaBase)
-
-        self.assertEqual(str(ctx.exception),
-                         "validator class doesn't have defined XSD builders")
-
-    def test_missing_builder_map(self):
-        with self.assertRaises(ValueError) as ctx:
-            class XMLSchema12(XMLSchemaBase):
-                XSD_VERSION = '1.1'
-                meta_schema = os.path.join(SCHEMAS_DIR, 'XSD_1.1/XMLSchema.xsd')
-                BUILDERS = XMLSchema11.BUILDERS
-
-            assert issubclass(XMLSchema12, XMLSchemaBase)
-
-        self.assertEqual(str(ctx.exception),
-                         "validator class doesn't have a builder map for XSD globals")
-
-    def test_from_schema_class(self):
-        class XMLSchema11Bis(XMLSchema11):
-            pass
-
-        self.assertTrue(issubclass(XMLSchema11Bis, XMLSchemaBase))
-
-    def test_dummy_validator_class(self):
-        class DummySchema(XMLSchemaBase):
-            XSD_VERSION = '1.1'
-            meta_schema = os.path.join(SCHEMAS_DIR, 'XSD_1.1/XMLSchema.xsd')
-            BUILDERS = {
-                'notation_class': None,
-                'complex_type_class': None,
-                'attribute_class': None,
-                'any_attribute_class': None,
-                'attribute_group_class': None,
-                'group_class': None,
-                'element_class': None,
-                'any_element_class': None,
-                'restriction_class': None,
-                'union_class': None,
-                'key_class': None,
-                'keyref_class': None,
-                'unique_class': None,
-                'simple_type_factory': None,
-            }
-            BASE_SCHEMAS = {}
-
-        self.assertTrue(issubclass(DummySchema, XMLSchemaBase))
-
-
-if __name__ == '__main__':
-    header_template = "Test xmlschema's schema classes with Python {} on {}"
-    header = header_template.format(platform.python_version(), platform.platform())
-    print('{0}\n{1}\n{0}'.format("*" * len(header), header))
-
-    unittest.main()

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/validators/schema.py Deleted

@@ -1,1932 +0,0 @@
-#
-# Copyright (c), 2016-2020, SISSA (International School for Advanced Studies).
-# All rights reserved.
-# This file is distributed under the terms of the MIT License.
-# See the file 'LICENSE' in the root directory of the present
-# distribution, or http://opensource.org/licenses/MIT.
-#
-# @author Davide Brunato <brunato@sissa.it>
-#
-"""
-This module contains XMLSchema classes creator for xmlschema package.
-
-Two schema classes are created at the end of this module, XMLSchema10 for XSD 1.0 and
-XMLSchema11 for XSD 1.1. The latter class parses also XSD 1.0 schemas, as prescribed by
-the standard.
-"""
-import os
-import logging
-import threading
-import warnings
-import re
-import sys
-from copy import copy
-from abc import ABCMeta
-from collections import namedtuple, Counter
-from itertools import chain
-
-from ..exceptions import XMLSchemaTypeError, XMLSchemaKeyError, \
-    XMLSchemaValueError, XMLSchemaNamespaceError
-from ..names import VC_MIN_VERSION, VC_MAX_VERSION, VC_TYPE_AVAILABLE, \
-    VC_TYPE_UNAVAILABLE, VC_FACET_AVAILABLE, VC_FACET_UNAVAILABLE, XSD_NOTATION, \
-    XSD_ATTRIBUTE, XSD_ATTRIBUTE_GROUP, XSD_GROUP, XSD_SIMPLE_TYPE, XSI_TYPE, \
-    XSD_COMPLEX_TYPE, XSD_ELEMENT, XSD_SEQUENCE, XSD_CHOICE, XSD_ALL, XSD_ANY, \
-    XSD_ANY_ATTRIBUTE, XSD_ANY_TYPE, XSD_NAMESPACE, XML_NAMESPACE, XSI_NAMESPACE, \
-    VC_NAMESPACE, SCHEMAS_DIR, LOCATION_HINTS, XSD_ANNOTATION, XSD_INCLUDE, \
-    XSD_IMPORT, XSD_REDEFINE, XSD_OVERRIDE, XSD_DEFAULT_OPEN_CONTENT
-from ..etree import etree_element, ParseError
-from ..helpers import prune_etree, get_namespace
-from ..namespaces import NamespaceResourcesMap, NamespaceView
-from ..resources import is_local_url, is_remote_url, url_path_is_file, \
-    normalize_locations, fetch_resource, normalize_url, XMLResource
-from ..converters import XMLSchemaConverter
-from ..xpath import XMLSchemaProxy, ElementPathMixin
-
-from .exceptions import XMLSchemaParseError, XMLSchemaValidationError, XMLSchemaEncodeError, \
-    XMLSchemaNotBuiltError, XMLSchemaIncludeWarning, XMLSchemaImportWarning
-from .helpers import get_xsd_derivation_attribute
-from .xsdbase import check_validation_mode, XsdValidator, ValidationMixin, XsdComponent
-from .notations import XsdNotation
-from .identities import XsdKey, XsdKeyref, XsdUnique, Xsd11Key, Xsd11Unique, Xsd11Keyref
-from .facets import XSD_10_FACETS, XSD_11_FACETS
-from .simple_types import xsd_simple_type_factory, XsdUnion, XsdAtomicRestriction, \
-    Xsd11AtomicRestriction, Xsd11Union
-from .attributes import XsdAttribute, XsdAttributeGroup, Xsd11Attribute
-from .complex_types import XsdComplexType, Xsd11ComplexType
-from .groups import XsdGroup, Xsd11Group
-from .elements import XsdElement, Xsd11Element
-from .wildcards import XsdAnyElement, XsdAnyAttribute, Xsd11AnyElement, \
-    Xsd11AnyAttribute, XsdDefaultOpenContent
-from .global_maps import XsdGlobals
-
-logger = logging.getLogger('xmlschema')
-logging_formatter = logging.Formatter('%(levelname)s %(message)s')
-logging_handler = logging.StreamHandler(sys.stderr)
-logging_handler.setFormatter(logging_formatter)
-logger.addHandler(logging_handler)
-
-XSD_VERSION_PATTERN = re.compile(r'^\d+\.\d+$')
-DRIVE_PATTERN = re.compile(r'^a-zA-Z:$')
-
-# Elements for building dummy groups
-ATTRIBUTE_GROUP_ELEMENT = etree_element(XSD_ATTRIBUTE_GROUP)
-ANY_ATTRIBUTE_ELEMENT = etree_element(
-    XSD_ANY_ATTRIBUTE, attrib={'namespace': '##any', 'processContents': 'lax'}
-)
-SEQUENCE_ELEMENT = etree_element(XSD_SEQUENCE)
-ANY_ELEMENT = etree_element(
-    XSD_ANY,
-    attrib={
-        'namespace': '##any',
-        'processContents': 'lax',
-        'minOccurs': '0',
-        'maxOccurs': 'unbounded'
-    })
-
-
-class XMLSchemaMeta(ABCMeta):
-
-    def __new__(mcs, name, bases, dict_):
-
-        def get_attribute(attr, *args):
-            for obj in args:
-                if hasattr(obj, attr):
-                    return getattr(obj, attr)
-
-        meta_schema = dict_.get('meta_schema') or get_attribute('meta_schema', *bases)
-        if meta_schema is None:
-            # Defining a subclass without a meta-schema (eg. XMLSchemaBase)
-            return super(XMLSchemaMeta, mcs).__new__(mcs, name, bases, dict_)
-        dict_'meta_schema' = None
-        dict_'lock' = threading.Lock()  # Lock instance for shared meta-schemas
-
-        xsd_version = dict_.get('XSD_VERSION') or get_attribute('XSD_VERSION', *bases)
-        if xsd_version not in ('1.0', '1.1'):
-            raise XMLSchemaValueError("XSD_VERSION must be '1.0' or '1.1'")
-
-        builders = dict_.get('BUILDERS') or get_attribute('BUILDERS', *bases)
-        if isinstance(builders, dict):
-            # noinspection PyArgumentList
-            dict_'BUILDERS' = namedtuple('Builders', builders)(**builders)
-            dict_'BUILDERS_MAP' = {
-                XSD_NOTATION: builders'notation_class',
-                XSD_SIMPLE_TYPE: builders'simple_type_factory',
-                XSD_COMPLEX_TYPE: builders'complex_type_class',
-                XSD_ATTRIBUTE: builders'attribute_class',
-                XSD_ATTRIBUTE_GROUP: builders'attribute_group_class',
-                XSD_GROUP: builders'group_class',
-                XSD_ELEMENT: builders'element_class',
-            }
-        elif builders is None:
-            raise XMLSchemaValueError("validator class doesn't have defined XSD builders")
-        elif get_attribute('BUILDERS_MAP', *bases) is None:
-            raise XMLSchemaValueError("validator class doesn't have a builder map for XSD globals")
-
-        # Build the new meta-schema class
-        meta_schema_class_name = 'Meta' + name
-        meta_schema_class: XMLSchemaBase = super(XMLSchemaMeta, mcs).__new__(
-            mcs, meta_schema_class_name, bases, dict_
-        )
-
-        meta_schema_class.__qualname__ = meta_schema_class_name
-        globals()meta_schema_class_name = meta_schema_class
-
-        # Build the shared meta-schema instance
-        schema_location = meta_schema.url if isinstance(meta_schema, XMLSchemaBase) else meta_schema
-        meta_schema = meta_schema_class.create_meta_schema(schema_location)
-        dict_'meta_schema' = meta_schema
-        dict_.pop('lock')
-
-        return super(XMLSchemaMeta, mcs).__new__(mcs, name, bases, dict_)
-
-
-class XMLSchemaBase(XsdValidator, ValidationMixin, ElementPathMixin, metaclass=XMLSchemaMeta):
-    """
-    Base class for an XML Schema instance.
-
-    :param source: an URI that reference to a resource or a file path or a file-like \
-    object or a string containing the schema or an Element or an ElementTree document.
-    :type source: Element or ElementTree or str or file-like object
-    :param namespace: is an optional argument that contains the URI of the namespace. \
-    When specified it must be equal to the *targetNamespace* declared in the schema.
-    :type namespace: str or None
-    :param validation: the XSD validation mode to use for build the schema, \
-    that can be 'strict' (default), 'lax' or 'skip'.
-    :type validation: str
-    :param global_maps: is an optional argument containing an :class:`XsdGlobals` \
-    instance, a mediator object for sharing declaration data between dependents \
-    schema instances.
-    :type global_maps: XsdGlobals or None
-    :param converter: is an optional argument that can be an :class:`XMLSchemaConverter` \
-    subclass or instance, used for defining the default XML data converter for XML Schema instance.
-    :type converter: XMLSchemaConverter or None
-    :param locations: schema extra location hints, that can include custom resource locations \
-    (eg. local XSD file instead of remote resource) or additional namespaces to import after \
-    processing schema's import statements. Can be a dictionary or a sequence of couples \
-    (namespace URI, resource URL). Extra locations passed using a tuple container are not \
-    normalized.
-    :type locations: dict or list or tuple or None
-    :param base_url: is an optional base URL, used for the normalization of relative paths \
-    when the URL of the schema resource can't be obtained from the source argument.
-    :type base_url: str or None
-    :param allow: defines the security mode for accessing resource locations. Can be \
-    'all', 'remote', 'local' or 'sandbox'. Default is 'all' that means all types of \
-    URLs are allowed. With 'remote' only remote resource URLs are allowed. With 'local' \
-    only file paths and URLs are allowed. With 'sandbox' only file paths and URLs that \
-    are under the directory path identified by source or by the *base_url* argument \
-    are allowed.
-    :type allow: str
-    :param defuse: defines when to defuse XML data using a `SafeXMLParser`. Can be \
-    'always', 'remote' or 'never'. For default defuses only remote XML data.
-    :type defuse: str
-    :param timeout: the timeout in seconds for fetching resources. Default is `300`.
-    :type timeout: int
-    :param build: defines whether build the schema maps. Default is `True`.
-    :type build: bool
-    :param use_meta: if `True` the schema processor uses the validator meta-schema, \
-    otherwise a new meta-schema is added at the end. In the latter case the meta-schema \
-    is rebuilt if any base namespace has been overridden by an import. Ignored if the \
-    argument *global_maps* is provided.
-    :type use_meta: bool
-    :param use_fallback: if `True` the schema processor uses the validator fallback \
-    location hints to load well-known namespaces (eg. xhtml).
-    :type use_fallback: bool
-    :param loglevel: for setting a different logging level for schema initialization \
-    and building. For default is WARNING (30). For INFO level set it with 20, for \
-    DEBUG level with 10. The default loglevel is restored after schema building, \
-    when exiting the initialization method.
-    :type loglevel: int
-
-    :cvar XSD_VERSION: store the XSD version (1.0 or 1.1).
-    :vartype XSD_VERSION: str
-    :cvar BUILDERS: a namedtuple with attributes related to schema components classes. \
-    Used for build local components within parsing methods.
-    :vartype BUILDERS: namedtuple
-    :cvar BUILDERS_MAP: a dictionary that maps from tag to class for XSD global components. \
-    Used for build global components within lookup functions.
-    :vartype BUILDERS_MAP: dict
-    :cvar BASE_SCHEMAS: a dictionary from namespace to schema resource for meta-schema bases.
-    :vartype BASE_SCHEMAS: dict
-    :cvar fallback_locations: fallback schema location hints for other standard namespaces.
-    :vartype fallback_locations: dict
-    :cvar meta_schema: the XSD meta-schema instance.
-    :vartype meta_schema: XMLSchema
-    :cvar attribute_form_default: the schema's *attributeFormDefault* attribute. \
-    Default is 'unqualified'.
-    :vartype attribute_form_default: str
-    :cvar element_form_default: the schema's *elementFormDefault* attribute. \
-    Default is 'unqualified'.
-    :vartype element_form_default: str
-    :cvar block_default: the schema's *blockDefault* attribute. Default is ''.
-    :vartype block_default: str
-    :cvar final_default: the schema's *finalDefault* attribute. Default is ''.
-    :vartype final_default: str
-    :cvar default_attributes: the XSD 1.1 schema's *defaultAttributes* attribute. \
-    Default is ``None``.
-    :vartype default_attributes: XsdAttributeGroup
-    :cvar xpath_tokens: symbol table for schema bound XPath 2.0 parsers. Initially set to \
-    ``None`` it's redefined at instance level with a dictionary at first use of the XPath \
-    selector. The parser symbol table is extended with schema types constructors.
-    :vartype xpath_tokens: dict
-
-    :ivar target_namespace: is the *targetNamespace* of the schema, the namespace to which \
-    belong the declarations/definitions of the schema. If it's empty no namespace is associated \
-    with the schema. In this case the schema declarations can be reused from other namespaces as \
-    *chameleon* definitions.
-    :vartype target_namespace: str
-    :ivar validation: validation mode, can be 'strict', 'lax' or 'skip'.
-    :vartype validation: str
-    :ivar maps: XSD global declarations/definitions maps. This is an instance of \
-    :class:`XsdGlobal`, that store the global_maps argument or a new object when \
-    this argument is not provided.
-    :vartype maps: XsdGlobals
-    :ivar converter: the default converter used for XML data decoding/encoding.
-    :vartype converter: XMLSchemaConverter
-    :ivar locations: schema location hints.
-    :vartype locations: NamespaceResourcesMap
-    :ivar namespaces: a dictionary that maps from the prefixes used by the schema \
-    into namespace URI.
-    :vartype namespaces: dict
-    :ivar imports: a dictionary of namespace imports of the schema, that maps namespace \
-    URI to imported schema object, or `None` in case of unsuccessful import.
-    :vartype imports: dict
-    :ivar includes: a dictionary of included schemas, that maps a schema location to an \
-    included schema. It also comprehend schemas included by "xs:redefine" or \
-    "xs:override" statements.
-    :vartype warnings: dict
-    :ivar warnings: warning messages about failure of import and include elements.
-    :vartype warnings: list
-
-    :ivar notations: `xsd:notation` declarations.
-    :vartype notations: NamespaceView
-    :ivar types: `xsd:simpleType` and `xsd:complexType` global declarations.
-    :vartype types: NamespaceView
-    :ivar attributes: `xsd:attribute` global declarations.
-    :vartype attributes: NamespaceView
-    :ivar attribute_groups: `xsd:attributeGroup` definitions.
-    :vartype attribute_groups: NamespaceView
-    :ivar groups: `xsd:group` global definitions.
-    :vartype groups: NamespaceView
-    :ivar elements: `xsd:element` global declarations.
-    :vartype elements: NamespaceView
-    """
-    XSD_VERSION = None
-    BUILDERS = None
-    BUILDERS_MAP = None
-    BASE_SCHEMAS = None
-    fallback_locations = None
-    meta_schema = None
-    _locations = None
-
-    # Schema defaults
-    target_namespace = ''
-    attribute_form_default = 'unqualified'
-    element_form_default = 'unqualified'
-    block_default = ''
-    final_default = ''
-    redefine = None
-
-    # Additional defaults for XSD 1.1
-    default_attributes = None
-    default_open_content = None
-    override = None
-    xpath_tokens = None
-
-    def __init__(self, source, namespace=None, validation='strict', global_maps=None,
-                 converter=None, locations=None, base_url=None, allow='all', defuse='remote',
-                 timeout=300, build=True, use_meta=True, use_fallback=True, loglevel=None):
-        super(XMLSchemaBase, self).__init__(validation)
-        ElementPathMixin.__init__(self)
-
-        if loglevel is not None:
-            if isinstance(loglevel, str):
-                level = loglevel.strip().upper()
-                if level not in {'DEBUG', 'INFO', 'WARN', 'WARNING', 'ERROR', 'CRITICAL'}:
-                    raise XMLSchemaValueError("{!r} is not a valid loglevel".format(loglevel))
-                loglevel = getattr(logging, level)
-
-            logger.setLevel(loglevel)
-        elif build and global_maps is None:
-            logger.setLevel(logging.WARNING)
-
-        if allow == 'sandbox' and base_url is None and is_local_url(source):
-            # Allow sandbox mode without a base_url using the initial schema URL as base
-            base_url = os.path.dirname(normalize_url(source))
-
-        if isinstance(source, XMLResource):
-            self.source = source
-        else:
-            self.source = XMLResource(source, base_url, allow, defuse, timeout)
-
-        logger.debug("Read schema from %r", self.source.url or self.source.source)
-
-        self.imports = {}
-        self.includes = {}
-        self.warnings = 
-        self._root_elements = None
-        root = self.source.root
-
-        # Get the schema's namespaces, the XML namespace is implicitly declared.
-        self.namespaces = self.source.get_namespaces(namespaces={'xml': XML_NAMESPACE})
-
-        try:
-            self.target_namespace = root.attrib'targetNamespace'.strip()
-        except KeyError:
-            pass
-        else:
-            if self.target_namespace == '':
-                # https://www.w3.org/TR/2004/REC-xmlschema-1-20041028/structures.html#element-schema
-                self.parse_error("the attribute 'targetNamespace' cannot be an empty string", root)
-
-        if namespace is not None and self.target_namespace != namespace:
-            if self.target_namespace:
-                msg = "wrong namespace (%r instead of %r) for XSD resource %s"
-                self.parse_error(msg % (self.target_namespace, namespace, self.url), root)
-
-            # Chameleon schema case: set the target namespace and the default namespace
-            self.target_namespace = namespace
-            if '' not in self.namespaces:
-                self.namespaces'' = namespace
-
-        logger.debug("Schema targetNamespace is %r", self.target_namespace)
-        logger.debug("Declared namespaces: %r", self.namespaces)
-
-        # Parses the schema defaults
-        if 'attributeFormDefault' in root.attrib:
-            self.attribute_form_default = root.attrib'attributeFormDefault'
-
-        if 'elementFormDefault' in root.attrib:
-            self.element_form_default = root.attrib'elementFormDefault'
-
-        if 'blockDefault' in root.attrib:
-            if self.meta_schema is None:
-                pass  # Skip for XSD 1.0 meta-schema that has blockDefault="#all"
-            else:
-                try:
-                    self.block_default = get_xsd_derivation_attribute(
-                        root, 'blockDefault', {'extension', 'restriction', 'substitution'}
-                    )
-                except ValueError as err:
-                    self.parse_error(err, root)
-
-        if 'finalDefault' in root.attrib:
-            try:
-                self.final_default = get_xsd_derivation_attribute(root, 'finalDefault')
-            except ValueError as err:
-                self.parse_error(err, root)
-
-        if converter is None:
-            self.converter = XMLSchemaConverter
-        else:
-            self.converter = self.get_converter(converter)
-
-        if self.meta_schema is None:
-            self.locations = NamespaceResourcesMap()
-
-            # Meta-schema maps creation (MetaXMLSchema10/11 classes)
-            self.maps = global_maps or XsdGlobals(self)
-            for child in self.source.root:
-                if child.tag == XSD_OVERRIDE:
-                    self.include_schema(child.attrib'schemaLocation', self.base_url)
-            return  # Meta-schemas don't need to be checked and don't process imports
-
-        if locations:
-            if isinstance(locations, tuple):
-                self._locations = locations
-            else:
-                self._locations = tuple(normalize_locations(locations, self.base_url))
-
-        self.locations = NamespaceResourcesMap(self.source.get_locations(self._locations))
-        if not use_fallback:
-            self.fallback_locations = {}
-
-        with self.meta_schema.lock:
-            if not self.meta_schema.maps.types:
-                self.meta_schema.maps.build()
-
-        # Create or set the XSD global maps instance
-        if isinstance(global_maps, XsdGlobals):
-            self.maps = global_maps
-        elif global_maps is not None:
-            raise XMLSchemaTypeError("'global_maps' argument must be an %r instance" % XsdGlobals)
-        elif use_meta and self.target_namespace not in self.meta_schema.maps.namespaces:
-            self.maps = self.meta_schema.maps.copy(self, validation)
-        else:
-            self.maps = XsdGlobals(self, validation)
-
-        if any(ns == VC_NAMESPACE for ns in self.namespaces.values()):
-            # For XSD 1.1+ apply versioning filter to schema tree. See the paragraph
-            # 4.2.2 of XSD 1.1 (Part 1: Structures) definition for details.
-            # Ref: https://www.w3.org/TR/xmlschema11-1/#cip
-            if prune_etree(root, selector=lambda x: not self.version_check(x)):
-                for k in list(root.attrib):
-                    if k not in {'targetNamespace', VC_MIN_VERSION, VC_MAX_VERSION}:
-                        del root.attribk
-
-        # Validate the schema document (transforming validation errors to parse errors)
-        if validation != 'skip':
-            for e in self.meta_schema.iter_errors(root, namespaces=self.namespaces):
-                self.parse_error(e.reason, elem=e.elem)
-
-        self._parse_inclusions()
-        self._parse_imports()
-
-        # Imports by argument (usually from xsi:schemaLocation attribute).
-        for ns in self.locations:
-            if ns not in self.maps.namespaces:
-                self._import_namespace(ns, self.locationsns)
-
-        if '' not in self.namespaces:
-            self.namespaces'' = ''  # For default local names are mapped to no namespace
-
-        # XSD 1.1 default declarations (defaultAttributes, defaultOpenContent,
-        # xpathDefaultNamespace)
-        if self.XSD_VERSION > '1.0':
-            self.xpath_default_namespace = self._parse_xpath_default_namespace(root)
-            if 'defaultAttributes' in root.attrib:
-                try:
-                    self.default_attributes = self.resolve_qname(root.attrib'defaultAttributes')
-                except (ValueError, KeyError, RuntimeError) as err:
-                    self.parse_error(err, root)
-
-            for child in root:
-                if child.tag == XSD_DEFAULT_OPEN_CONTENT:
-                    self.default_open_content = XsdDefaultOpenContent(child, self)
-                    break
-
-        try:
-            if build:
-                self.maps.build()
-        finally:
-            if loglevel is not None:
-                logger.setLevel(logging.WARNING)  # Restore default logging
-
-    @property
-    def name(self):
-        return os.path.basename(self.url) if self.url else None
-
-    def __repr__(self):
-        if self.url:
-            return '%s(name=%r, namespace=%r)' % (
-                self.__class__.__name__, self.name, self.target_namespace
-            )
-        return '%s(namespace=%r)' % (self.__class__.__name__, self.target_namespace)
-
-    def __setattr__(self, name, value):
-        if name == 'maps':
-            if self.meta_schema is None and hasattr(self, 'maps'):
-                msg = "cannot change the global maps instance of a meta-schema"
-                raise XMLSchemaValueError(msg)
-
-            super(XMLSchemaBase, self).__setattr__(name, value)
-            self.notations = NamespaceView(value.notations, self.target_namespace)
-            self.types = NamespaceView(value.types, self.target_namespace)
-            self.attributes = NamespaceView(value.attributes, self.target_namespace)
-            self.attribute_groups = NamespaceView(value.attribute_groups, self.target_namespace)
-            self.groups = NamespaceView(value.groups, self.target_namespace)
-            self.elements = NamespaceView(value.elements, self.target_namespace)
-            self.substitution_groups = NamespaceView(value.substitution_groups,
-                                                     self.target_namespace)
-            self.identities = NamespaceView(value.identities, self.target_namespace)
-            self._global_views = (self.notations, self.types, self.attributes,
-                                  self.attribute_groups, self.groups, self.elements)
-            value.register(self)
-        else:
-            if name == 'validation':
-                check_validation_mode(value)
-            super(XMLSchemaBase, self).__setattr__(name, value)
-
-    def __iter__(self):
-        yield from sorted(self.elements.values(), key=lambda x: x.name)
-
-    def __reversed__(self):
-        yield from sorted(self.elements.values(), key=lambda x: x.name, reverse=True)
-
-    def __len__(self):
-        return len(self.elements)
-
-    @property
-    def xpath_proxy(self):
-        return XMLSchemaProxy(self)
-
-    @property
-    def xsd_version(self):
-        """Compatibility property that returns the class attribute XSD_VERSION."""
-        return self.XSD_VERSION
-
-    # XML resource attributes access
-    @property
-    def root(self):
-        """Root element of the schema."""
-        return self.source.root
-
-    def get_text(self):
-        """Returns the source text of the XSD schema."""
-        return self.source.get_text()
-
-    @property
-    def url(self):
-        """Schema resource URL, is `None` if the schema is built from a string."""
-        return self.source.url
-
-    @property
-    def base_url(self):
-        """The base URL of the source of the schema."""
-        return self.source.base_url
-
-    @property
-    def allow(self):
-        """Defines the resource access security mode, can be 'all', 'local' or 'sandbox'."""
-        return self.source.allow
-
-    @property
-    def defuse(self):
-        """Defines when to defuse XML data, can be 'always', 'remote' or 'never'."""
-        return self.source.defuse
-
-    @property
-    def timeout(self):
-        """Timeout in seconds for fetching resources."""
-        return self.source.timeout
-
-    @property
-    def use_meta(self):
-        """Returns `True` if the class meta-schema is used."""
-        return self.meta_schema is self.__class__.meta_schema
-
-    # Schema root attributes
-    @property
-    def tag(self):
-        """Schema root tag. For compatibility with the ElementTree API."""
-        return self.root.tag
-
-    @property
-    def id(self):
-        """The schema's *id* attribute, defaults to ``None``."""
-        return self.root.get('id')
-
-    @property
-    def version(self):
-        """The schema's *version* attribute, defaults to ``None``."""
-        return self.root.get('version')
-
-    @property
-    def schema_location(self):
-        """
-        A list of location hints extracted from the *xsi:schemaLocation* attribute of the schema.
-        """
-        return (k, v) for k, v in self.source.iter_location_hints() if k
-
-    @property
-    def no_namespace_schema_location(self):
-        """
-        A location hint extracted from the *xsi:noNamespaceSchemaLocation* attribute of the schema.
-        """
-        for k, v in self.source.iter_location_hints():
-            if not k:
-                return v
-
-    @property
-    def default_namespace(self):
-        """The namespace associated to the empty prefix ''."""
-        return self.namespaces.get('')
-
-    @property
-    def target_prefix(self):
-        """The prefix associated to the *targetNamespace*."""
-        for prefix, namespace in self.namespaces.items():
-            if namespace == self.target_namespace:
-                return prefix
-        return ''
-
-    @classmethod
-    def builtin_types(cls):
-        """Returns the XSD built-in types of the meta-schema."""
-        try:
-            builtin_types = cls.meta_schema.maps.namespacesXSD_NAMESPACE0.types
-        except KeyError:
-            raise XMLSchemaNotBuiltError(cls.meta_schema, "missing XSD namespace in meta-schema")
-        except AttributeError:
-            raise XMLSchemaNotBuiltError(cls.meta_schema, "meta-schema unavailable for %r" % cls)
-        else:
-            if not builtin_types:
-                cls.meta_schema.build()
-            return builtin_types
-
-    @property
-    def root_elements(self):
-        """
-        The list of global elements that are not used by reference in any model of the schema.
-        This is implemented as lazy property because it's computationally expensive to build
-        when the schema model is complex.
-        """
-        if not self.elements:
-            return 
-        elif len(self.elements) == 1:
-            return list(self.elements.values())
-        elif self._root_elements is None:
-            names = set(e.name for e in self.elements.values())
-            for xsd_element in self.elements.values():
-                for e in xsd_element.iter():
-                    if e is xsd_element or isinstance(e, XsdAnyElement):
-                        continue
-                    elif e.ref or e.parent is None:
-                        if e.name in names:
-                            names.discard(e.name)
-                            if not names:
-                                break
-            self._root_elements = list(names)
-
-        return e for e in self.elements.values() if e.name in self._root_elements
-
-    @property
-    def simple_types(self):
-        """Returns a list containing the global simple types."""
-        return x for x in self.types.values() if x.is_simple()
-
-    @property
-    def complex_types(self):
-        """Returns a list containing the global complex types."""
-        return x for x in self.types.values() if x.is_complex()
-
-    @classmethod
-    def create_meta_schema(cls, source=None, base_schemas=None, global_maps=None):
-        """
-        Creates a new meta-schema instance.
-
-        :param source: an optional argument referencing to or containing the XSD meta-schema \
-        resource. Required if the schema class doesn't already have a meta-schema.
-        :param base_schemas: an optional dictionary that contains namespace URIs and \
-        schema locations. If provided it's used as substitute for class 's BASE_SCHEMAS. \
-        Also a sequence of (namespace, location) items can be provided if there are more \
-        schema documents for one or more namespaces.
-        :param global_maps: is an optional argument containing an :class:`XsdGlobals` \
-        instance for the new meta schema. If not provided a new map is created.
-        """
-        if source is None:
-            try:
-                source = cls.meta_schema.url
-            except AttributeError:
-                raise XMLSchemaValueError("The argument 'source' is required when "
-                                          "the class doesn't already have a meta-schema")
-
-        if base_schemas is None:
-            base_schemas = cls.BASE_SCHEMAS.items()
-        elif isinstance(base_schemas, dict):
-            base_schemas = base_schemas.items()
-        else:
-            try:
-                base_schemas = (n, l) for n, l in base_schemas
-            except ValueError:
-                raise ValueError(
-                    "The argument 'base_schemas' is not a dictionary nor a sequence of items"
-                )
-
-        meta_schema_class = cls if cls.meta_schema is None else cls.meta_schema.__class__
-        meta_schema = meta_schema_class(source, XSD_NAMESPACE, global_maps=global_maps,
-                                        defuse='never', build=False)
-        for ns, location in base_schemas:
-            if ns == XSD_NAMESPACE:
-                meta_schema.include_schema(location=location)
-            else:
-                meta_schema.import_schema(namespace=ns, location=location)
-        return meta_schema
-
-    def create_any_content_group(self, parent, any_element=None):
-        """
-        Creates a model group related to schema instance that accepts any content.
-
-        :param parent: the parent component to set for the any content group.
-        :param any_element: an optional any element to use for the content group. \
-        When provided it's copied, linked to the group and the minOccurs/maxOccurs \
-        are set to 0 and 'unbounded'.
-        """
-        group = self.BUILDERS.group_class(SEQUENCE_ELEMENT, self, parent)
-
-        if any_element is not None:
-            any_element = any_element.copy()
-            any_element.min_occurs = 0
-            any_element.max_occurs = None
-            any_element.parent = group
-            group.append(any_element)
-        else:
-            group.append(self.BUILDERS.any_element_class(ANY_ELEMENT, self, group))
-
-        return group
-
-    def create_empty_content_group(self, parent, model='sequence', **attrib):
-        if model == 'sequence':
-            group_elem = etree_element(XSD_SEQUENCE, **attrib)
-        elif model == 'choice':
-            group_elem = etree_element(XSD_CHOICE, **attrib)
-        elif model == 'all':
-            group_elem = etree_element(XSD_ALL, **attrib)
-        else:
-            raise XMLSchemaValueError("'model' argument must be (sequence | choice | all)")
-
-        group_elem.text = '\n    '
-        return self.BUILDERS.group_class(group_elem, self, parent)
-
-    def create_any_attribute_group(self, parent):
-        """
-        Creates an attribute group related to schema instance that accepts any attribute.
-
-        :param parent: the parent component to set for the any attribute group.
-        """
-        attribute_group = self.BUILDERS.attribute_group_class(
-            ATTRIBUTE_GROUP_ELEMENT, self, parent
-        )
-        attribute_groupNone = self.BUILDERS.any_attribute_class(
-            ANY_ATTRIBUTE_ELEMENT, self, attribute_group
-        )
-        return attribute_group
-
-    def create_empty_attribute_group(self, parent):
-        """
-        Creates an empty attribute group related to schema instance.
-
-        :param parent: the parent component to set for the any attribute group.
-        """
-        return self.BUILDERS.attribute_group_class(ATTRIBUTE_GROUP_ELEMENT, self, parent)
-
-    def create_any_type(self):
-        """
-        Creates an xs:anyType equivalent type related with the wildcards
-        connected to global maps of the schema instance in order to do a
-        correct namespace lookup during wildcards validation.
-        """
-        schema = self.meta_schema or self
-        any_type = self.BUILDERS.complex_type_class(
-            elem=etree_element(XSD_COMPLEX_TYPE, name=XSD_ANY_TYPE),
-            schema=schema, parent=None, mixed=True, block='', final=''
-        )
-        any_type.content.append(self.BUILDERS.any_element_class(
-            ANY_ELEMENT, schema, any_type.content
-        ))
-        any_type.attributesNone = self.BUILDERS.any_attribute_class(
-            ANY_ATTRIBUTE_ELEMENT, schema, any_type.attributes
-        )
-        any_type.maps = any_type.content.maps = any_type.content0.maps = \
-            any_type.attributesNone.maps = self.maps
-        return any_type
-
-    def create_element(self, name, parent=None, text=None, **attrib):
-        """
-        Creates an xs:element instance related to schema component.
-        Used as dummy element for validation/decoding/encoding
-        operations of wildcards and complex types.
-        """
-        elem = etree_element(XSD_ELEMENT, name=name, **attrib)
-        if text is not None:
-            elem.text = text
-        return self.BUILDERS.element_class(elem=elem, schema=self, parent=parent)
-
-    def copy(self):
-        """
-        Makes a copy of the schema instance. The new instance has independent maps
-        of shared XSD components.
-        """
-        schema = object.__new__(self.__class__)
-        schema.__dict__.update(self.__dict__)
-        schema.source = copy(self.source)
-        schema.errors = self.errors:
-        schema.warnings = self.warnings:
-        schema.namespaces = self.namespaces.copy()
-        schema.locations = NamespaceResourcesMap(self.locations)
-        schema.imports = dict(self.imports)
-        schema.includes = dict(self.includes)
-        schema.maps = self.maps.copy(validator=schema)
-        return schema
-
-    __copy__ = copy
-
-    @classmethod
-    def check_schema(cls, schema, namespaces=None):
-        """
-        Validates the given schema against the XSD meta-schema (:attr:`meta_schema`).
-
-        :param schema: the schema instance that has to be validated.
-        :param namespaces: is an optional mapping from namespace prefix to URI.
-
-        :raises: :exc:`XMLSchemaValidationError` if the schema is invalid.
-        """
-        if not cls.meta_schema.maps.types:
-            cls.meta_schema.maps.build()
-
-        for error in cls.meta_schema.iter_errors(schema, namespaces=namespaces):
-            raise error
-
-    def check_validator(self, validation='strict'):
-        """Checks the status of a schema validator against a validation mode."""
-        check_validation_mode(validation)
-
-        if self.built:
-            pass
-        elif self.meta_schema is None:
-            self.build()  # Meta-schema lazy build
-        elif validation == 'skip' and self.validation == 'skip' and \
-                any(comp.validation_attempted == 'partial' for comp in self.iter_globals()):
-            pass
-        else:
-            raise XMLSchemaNotBuiltError(self, "schema %r is not built" % self)
-
-    def build(self):
-        """Builds the schema's XSD global maps."""
-        self.maps.build()
-
-    def clear(self):
-        """Clears the schema's XSD global maps."""
-        self.maps.clear()
-
-    @property
-    def built(self):
-        if any(not isinstance(g, XsdComponent) or not g.built for g in self.iter_globals()):
-            return False
-        for _ in self.iter_globals():
-            return True
-        if self.meta_schema is None:
-            return False
-
-        # No XSD globals: check with a lookup of schema child elements.
-        prefix = '{%s}' % self.target_namespace if self.target_namespace else ''
-        for child in self.source.root:
-            if child.tag in {XSD_REDEFINE, XSD_OVERRIDE}:
-                for e in filter(lambda x: x.tag in self.BUILDERS_MAP, child):
-                    name = e.get('name')
-                    if name is not None:
-                        try:
-                            if not self.maps.lookup(e.tag, prefix + name if prefix else name).built:
-                                return False
-                        except KeyError:
-                            return False
-            elif child.tag in self.BUILDERS_MAP:
-                name = child.get('name')
-                if name is not None:
-                    try:
-                        if not self.maps.lookup(child.tag, prefix + name if prefix else name).built:
-                            return False
-                    except KeyError:
-                        return False
-        return True
-
-    @property
-    def validation_attempted(self):
-        if self.built:
-            return 'full'
-        elif any(comp.validation_attempted == 'partial' for comp in self.iter_globals()):
-            return 'partial'
-        else:
-            return 'none'
-
-    def iter_globals(self, schema=None):
-        """
-        Creates an iterator for XSD global definitions/declarations related to schema namespace.
-
-        :param schema: Optional argument for filtering only globals related to a schema instance.
-        """
-        if schema is None:
-            for global_map in self._global_views:
-                yield from global_map.values()
-        else:
-            for global_map in self._global_views:
-                for obj in global_map.values():
-                    if isinstance(obj, tuple):
-                        if obj1 == schema:
-                            yield obj
-                    elif obj.schema == schema:
-                        yield obj
-
-    def iter_components(self, xsd_classes=None):
-        """
-        Iterates yielding the schema and its components. For default
-        includes all the relevant components of the schema, excluding
-        only facets and empty attribute groups. The first returned
-        component is the schema itself.
-
-        :param xsd_classes: provide a class or a tuple of classes to \
-        restrict the range of component types yielded.
-        """
-        if xsd_classes is None or isinstance(self, xsd_classes):
-            yield self
-        for xsd_global in self.iter_globals(self):
-            yield from xsd_global.iter_components(xsd_classes)
-
-    def get_schema(self, namespace):
-        """
-        Returns the first schema loaded for a namespace. Raises a
-        `KeyError` if the requested namespace is not loaded.
-        """
-        try:
-            return self.maps.namespacesnamespace0
-        except KeyError:
-            if not namespace:
-                return self
-            raise XMLSchemaKeyError('the namespace {!r} is not loaded'.format(namespace)) from None
-
-    def get_converter(self, converter=None, **kwargs):
-        """
-        Returns a new converter instance.
-
-        :param converter: can be a converter class or instance. If it's an instance \
-        the new instance is copied from it and configured with the provided arguments.
-        :param kwargs: optional arguments for initialize the converter instance.
-        :return: a converter instance.
-        """
-        if converter is None:
-            converter = self.converter
-
-        if isinstance(converter, XMLSchemaConverter):
-            return converter.copy(**kwargs)
-        elif isinstance(converter, type) and issubclass(converter, XMLSchemaConverter):
-            return converter(**kwargs)
-        else:
-            msg = "'converter' argument must be a %r subclass or instance: %r"
-            raise XMLSchemaTypeError(msg % (XMLSchemaConverter, converter))
-
-    def get_locations(self, namespace):
-        """
-        Get a list of location hints for a namespace.
-        """
-        try:
-            return list(self.locationsnamespace)
-        except KeyError:
-            return 
-
-    def get_element(self, tag, path=None, namespaces=None):
-        if not path:
-            return self.find(tag)
-        elif path-1 == '*':
-            xsd_element = self.find(path:-1 + tag, namespaces)
-            return self.maps.elements.get(tag) if xsd_element is None else xsd_element
-        else:
-            return self.find(path, namespaces)
-
-    def create_bindings(self, *bases, **attrs):
-        """
-        Creates data object bindings for XSD elements of the schema.
-
-        :param bases: base classes to use for creating the binding classes.
-        :param attrs: attribute and method definitions for the binding classes body.
-        """
-        for xsd_element in self.iter_components(xsd_classes=XsdElement):
-            xsd_element.get_binding(*bases, replace_existing=True, **attrs)
-
-    def _parse_inclusions(self):
-        """Processes schema document inclusions and redefinitions."""
-        for child in self.source.root:
-            if child.tag == XSD_INCLUDE:
-                try:
-                    location = child.attrib'schemaLocation'.strip()
-                    logger.info("Include schema from %r", location)
-                    self.include_schema(location, self.base_url)
-                except KeyError:
-                    # Attribute missing error already found by validation against meta-schema
-                    pass
-                except (OSError, IOError) as err:
-                    # It is not an error if the location fail to resolve:
-                    #   https://www.w3.org/TR/2012/REC-xmlschema11-1-20120405/#compound-schema
-                    #   https://www.w3.org/TR/2012/REC-xmlschema11-1-20120405/#src-include
-                    self.warnings.append("Include schema failed: %s." % str(err))
-                    warnings.warn(self.warnings-1, XMLSchemaIncludeWarning, stacklevel=3)
-                except (XMLSchemaParseError, XMLSchemaTypeError, ParseError) as err:
-                    msg = 'cannot include schema %r: %s' % (child.attrib'schemaLocation', err)
-                    if isinstance(err, (XMLSchemaParseError, ParseError)):
-                        self.parse_error(msg)
-                    elif self.validation == 'strict':
-                        raise type(err)(msg)
-                    else:
-                        self.errors.append(type(err)(msg))
-
-            elif child.tag == XSD_REDEFINE:
-                try:
-                    location = child.attrib'schemaLocation'.strip()
-                    logger.info("Redefine schema %r", location)
-                    schema = self.include_schema(location, self.base_url)
-                except KeyError:
-                    # Attribute missing error already found by validation against meta-schema
-                    pass
-                except (OSError, IOError) as err:
-                    # If the redefine doesn't contain components (annotation excluded)
-                    # the statement is equivalent to an include, so no error is generated.
-                    # Otherwise fails.
-                    self.warnings.append("Redefine schema failed: %s." % str(err))
-                    warnings.warn(self.warnings-1, XMLSchemaIncludeWarning, stacklevel=3)
-                    if any(e.tag != XSD_ANNOTATION and not callable(e.tag) for e in child):
-                        self.parse_error(err, child)
-                except (XMLSchemaParseError, XMLSchemaTypeError, ParseError) as err:
-                    msg = 'cannot redefine schema %r: %s' % (child.attrib'schemaLocation', err)
-                    if isinstance(err, (XMLSchemaParseError, ParseError)):
-                        self.parse_error(msg, child)
-                    elif self.validation == 'strict':
-                        raise type(err)(msg)
-                    else:
-                        self.errors.append(type(err)(msg))
-                else:
-                    schema.redefine = self
-
-    def include_schema(self, location, base_url=None):
-        """
-        Includes a schema for the same namespace, from a specific URL.
-
-        :param location: is the URL of the schema.
-        :param base_url: is an optional base URL for fetching the schema resource.
-        :return: the included :class:`XMLSchema` instance.
-        """
-        schema_url = fetch_resource(location, base_url)
-        for schema in self.maps.namespacesself.target_namespace:
-            if schema_url == schema.url:
-                logger.info("Resource %r is already loaded", location)
-                break
-        else:
-            schema = type(self)(
-                source=schema_url,
-                namespace=self.target_namespace,
-                validation=self.validation,
-                global_maps=self.maps,
-                converter=self.converter,
-                locations=self._locations,
-                base_url=self.base_url,
-                allow=self.allow,
-                defuse=self.defuse,
-                timeout=self.timeout,
-                build=False,
-            )
-
-        if schema is self:
-            return self
-        elif location not in self.includes:
-            self.includeslocation = schema
-        elif self.includeslocation is not schema:
-            self.includesschema_url = schema
-        return schema
-
-    def _parse_imports(self):
-        """
-        Parse namespace import elements. Imports are done on namespace basis, not on
-        single resource. A warning is generated for a failure of a namespace import.
-        """
-        namespace_imports = NamespaceResourcesMap(map(
-            lambda x: (x.get('namespace'), x.get('schemaLocation')),
-            filter(lambda x: x.tag == XSD_IMPORT, self.source.root)
-        ))
-
-        for namespace, locations in namespace_imports.items():
-
-            # Checks the namespace against the targetNamespace of the schema
-            if namespace is None:
-                namespace = ''
-                if namespace == self.target_namespace:
-                    self.parse_error("if the 'namespace' attribute is not present on "
-                                     "the import statement then the importing schema "
-                                     "must have a 'targetNamespace'")
-                    continue
-            elif namespace == self.target_namespace:
-                self.parse_error("the attribute 'namespace' must be different from "
-                                 "schema's 'targetNamespace'")
-                continue
-
-            # Skip import of already imported namespaces
-            if self.imports.get(namespace) is not None:
-                continue
-            elif namespace in self.maps.namespaces:
-                self.importsnamespace = self.maps.namespacesnamespace0
-                continue
-
-            locations = url for url in locations if url
-            if not namespace:
-                pass
-            elif not locations:
-                locations = self.get_locations(namespace)
-            elif all(is_remote_url(url) for url in locations):
-                # If all import schema locations are remote URLs and there are local hints
-                # that match a local file path, try the local hints before schema locations.
-                # This is not the standard processing for XSD imports, but resolve the problem
-                # of local processing of schemas tested to work from a http server, providing
-                # explicit local hints.
-                local_hints = url for url in self.get_locations(namespace)
-                               if url and url_path_is_file(url)
-                if local_hints:
-                    locations = local_hints + locations
-
-            if namespace in self.fallback_locations:
-                locations.append(self.fallback_locationsnamespace)
-
-            self._import_namespace(namespace, locations)
-
-    def _import_namespace(self, namespace, locations):
-        import_error = None
-        for url in locations:
-            try:
-                logger.debug("Import namespace %r from %r", namespace, url)
-                self.import_schema(namespace, url, self.base_url)
-            except (OSError, IOError) as err:
-                # It's not an error if the location access fails (ref. section 4.2.6.2):
-                #   https://www.w3.org/TR/2012/REC-xmlschema11-1-20120405/#composition-schemaImport
-                logger.debug('%s', err)
-                if import_error is None:
-                    import_error = err
-            except (XMLSchemaParseError, XMLSchemaTypeError, ParseError) as err:
-                if namespace:
-                    msg = "cannot import namespace %r: %s." % (namespace, err)
-                else:
-                    msg = "cannot import chameleon schema: %s." % err
-                if isinstance(err, (XMLSchemaParseError, ParseError)):
-                    self.parse_error(msg)
-                elif self.validation == 'strict':
-                    raise type(err)(msg)
-                else:
-                    self.errors.append(type(err)(msg))
-            except XMLSchemaValueError as err:
-                self.parse_error(err)
-            else:
-                logger.info("Namespace %r imported from %r", namespace, url)
-                break
-        else:
-            if import_error is not None:
-                msg = "Import of namespace {!r} from {!r} failed: {}."
-                self.warnings.append(msg.format(namespace, locations, str(import_error)))
-                warnings.warn(self.warnings-1, XMLSchemaImportWarning, stacklevel=4)
-            self.importsnamespace = None
-
-    def import_schema(self, namespace, location, base_url=None, force=False, build=False):
-        """
-        Imports a schema for an external namespace, from a specific URL.
-
-        :param namespace: is the URI of the external namespace.
-        :param location: is the URL of the schema.
-        :param base_url: is an optional base URL for fetching the schema resource.
-        :param force: if set to `True` imports the schema also if the namespace is already imported.
-        :param build: defines when to build the imported schema, the default is to not build.
-        :return: the imported :class:`XMLSchema` instance.
-        """
-        if location == self.url:
-            return self
-
-        if not force:
-            if self.imports.get(namespace) is not None:
-                return self.importsnamespace
-            elif namespace in self.maps.namespaces:
-                self.importsnamespace = self.maps.namespacesnamespace0
-                return self.importsnamespace
-
-        schema_url = fetch_resource(location, base_url)
-        if self.imports.get(namespace) is not None and self.importsnamespace.url == schema_url:
-            return self.importsnamespace
-        elif namespace in self.maps.namespaces:
-            for schema in self.maps.namespacesnamespace:
-                if schema_url == schema.url:
-                    self.importsnamespace = schema
-                    return schema
-
-        schema = type(self)(
-            source=schema_url,
-            validation=self.validation,
-            global_maps=self.maps,
-            converter=self.converter,
-            locations=self._locations,
-            base_url=self.base_url,
-            allow=self.allow,
-            defuse=self.defuse,
-            timeout=self.timeout,
-            build=build,
-        )
-        if schema.target_namespace != namespace:
-            raise XMLSchemaValueError(
-                'imported schema %r has an unmatched namespace %r' % (location, namespace)
-            )
-        self.importsnamespace = schema
-        return schema
-
-    def export(self, target, only_relative=True):
-        """
-        Exports a schema instance. The schema instance is exported to a
-        directory with also the hierarchy of imported/included schemas.
-
-        :param target: a path to a local empty directory.
-        :param only_relative: for default only loaded schemas referred by a relative \
-        location are saved. If `False` is provided all the loaded schemas are saved.
-        """
-        import pathlib
-        from urllib.parse import urlsplit
-
-        target_path = pathlib.Path(target)
-        if target_path.is_dir():
-            if list(target_path.iterdir()):
-                raise XMLSchemaValueError("target directory {!r} is not empty".format(target))
-        elif target_path.exists():
-            msg = "target {} is not a directory"
-            raise XMLSchemaValueError(msg.format(target_path.parent))
-        elif not target_path.parent.exists():
-            msg = "target parent directory {} does not exist"
-            raise XMLSchemaValueError(msg.format(target_path.parent))
-        elif not target_path.parent.is_dir():
-            msg = "target parent {} is not a directory"
-            raise XMLSchemaValueError(msg.format(target_path.parent))
-
-        url = self.url or 'schema.xsd'
-        basename = pathlib.Path(urlsplit(url).path).name
-        exported_schemas = {self: target_path.joinpath(basename), self.get_text()}
-
-        while True:
-            current_length = len(exported_schemas)
-            for schema in list(exported_schemas):
-                for location, ref_schema in \
-                        chain(schema.includes.items(), schema.imports.items()):
-
-                    if ref_schema in exported_schemas:
-                        continue
-
-                    schema_path = exported_schemasschema0.parent
-
-                    if is_remote_url(location):
-                        if only_relative:
-                            continue
-                        url_parts = urlsplit(location)
-                        netloc, path = url_parts.netloc, url_parts.path
-                        path = pathlib.Path().joinpath(netloc).joinpath(path.lstrip('/'))
-                    else:
-                        path = pathlib.Path(location)
-                        if path.is_absolute():
-                            if only_relative:
-                                continue
-                        elif not str(path).startswith('..'):
-                            path = schema_path.joinpath(path)
-                            exported_schemasref_schema = path, ref_schema.get_text()
-                            continue
-
-                    if DRIVE_PATTERN.match(path.parts0):
-                        path = pathlib.Path().joinpath(path.parts1:)
-
-                    for strip_path in ('/', '\\', '..'):
-                        while True:
-                            try:
-                                path = path.relative_to(strip_path)
-                            except ValueError:
-                                break
-
-                    path = target_path.joinpath(path)
-                    repl = 'schemaLocation="{}"'.format(path.as_posix())
-                    text = exported_schemasschema1
-                    pattern = r'\bschemaLocation\s*=\s*\'\".*%s.*\'"' % re.escape(location)
-                    exported_schemasschema1 = re.sub(pattern, repl, text)
-                    exported_schemasref_schema = path, ref_schema.get_text()
-
-            if current_length == len(exported_schemas):
-                break
-
-        for schema, (path, text) in exported_schemas.items():
-            if not path.parent.exists():
-                path.parent.mkdir(parents=True)
-
-            with path.open(mode='w') as fp:
-                fp.write(text)
-
-    def version_check(self, elem):
-        """
-        Checks if the element is compatible with the version of the validator and XSD
-        types/facets availability. Invalid vc attributes are not detected in XSD 1.0.
-
-        :param elem: an Element of the schema.
-        :return: `True` if the schema element is compatible with the validator, \
-        `False` otherwise.
-        """
-        if VC_MIN_VERSION in elem.attrib:
-            vc_min_version = elem.attribVC_MIN_VERSION
-            if not XSD_VERSION_PATTERN.match(vc_min_version):
-                if self.XSD_VERSION > '1.0':
-                    self.parse_error("invalid attribute vc:minVersion value", elem)
-            elif vc_min_version > self.XSD_VERSION:
-                return False
-
-        if VC_MAX_VERSION in elem.attrib:
-            vc_max_version = elem.attribVC_MAX_VERSION
-            if not XSD_VERSION_PATTERN.match(vc_max_version):
-                if self.XSD_VERSION > '1.0':
-                    self.parse_error("invalid attribute vc:maxVersion value", elem)
-            elif vc_max_version <= self.XSD_VERSION:
-                return False
-
-        if VC_TYPE_AVAILABLE in elem.attrib:
-            for qname in elem.attribVC_TYPE_AVAILABLE.split():
-                try:
-                    if self.resolve_qname(qname) not in self.maps.types:
-                        return False
-                except XMLSchemaNamespaceError:
-                    return False
-                except (KeyError, ValueError) as err:
-                    self.parse_error(str(err), elem)
-
-        if VC_TYPE_UNAVAILABLE in elem.attrib:
-            for qname in elem.attribVC_TYPE_UNAVAILABLE.split():
-                try:
-                    if self.resolve_qname(qname) not in self.maps.types:
-                        break
-                except XMLSchemaNamespaceError:
-                    break
-                except (KeyError, ValueError) as err:
-                    self.parse_error(err, elem)
-            else:
-                return False
-
-        if VC_FACET_AVAILABLE in elem.attrib:
-            for qname in elem.attribVC_FACET_AVAILABLE.split():
-                try:
-                    facet_name = self.resolve_qname(qname)
-                except XMLSchemaNamespaceError:
-                    pass
-                except (KeyError, ValueError) as err:
-                    self.parse_error(str(err), elem)
-                else:
-                    if self.XSD_VERSION == '1.0':
-                        if facet_name not in XSD_10_FACETS:
-                            return False
-                    elif facet_name not in XSD_11_FACETS:
-                        return False
-
-        if VC_FACET_UNAVAILABLE in elem.attrib:
-            for qname in elem.attribVC_FACET_UNAVAILABLE.split():
-                try:
-                    facet_name = self.resolve_qname(qname)
-                except XMLSchemaNamespaceError:
-                    break
-                except (KeyError, ValueError) as err:
-                    self.parse_error(err, elem)
-                else:
-                    if self.XSD_VERSION == '1.0':
-                        if facet_name not in XSD_10_FACETS:
-                            break
-                    elif facet_name not in XSD_11_FACETS:
-                        break
-            else:
-                return False
-
-        return True
-
-    def resolve_qname(self, qname, namespace_imported=True):
-        """
-        QName resolution for a schema instance.
-
-        :param qname: a string in xs:QName format.
-        :param namespace_imported: if this argument is `True` raises an \
-        `XMLSchemaNamespaceError` if the namespace of the QName is not the \
-        *targetNamespace* and the namespace is not imported by the schema.
-        :returns: an expanded QName in the format "{*namespace-URI*}*local-name*".
-        :raises: `XMLSchemaValueError` for an invalid xs:QName is found, \
-        `XMLSchemaKeyError` if the namespace prefix is not declared in the \
-        schema instance.
-        """
-        qname = qname.strip()
-        if not qname or ' ' in qname or '\t' in qname or '\n' in qname:
-            raise XMLSchemaValueError("{!r} is not a valid value for xs:QName".format(qname))
-
-        if qname0 == '{':
-            try:
-                namespace, local_name = qname1:.split('}')
-            except ValueError:
-                raise XMLSchemaValueError("{!r} is not a valid value for xs:QName".format(qname))
-        elif ':' in qname:
-            try:
-                prefix, local_name = qname.split(':')
-            except ValueError:
-                raise XMLSchemaValueError("{!r} is not a valid value for xs:QName".format(qname))
-            else:
-                try:
-                    namespace = self.namespacesprefix
-                except KeyError:
-                    raise XMLSchemaKeyError("prefix %r not found in namespace map" % prefix)
-        else:
-            namespace, local_name = self.namespaces.get('', ''), qname
-
-        if not namespace:
-            if namespace_imported and self.target_namespace and '' not in self.imports:
-                raise XMLSchemaNamespaceError(
-                    "the QName {!r} is mapped to no namespace, but this requires "
-                    "that there is an xs:import statement in the schema without "
-                    "the 'namespace' attribute.".format(qname)
-                )
-            return local_name
-        elif namespace_imported and self.meta_schema is not None and \
-                namespace != self.target_namespace and \
-                namespace not in {XSD_NAMESPACE, XSI_NAMESPACE} and \
-                namespace not in self.imports:
-            raise XMLSchemaNamespaceError(
-                "the QName {!r} is mapped to the namespace {!r}, but this namespace has "
-                "not an xs:import statement in the schema.".format(qname, namespace)
-            )
-        return '{%s}%s' % (namespace, local_name)
-
-    def validate(self, source, path=None, schema_path=None, use_defaults=True, namespaces=None):
-        """
-        Validates an XML data against the XSD schema/component instance.
-
-        :raises: :exc:`XMLSchemaValidationError` if XML *data* instance is not a valid.
-        """
-        for error in self.iter_errors(source, path, schema_path, use_defaults, namespaces):
-            raise error
-
-    def is_valid(self, source, path=None, schema_path=None, use_defaults=True, namespaces=None):
-        """
-        Like :meth:`validate` except that do not raises an exception but returns ``True`` if
-        the XML data is valid, ``False`` if it's invalid.
-        """
-        error = next(self.iter_errors(source, path, schema_path, use_defaults, namespaces), None)
-        return error is None
-
-    def iter_errors(self, source, path=None, schema_path=None, use_defaults=True, namespaces=None):
-        """
-        Creates an iterator for the errors generated by the validation of an XML data
-        against the XSD schema/component instance.
-
-        :param source: the source of XML data. Can be an :class:`XMLResource` instance, a \
-        path to a file or an URI of a resource or an opened file-like object or an Element \
-        instance or an ElementTree instance or a string containing the XML data.
-        :param path: is an optional XPath expression that matches the elements of the XML \
-        data that have to be decoded. If not provided the XML root element is selected.
-        :param schema_path: an alternative XPath expression to select the XSD element \
-        to use for decoding. Useful if the root of the XML data doesn't match an XSD \
-        global element of the schema.
-        :param use_defaults: Use schema's default values for filling missing data.
-        :param namespaces: is an optional mapping from namespace prefix to URI.
-        """
-        self.check_validator(validation='lax')
-        if not isinstance(source, XMLResource):
-            source = XMLResource(source, defuse=self.defuse, timeout=self.timeout)
-        if not schema_path:
-            schema_path = source.get_absolute_path(path)
-
-        namespaces = source.get_namespaces(namespaces, root_only=True)
-        namespace = source.namespace or namespaces.get('', '')
-
-        try:
-            schema = self.get_schema(namespace)
-        except KeyError:
-            schema = self
-
-        identities = {}
-        locations = 
-        ancestors = 
-        prev_ancestors = 
-        kwargs = {
-            'level': source.lazy_depth or bool(path),
-            'source': source,
-            'namespaces': namespaces,
-            'converter': None,
-            'use_defaults': use_defaults,
-            'id_map': Counter(),
-            'identities': identities,
-            'inherited': {},
-            'locations': locations,  # TODO: lazy schemas load
-        }
-
-        if path:
-            selector = source.iterfind(path, namespaces, nsmap=namespaces, ancestors=ancestors)
-        else:
-            selector = source.iter_depth(mode=3, nsmap=namespaces, ancestors=ancestors)
-
-        for elem in selector:
-            if elem is source.root:
-                xsd_element = schema.get_element(elem.tag, namespaces=namespaces)
-                if source.lazy_depth:
-                    kwargs'level' = 0
-                    kwargs'identities' = {}
-                    kwargs'max_depth' = source.lazy_depth
-            else:
-                if prev_ancestors != ancestors:
-                    k = 0
-                    for k in range(min(len(ancestors), len(prev_ancestors))):
-                        if ancestorsk is not prev_ancestorsk:
-                            break
-
-                    path_ = '/'.join(e.tag for e in ancestors) + '/ancestor-or-self::node()'
-                    xsd_ancestors = schema.findall(path_, namespaces)1:
-
-                    for e in xsd_ancestorsk::
-                        e.stop_identities(identities)
-
-                    for e in xsd_ancestorsk::
-                        e.start_identities(identities)
-
-                    prev_ancestors = ancestors:
-
-                xsd_element = schema.get_element(elem.tag, schema_path, namespaces)
-
-            if xsd_element is None:
-                if XSI_TYPE in elem.attrib:
-                    xsd_element = self.create_element(name=elem.tag)
-                elif elem is not source.root and ancestors:
-                    continue
-                else:
-                    reason = "{!r} is not an element of the schema".format(elem)
-                    yield schema.validation_error('lax', reason, elem, source, namespaces)
-                    return
-
-            for result in xsd_element.iter_decode(elem, **kwargs):
-                if isinstance(result, XMLSchemaValidationError):
-                    yield result
-                else:
-                    del result
-
-        if kwargs'identities' is not identities:
-            for identity, counter in kwargs'identities'.items():
-                identitiesidentity.counter.update(counter.counter)
-            kwargs'identities' = identities
-
-        yield from self._validate_references(validation='lax', **kwargs)
-
-    def _validate_references(self, source, validation='lax', id_map=None,
-                             identities=None, **kwargs):
-        # Check unresolved IDREF values
-        if id_map:
-            for k, v in id_map.items():
-                if v == 0:
-                    msg = "IDREF %r not found in XML document" % k
-                    yield self.validation_error(validation, msg, source.root)
-
-        # Check still enabled key references (lazy validation cases)
-        if identities:
-            for constraint, counter in identities.items():
-                if counter.enabled and isinstance(constraint, XsdKeyref):
-                    for error in counter.iter_errors(identities):
-                        yield self.validation_error(validation, error, source.root, **kwargs)
-
-    def raw_decoder(self, source, path=None, schema_path=None, validation='lax',
-                    namespaces=None, **kwargs):
-        """Returns a generator for decoding a resource."""
-        if path:
-            selector = source.iterfind(path, namespaces, nsmap=namespaces)
-        else:
-            selector = source.iter_depth(nsmap=namespaces)
-
-        for elem in selector:
-            xsd_element = self.get_element(elem.tag, schema_path, namespaces)
-            if xsd_element is None:
-                if XSI_TYPE in elem.attrib:
-                    xsd_element = self.create_element(name=elem.tag)
-                else:
-                    reason = "{!r} is not an element of the schema".format(elem)
-                    yield self.validation_error(validation, reason, elem, source, namespaces)
-                    continue
-
-            yield from xsd_element.iter_decode(elem, validation, **kwargs)
-
-        if 'max_depth' not in kwargs:
-            yield from self._validate_references(source, validation=validation, **kwargs)
-
-    def iter_decode(self, source, path=None, schema_path=None, validation='lax',
-                    process_namespaces=True, namespaces=None, use_defaults=True,
-                    decimal_type=None, datetime_types=False, binary_types=False,
-                    converter=None, filler=None, fill_missing=False, keep_unknown=False,
-                    max_depth=None, depth_filler=None, **kwargs):
-        """
-        Creates an iterator for decoding an XML source to a data structure.
-
-        :param source: the source of XML data. Can be an :class:`XMLResource` instance, a \
-        path to a file or an URI of a resource or an opened file-like object or an Element \
-        instance or an ElementTree instance or a string containing the XML data.
-        :param path: is an optional XPath expression that matches the elements of the XML \
-        data that have to be decoded. If not provided the XML root element is selected.
-        :param schema_path: an alternative XPath expression to select the XSD element \
-        to use for decoding. Useful if the root of the XML data doesn't match an XSD \
-        global element of the schema.
-        :param validation: defines the XSD validation mode to use for decode, can be \
-        'strict', 'lax' or 'skip'.
-        :param process_namespaces: whether to use namespace information in the
-        decoding process, using the map provided with the argument *namespaces* \
-        and the map extracted from the XML document.
-        :param namespaces: is an optional mapping from namespace prefix to URI.
-        :param use_defaults: whether to use default values for filling missing data.
-        :param decimal_type: conversion type for `Decimal` objects (generated by \
-        `xs:decimal` built-in and derived types), useful if you want to generate a \
-        JSON-compatible data structure.
-        :param datetime_types: if set to `True` the datetime and duration XSD types \
-        are decoded, otherwise their origin XML string is returned.
-        :param binary_types: if set to `True` xs:hexBinary and xs:base64Binary types \
-        are decoded, otherwise their origin XML string is returned.
-        :param converter: an :class:`XMLSchemaConverter` subclass or instance to use \
-        for decoding.
-        :param filler: an optional callback function to fill undecodable data with a \
-        typed value. The callback function must accept one positional argument, that \
-        can be an XSD Element or an attribute declaration. If not provided undecodable \
-        data is replaced by `None`.
-        :param fill_missing: if set to `True` the decoder fills also missing attributes. \
-        The filling value is `None` or a typed value if the *filler* callback is provided.
-        :param keep_unknown: if set to `True` unknown tags are kept and are decoded with \
-        *xs:anyType*. For default unknown tags not decoded by a wildcard are discarded.
-        :param max_depth: maximum level of decoding, for default there is no limit.
-        :param depth_filler: an optional callback function to replace data over the \
-        *max_depth* level. The callback function must accept one positional argument, that \
-        can be an XSD Element. If not provided deeper data are replaced with `None` values.
-        :param kwargs: keyword arguments with other options for converter and decoder.
-        :return: yields a decoded data object, eventually preceded by a sequence of \
-        validation or decoding errors.
-        """
-        self.check_validator(validation)
-        if not isinstance(source, XMLResource):
-            source = XMLResource(source, defuse=self.defuse, timeout=self.timeout)
-        if not schema_path and path:
-            schema_path = source.get_absolute_path(path)
-
-        if process_namespaces:
-            namespaces = source.get_namespaces(namespaces, root_only=True)
-            namespace = source.namespace or namespaces.get('', '')
-        else:
-            namespace = source.namespace
-
-        schema = self.get_schema(namespace)
-        converter = self.get_converter(converter, namespaces=namespaces, **kwargs)
-        kwargs.update(
-            converter=converter,
-            namespaces=namespaces,
-            source=source,
-            use_defaults=use_defaults,
-            id_map=Counter(),
-            identities={},
-            inherited={},
-        )
-
-        if decimal_type is not None:
-            kwargs'decimal_type' = decimal_type
-        if datetime_types:
-            kwargs'datetime_types' = datetime_types
-        if binary_types:
-            kwargs'binary_types' = binary_types
-        if filler is not None:
-            kwargs'filler' = filler
-        if fill_missing:
-            kwargs'fill_missing' = fill_missing
-        if keep_unknown:
-            kwargs'keep_unknown' = keep_unknown
-        if max_depth is not None:
-            kwargs'max_depth' = max_depth
-        if depth_filler is not None:
-            kwargs'depth_filler' = depth_filler
-
-        if path:
-            selector = source.iterfind(path, namespaces, nsmap=namespaces)
-        elif not source.is_lazy():
-            selector = source.iter_depth(nsmap=namespaces)
-        else:
-            decoder = self.raw_decoder(
-                schema_path=source.get_absolute_path(),
-                validation=validation,
-                **kwargs
-            )
-            kwargs'depth_filler' = lambda x: decoder
-            kwargs'max_depth' = source.lazy_depth
-            selector = source.iter_depth(mode=2, nsmap=namespaces)
-
-        for elem in selector:
-            xsd_element = schema.get_element(elem.tag, schema_path, namespaces)
-            if xsd_element is None:
-                if XSI_TYPE in elem.attrib:
-                    xsd_element = self.create_element(name=elem.tag)
-                else:
-                    reason = "{!r} is not an element of the schema".format(elem)
-                    yield schema.validation_error(validation, reason, elem, source, namespaces)
-                    return
-
-            yield from xsd_element.iter_decode(elem, validation, **kwargs)
-
-        if 'max_depth' not in kwargs:
-            yield from self._validate_references(validation=validation, **kwargs)
-
-    def decode(self, source, path=None, schema_path=None, validation='strict', *args, **kwargs):
-        """
-        Decodes XML data. Takes the same arguments of the method :func:`XMLSchema.iter_decode`.
-        """
-        data, errors = , 
-        for result in self.iter_decode(source, path, schema_path, validation, *args, **kwargs):
-            if not isinstance(result, XMLSchemaValidationError):
-                data.append(result)
-            elif validation == 'lax':
-                errors.append(result)
-            elif validation == 'strict':
-                raise result
-
-        if not data:
-            return (None, errors) if validation == 'lax' else None
-        elif len(data) == 1:
-            return (data0, errors) if validation == 'lax' else data0
-        else:
-            return (data, errors) if validation == 'lax' else data
-
-    to_dict = decode
-
-    def iter_encode(self, obj, path=None, validation='lax', namespaces=None,
-                    use_defaults=True, converter=None, unordered=False, **kwargs):
-        """
-        Creates an iterator for encoding a data structure to an ElementTree's Element.
-
-        :param obj: the data that has to be encoded to XML data.
-        :param path: is an optional XPath expression for selecting the element of \
-        the schema that matches the data that has to be encoded. For default the first \
-        global element of the schema is used.
-        :param validation: the XSD validation mode. Can be 'strict', 'lax' or 'skip'.
-        :param namespaces: is an optional mapping from namespace prefix to URI.
-        :param use_defaults: whether to use default values for filling missing data.
-        :param converter: an :class:`XMLSchemaConverter` subclass or instance to use for \
-        the encoding.
-        :param unordered: a flag for explicitly activating unordered encoding mode for \
-        content model data. This mode uses content models for a reordered-by-model \
-        iteration of the child elements.
-        :param kwargs: Keyword arguments containing options for converter and encoding.
-        :return: yields an Element instance/s or validation/encoding errors.
-        """
-        self.check_validator(validation)
-        if not self.elements:
-            yield XMLSchemaValueError("encoding needs at least one XSD element declaration!")
-
-        namespaces = {} if namespaces is None else namespaces.copy()
-        converter = self.get_converter(converter, namespaces=namespaces, **kwargs)
-
-        xsd_element = None
-        if path is not None:
-            match = re.search(r'{\w', path)
-            if match:
-                namespace = get_namespace(pathmatch.start():, namespaces)
-                schema = self.get_schema(namespace)
-                xsd_element = schema.find(path, namespaces)
-
-        elif len(self.elements) == 1:
-            xsd_element = list(self.elements.values())0
-        else:
-            root_elements = self.root_elements
-            if len(root_elements) == 1:
-                xsd_element = root_elements0
-            elif isinstance(obj, (converter.dict, dict)) and len(obj) == 1:
-                for key in obj:
-                    match = re.search(r'{\w', key)
-                    if match:
-                        namespace = get_namespace(keymatch.start():, namespaces)
-                        schema = self.get_schema(namespace)
-                        xsd_element = schema.find(key, namespaces)
-
-        if not isinstance(xsd_element, XsdElement):
-            if path is not None:
-                reason = "the path %r doesn't match any element of the schema!" % path
-            else:
-                reason = "unable to select an element for decoding data, " \
-                         "provide a valid 'path' argument."
-            raise XMLSchemaEncodeError(self, obj, self.elements, reason, namespaces=namespaces)
-        else:
-            yield from xsd_element.iter_encode(obj, validation, use_defaults=use_defaults,
-                                               converter=converter, unordered=unordered, **kwargs)
-
-    def encode(self, obj, path=None, validation='strict', *args, **kwargs):
-        """
-        Encodes to XML data. Takes the same arguments of the method :func:`XMLSchema.iter_encode`.
-
-        :return: An ElementTree's Element or a list containing a sequence of ElementTree's \
-        elements if the argument *path* matches multiple XML data chunks. If *validation* \
-        argument is 'lax' a 2-items tuple is returned, where the first item is the encoded \
-        object and the second item is a list containing the errors.
-        """
-        data, errors = , 
-        for result in self.iter_encode(obj, path, validation, *args, **kwargs):
-            if not isinstance(result, XMLSchemaValidationError):
-                data.append(result)
-            elif validation == 'lax':
-                errors.append(result)
-            elif validation == 'strict':
-                raise result
-
-        if not data:
-            return (None, errors) if validation == 'lax' else None
-        elif len(data) == 1:
-            return (data0, errors) if validation == 'lax' else data0
-        else:
-            return (data, errors) if validation == 'lax' else data
-
-    to_etree = encode
-
-
-class XMLSchema10(XMLSchemaBase):
-    """
-    XSD 1.0 schema class.
-
-    <schema
-      attributeFormDefault = (qualified | unqualified) : unqualified
-      blockDefault = (#all | List of (extension | restriction | substitution))  : ''
-      elementFormDefault = (qualified | unqualified) : unqualified
-      finalDefault = (#all | List of (extension | restriction | list | union))  : ''
-      id = ID
-      targetNamespace = anyURI
-      version = token
-      xml:lang = language
-      {any attributes with non-schema namespace . . .}>
-      Content: ((include | import | redefine | annotation)*, (((simpleType | complexType | group |
-      attributeGroup) | element | attribute | notation), annotation*)*)
-    </schema>
-    """
-    XSD_VERSION = '1.0'
-    BUILDERS = {
-        'notation_class': XsdNotation,
-        'complex_type_class': XsdComplexType,
-        'attribute_class': XsdAttribute,
-        'any_attribute_class': XsdAnyAttribute,
-        'attribute_group_class': XsdAttributeGroup,
-        'group_class': XsdGroup,
-        'element_class': XsdElement,
-        'any_element_class': XsdAnyElement,
-        'restriction_class': XsdAtomicRestriction,
-        'union_class': XsdUnion,
-        'key_class': XsdKey,
-        'keyref_class': XsdKeyref,
-        'unique_class': XsdUnique,
-        'simple_type_factory': xsd_simple_type_factory
-    }
-    meta_schema = os.path.join(SCHEMAS_DIR, 'XSD_1.0/XMLSchema.xsd')
-    BASE_SCHEMAS = {
-        XML_NAMESPACE: os.path.join(SCHEMAS_DIR, 'XML/xml_minimal.xsd'),
-        XSI_NAMESPACE: os.path.join(SCHEMAS_DIR, 'XSI/XMLSchema-instance_minimal.xsd'),
-    }
-    fallback_locations = LOCATION_HINTS.copy()
-
-
-class XMLSchema11(XMLSchemaBase):
-    """
-    XSD 1.1 schema class.
-
-    <schema
-      attributeFormDefault = (qualified | unqualified) : unqualified
-      blockDefault = (#all | List of (extension | restriction | substitution)) : ''
-      defaultAttributes = QName
-      xpathDefaultNamespace = (anyURI | (##defaultNamespace | ##targetNamespace| ##local)) : ##local
-      elementFormDefault = (qualified | unqualified) : unqualified
-      finalDefault = (#all | List of (extension | restriction | list | union))  : ''
-      id = ID
-      targetNamespace = anyURI
-      version = token
-      xml:lang = language
-      {any attributes with non-schema namespace . . .}>
-      Content: ((include | import | redefine | override | annotation)*,
-      (defaultOpenContent, annotation*)?, ((simpleType | complexType |
-      group | attributeGroup | element | attribute | notation), annotation*)*)
-    </schema>
-
-    <schema
-      attributeFormDefault = (qualified | unqualified) : unqualified
-      blockDefault = (#all | List of (extension | restriction | substitution))  : ''
-      elementFormDefault = (qualified | unqualified) : unqualified
-      finalDefault = (#all | List of (extension | restriction | list | union))  : ''
-      id = ID
-      targetNamespace = anyURI
-      version = token
-      xml:lang = language
-      {any attributes with non-schema namespace . . .}>
-      Content: ((include | import | redefine | annotation)*, (((simpleType | complexType | group |
-      attributeGroup) | element | attribute | notation), annotation*)*)
-    </schema>
-    """
-    XSD_VERSION = '1.1'
-    BUILDERS = {
-        'notation_class': XsdNotation,
-        'complex_type_class': Xsd11ComplexType,
-        'attribute_class': Xsd11Attribute,
-        'any_attribute_class': Xsd11AnyAttribute,
-        'attribute_group_class': XsdAttributeGroup,
-        'group_class': Xsd11Group,
-        'element_class': Xsd11Element,
-        'any_element_class': Xsd11AnyElement,
-        'restriction_class': Xsd11AtomicRestriction,
-        'union_class': Xsd11Union,
-        'key_class': Xsd11Key,
-        'keyref_class': Xsd11Keyref,
-        'unique_class': Xsd11Unique,
-        'simple_type_factory': xsd_simple_type_factory,
-    }
-    meta_schema = os.path.join(SCHEMAS_DIR, 'XSD_1.1/XMLSchema.xsd')
-    BASE_SCHEMAS = {
-        XML_NAMESPACE: os.path.join(SCHEMAS_DIR, 'XML/xml_minimal.xsd'),
-        XSI_NAMESPACE: os.path.join(SCHEMAS_DIR, 'XSI/XMLSchema-instance_minimal.xsd'),
-        XSD_NAMESPACE: os.path.join(SCHEMAS_DIR, 'XSD_1.1/xsd11-extra.xsd'),
-        VC_NAMESPACE: os.path.join(SCHEMAS_DIR, 'VC/XMLSchema-versioning.xsd'),
-    }
-    fallback_locations = LOCATION_HINTS.copy()
-
-    def _parse_inclusions(self):
-        super(XMLSchema11, self)._parse_inclusions()
-
-        for child in self.source.root:
-            if child.tag == XSD_OVERRIDE:
-                try:
-                    location = child.attrib'schemaLocation'.strip()
-                    logger.info("Override schema %r", location)
-                    schema = self.include_schema(location, self.base_url)
-                except KeyError:
-                    # Attribute missing error already found by validation against meta-schema
-                    pass
-                except (OSError, IOError) as err:
-                    # If the override doesn't contain components (annotation excluded)
-                    # the statement is equivalent to an include, so no error is generated.
-                    # Otherwise fails.
-                    self.warnings.append("Override schema failed: %s." % str(err))
-                    warnings.warn(self.warnings-1, XMLSchemaIncludeWarning, stacklevel=3)
-                    if any(e.tag != XSD_ANNOTATION and not callable(e.tag) for e in child):
-                        self.parse_error(str(err), child)
-                else:
-                    schema.override = self
-
-
-XMLSchema = XMLSchema10
-"""The default class for schema instances."""

_service:tar_scm:xmlschema-1.5.2.tar.gz/CHANGELOG.rst -> _service:tar_scm:xmlschema-1.9.2.tar.gz/CHANGELOG.rst Changed

@@ -2,6 +2,86 @@
 CHANGELOG
 *********
 
+`v1.9.2`_ (2021-12-23)
+======================
+* Fix for global simple type naming (issue #278)
+
+`v1.9.1`_ (2021-12-08)
+======================
+* Improve error reporting for encoded data (issue #275)
+* Fix attribute duplicates in attribute group (issue #276)
+* Add process_skipped optional argument to decoding/encoding
+
+`v1.9.0`_ (2021-11-30)
+======================
+* Add iter_decode() to document level API
+* Enhance XMLResource class adding usage of pathlib.Path objects
+  for source and base_url arguments
+* Fix for issue #273
+
+`v1.8.2`_ (2021-11-11)
+======================
+* Fix for issues #266 and #268
+* Fix type annotation of XMLSchema source argument (issue #230)
+
+`v1.8.1`_ (2021-10-20)
+======================
+* Near compliance with strict type annotations
+* Removed ModelGroup class, merged with XsdGroup
+* Some optimizations and fixes from static analysis
+
+`v1.8.0`_ (2021-09-27)
+======================
+* Refactor XMLSchemaMeta deprecating BUILDER attribute
+* Extend type annotations to package API
+* Add static typing tests with checked mypy runs
+
+`v1.7.1`_ (2021-09-03)
+======================
+* Activate mypy checks for package
+* Fix for issues #257 and #259
+
+`v1.7.0`_ (2021-08-02)
+======================
+* Make XSD annotation parsing lazy
+* Add lazy annotations to schema instances
+* Add get_annotation() method to multiple-facets classes (issue #255)
+
+`v1.6.4`_ (2021-06-09)
+======================
+* Add testing config for Python 3.10 (Tox and CI)
+* Fix internal _PurePath class with Python 3.10 (issue #251)
+* Remove redundant xmlns="" declaration when encoding with lxml (issue #252)
+
+`v1.6.3`_ (2021-06-07)
+======================
+* Refactor normalize_url() using pathlib.PurePath
+* Support UNC paths (issue #246)
+* Fix API docs (issue #248)
+
+`v1.6.2`_ (2021-05-03)
+======================
+* Fix for issue #245 (key/keyref with dynamic types)
+* Change default decoding of mixed content with only text to a string
+  instead of a dictionary (issue #242)
+
+`v1.6.1`_ (2021-04-11)
+======================
+* Add multi-source initialization and add_schema() to schema class
+* Add bytes strings to accepted XML sources (issue #238)
+
+`v1.6.0`_ (2021-04-06)
+======================
+* XML data bindings and code generators are now considered stable
+* Add arguments 'max_depth' and 'extra_validator' to validation methods
+* Enhance decoding with 'value_hook' argument
+
+`v1.5.3`_ (2021-03-14)
+======================
+* Remove unnecessary bindings with schema proxy from ElementPathMixin
+  to avoid conflicts when schema is used by an XPath 3 parser
+* Fix schema logger (issue #228)
+
 `v1.5.2`_ (2021-03-04)
 ======================
 * Improve empty content checking
@@ -416,3 +496,17 @@
 .. _v1.5.0: https://github.com/brunato/xmlschema/compare/v1.4.2...v1.5.0
 .. _v1.5.1: https://github.com/brunato/xmlschema/compare/v1.5.0...v1.5.1
 .. _v1.5.2: https://github.com/brunato/xmlschema/compare/v1.5.1...v1.5.2
+.. _v1.5.3: https://github.com/brunato/xmlschema/compare/v1.5.2...v1.5.3
+.. _v1.6.0: https://github.com/brunato/xmlschema/compare/v1.5.3...v1.6.0
+.. _v1.6.1: https://github.com/brunato/xmlschema/compare/v1.6.0...v1.6.1
+.. _v1.6.2: https://github.com/brunato/xmlschema/compare/v1.6.1...v1.6.2
+.. _v1.6.3: https://github.com/brunato/xmlschema/compare/v1.6.2...v1.6.3
+.. _v1.6.4: https://github.com/brunato/xmlschema/compare/v1.6.3...v1.6.4
+.. _v1.7.0: https://github.com/brunato/xmlschema/compare/v1.6.4...v1.7.0
+.. _v1.7.1: https://github.com/brunato/xmlschema/compare/v1.7.0...v1.7.1
+.. _v1.8.0: https://github.com/brunato/xmlschema/compare/v1.7.1...v1.8.0
+.. _v1.8.1: https://github.com/brunato/xmlschema/compare/v1.8.0...v1.8.1
+.. _v1.8.2: https://github.com/brunato/xmlschema/compare/v1.8.1...v1.8.2
+.. _v1.9.0: https://github.com/brunato/xmlschema/compare/v1.8.2...v1.9.0
+.. _v1.9.1: https://github.com/brunato/xmlschema/compare/v1.9.0...v1.9.1
+.. _v1.9.2: https://github.com/brunato/xmlschema/compare/v1.9.1...v1.9.2

_service:tar_scm:xmlschema-1.5.2.tar.gz/PKG-INFO -> _service:tar_scm:xmlschema-1.9.2.tar.gz/PKG-INFO Changed

@@ -1,172 +1,11 @@
 Metadata-Version: 2.1
 Name: xmlschema
-Version: 1.5.2
+Version: 1.9.2
 Summary: An XML Schema validator and decoder
 Home-page: https://github.com/sissaschool/xmlschema
 Author: Davide Brunato
 Author-email: brunato@sissa.it
 License: MIT
-Description: *********
-        xmlschema
-        *********
-        
-        .. image:: https://img.shields.io/pypi/v/xmlschema.svg
-           :target: https://pypi.python.org/pypi/xmlschema/
-        .. image:: https://img.shields.io/pypi/pyversions/xmlschema.svg
-           :target: https://pypi.python.org/pypi/xmlschema/
-        .. image:: https://img.shields.io/pypi/implementation/xmlschema.svg
-           :target: https://pypi.python.org/pypi/xmlschema/
-        .. image:: https://img.shields.io/badge/License-MIT-blue.svg
-           :alt: MIT License
-           :target: https://lbesson.mit-license.org/
-        .. image:: https://travis-ci.org/sissaschool/xmlschema.svg?branch=master
-           :target: https://travis-ci.org/sissaschool/xmlschema
-        .. image:: https://img.shields.io/pypi/dm/xmlschema.svg
-           :target: https://pypi.python.org/pypi/xmlschema/
-        .. image:: https://img.shields.io/badge/Maintained%3F-yes-green.svg
-           :target: https://GitHub.com/Naereen/StrapDown.js/graphs/commit-activity
-        
-        .. xmlschema-introduction-start
-        
-        The *xmlschema* library is an implementation of `XML Schema <http://www.w3.org/2001/XMLSchema>`_
-        for Python (supports Python 3.6+).
-        
-        This library arises from the needs of a solid Python layer for processing XML
-        Schema based files for
-        `MaX (Materials design at the Exascale) <http://www.max-centre.eu>`_  European project.
-        A significant problem is the encoding and the decoding of the XML data files
-        produced by different simulation software.
-        Another important requirement is the XML data validation, in order to put the
-        produced data under control. The lack of a suitable alternative for Python in
-        the schema-based decoding of XML data has led to build this library. Obviously
-        this library can be useful for other cases related to XML Schema based processing,
-        not only for the original scope.
-        
-        The full `xmlschema documentation is available on "Read the Docs" <http://xmlschema.readthedocs.io/en/latest/>`_.
-        
-        
-        Features
-        ========
-        
-        This library includes the following features:
-        
-        * Full XSD 1.0 and XSD 1.1 support
-        * Building of XML schema objects from XSD files
-        * Validation of XML instances against XSD schemas
-        * Decoding of XML data into Python data and to JSON
-        * Encoding of Python data and JSON to XML
-        * Data decoding and encoding ruled by converter classes
-        * An XPath based API for finding schema's elements and attributes
-        * Support of XSD validation modes *strict*/*lax*/*skip*
-        * Remote attacks protection by default using an XMLParser that forbids entities
-        * XML data bindings based on DataElement class (experimental)
-        * Static code generation with Jinja2 templates (experimental)
-        
-        
-        Installation
-        ============
-        
-        You can install the library with *pip* in a Python 3.6+ environment::
-        
-            pip install xmlschema
-        
-        The library uses the Python's ElementTree XML library and requires
-        `elementpath <https://github.com/brunato/elementpath>`_ additional package.
-        The base schemas of the XSD standards are included in the package for working
-        offline and to speed-up the building of schema instances.
-        
-        .. xmlschema-introduction-end
-        
-        
-        Usage
-        =====
-        
-        Import the library and then create a schema instance using the path of
-        the file containing the schema as argument:
-        
-        .. code-block:: pycon
-        
-            >>> import xmlschema
-            >>> my_schema = xmlschema.XMLSchema('tests/test_cases/examples/vehicles/vehicles.xsd')
-        
-        .. note::
-            For XSD 1.1 schemas use the class `XMLSchema11`, because the default class
-            `XMLSchema` is an alias of the XSD 1.0 validator class `XMLSchema10`.
-        
-        The schema can be used to validate XML documents:
-        
-        .. code-block:: pycon
-        
-            >>> my_schema.is_valid('tests/test_cases/examples/vehicles/vehicles.xml')
-            True
-            >>> my_schema.is_valid('tests/test_cases/examples/vehicles/vehicles-1_error.xml')
-            False
-            >>> my_schema.validate('tests/test_cases/examples/vehicles/vehicles-1_error.xml')
-            Traceback (most recent call last):
-              File "<stdin>", line 1, in <module>
-              File "/home/brunato/Development/projects/xmlschema/xmlschema/validators/xsdbase.py", line 393, in validate
-                raise error
-            xmlschema.validators.exceptions.XMLSchemaValidationError: failed validating <Element '{http://example.com/vehicles}cars' at 0x7f8032768458> with XsdGroup(model='sequence').
-        
-            Reason: character data between child elements not allowed!
-        
-            Schema:
-        
-              <xs:sequence xmlns:xs="http://www.w3.org/2001/XMLSchema">
-                    <xs:element maxOccurs="unbounded" minOccurs="0" name="car" type="vh:vehicleType" />
-              </xs:sequence>
-        
-            Instance:
-        
-              <vh:cars xmlns:vh="http://example.com/vehicles">
-                NOT ALLOWED CHARACTER DATA
-                <vh:car make="Porsche" model="911" />
-                <vh:car make="Porsche" model="911" />
-              </vh:cars>
-        
-        Using a schema you can also decode the XML documents to nested dictionaries, with
-        values that match to the data types declared by the schema:
-        
-        .. code-block:: pycon
-        
-            >>> import xmlschema
-            >>> from pprint import pprint
-            >>> xs = xmlschema.XMLSchema('tests/test_cases/examples/collection/collection.xsd')
-            >>> pprint(xs.to_dict('tests/test_cases/examples/collection/collection.xml'))
-            {'@xsi:schemaLocation': 'http://example.com/ns/collection collection.xsd',
-             'object': {'@available': True,
-                         '@id': 'b0836217462',
-                         'author': {'@id': 'PAR',
-                                    'born': '1841-02-25',
-                                    'dead': '1919-12-03',
-                                    'name': 'Pierre-Auguste Renoir',
-                                    'qualification': 'painter'},
-                         'estimation': Decimal('10000.00'),
-                         'position': 1,
-                         'title': 'The Umbrellas',
-                         'year': '1886'},
-                        {'@available': True,
-                         '@id': 'b0836217463',
-                         'author': {'@id': 'JM',
-                                    'born': '1893-04-20',
-                                    'dead': '1983-12-25',
-                                    'name': 'Joan Miró',
-                                    'qualification': 'painter, sculptor and ceramicist'},
-                         'position': 2,
-                         'title': None,
-                         'year': '1925'}}
-        
-        
-        Authors
-        =======
-        Davide Brunato and others who have contributed with code or with sample cases.
-        
-        License
-        =======
-        This software is distributed under the terms of the MIT License.
-        See the file 'LICENSE' in the root directory of the present
-        distribution, or http://opensource.org/licenses/MIT.
-        
 Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -181,6 +20,7 @@
 Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Software Development :: Libraries
@@ -189,3 +29,167 @@
 Provides-Extra: codegen
 Provides-Extra: dev
 Provides-Extra: docs
+License-File: LICENSE
+
+*********
+xmlschema
+*********
+
+.. image:: https://img.shields.io/pypi/v/xmlschema.svg
+   :target: https://pypi.python.org/pypi/xmlschema/
+.. image:: https://img.shields.io/pypi/pyversions/xmlschema.svg
+   :target: https://pypi.python.org/pypi/xmlschema/
+.. image:: https://img.shields.io/pypi/implementation/xmlschema.svg
+   :target: https://pypi.python.org/pypi/xmlschema/
+.. image:: https://img.shields.io/badge/License-MIT-blue.svg
+   :alt: MIT License
+   :target: https://lbesson.mit-license.org/
+.. image:: https://travis-ci.org/sissaschool/xmlschema.svg?branch=master
+   :target: https://travis-ci.org/sissaschool/xmlschema
+.. image:: https://img.shields.io/pypi/dm/xmlschema.svg
+   :target: https://pypi.python.org/pypi/xmlschema/
+.. image:: https://img.shields.io/badge/Maintained%3F-yes-green.svg
+   :target: https://GitHub.com/Naereen/StrapDown.js/graphs/commit-activity
+
+.. xmlschema-introduction-start
+
+The *xmlschema* library is an implementation of `XML Schema <http://www.w3.org/2001/XMLSchema>`_
+for Python (supports Python 3.6+).
+
+This library arises from the needs of a solid Python layer for processing XML
+Schema based files for
+`MaX (Materials design at the Exascale) <http://www.max-centre.eu>`_  European project.
+A significant problem is the encoding and the decoding of the XML data files
+produced by different simulation software.
+Another important requirement is the XML data validation, in order to put the
+produced data under control. The lack of a suitable alternative for Python in
+the schema-based decoding of XML data has led to build this library. Obviously
+this library can be useful for other cases related to XML Schema based processing,
+not only for the original scope.
+
+The full `xmlschema documentation is available on "Read the Docs" <http://xmlschema.readthedocs.io/en/latest/>`_.
+
+
+Features
+========
+
+This library includes the following features:
+
+* Full XSD 1.0 and XSD 1.1 support
+* Building of XML schema objects from XSD files
+* Validation of XML instances against XSD schemas
+* Decoding of XML data into Python data and to JSON
+* Encoding of Python data and JSON to XML
+* Data decoding and encoding ruled by converter classes
+* An XPath based API for finding schema's elements and attributes
+* Support of XSD validation modes *strict*/*lax*/*skip*
+* Remote attacks protection by default using an XMLParser that forbids entities
+* XML data bindings based on DataElement class
+* Static code generation with Jinja2 templates
+
+
+Installation
+============
+
+You can install the library with *pip* in a Python 3.6+ environment::
+
+    pip install xmlschema
+
+The library uses the Python's ElementTree XML library and requires
+`elementpath <https://github.com/brunato/elementpath>`_ additional package.
+The base schemas of the XSD standards are included in the package for working
+offline and to speed-up the building of schema instances.
+
+.. xmlschema-introduction-end
+
+
+Usage
+=====
+
+Import the library and then create a schema instance using the path of
+the file containing the schema as argument:
+
+.. code-block:: pycon
+
+    >>> import xmlschema
+    >>> my_schema = xmlschema.XMLSchema('tests/test_cases/examples/vehicles/vehicles.xsd')
+
+.. note::
+    For XSD 1.1 schemas use the class `XMLSchema11`, because the default class
+    `XMLSchema` is an alias of the XSD 1.0 validator class `XMLSchema10`.
+
+The schema can be used to validate XML documents:
+
+.. code-block:: pycon
+
+    >>> my_schema.is_valid('tests/test_cases/examples/vehicles/vehicles.xml')
+    True
+    >>> my_schema.is_valid('tests/test_cases/examples/vehicles/vehicles-1_error.xml')
+    False
+    >>> my_schema.validate('tests/test_cases/examples/vehicles/vehicles-1_error.xml')
+    Traceback (most recent call last):
+      File "<stdin>", line 1, in <module>
+      File "/home/brunato/Development/projects/xmlschema/xmlschema/validators/xsdbase.py", line 393, in validate
+        raise error
+    xmlschema.validators.exceptions.XMLSchemaValidationError: failed validating <Element '{http://example.com/vehicles}cars' at 0x7f8032768458> with XsdGroup(model='sequence').
+
+    Reason: character data between child elements not allowed!
+
+    Schema:
+
+      <xs:sequence xmlns:xs="http://www.w3.org/2001/XMLSchema">
+            <xs:element maxOccurs="unbounded" minOccurs="0" name="car" type="vh:vehicleType" />
+      </xs:sequence>
+
+    Instance:
+
+      <vh:cars xmlns:vh="http://example.com/vehicles">
+        NOT ALLOWED CHARACTER DATA
+        <vh:car make="Porsche" model="911" />
+        <vh:car make="Porsche" model="911" />
+      </vh:cars>
+
+Using a schema you can also decode the XML documents to nested dictionaries, with
+values that match to the data types declared by the schema:
+
+.. code-block:: pycon
+
+    >>> import xmlschema
+    >>> from pprint import pprint
+    >>> xs = xmlschema.XMLSchema('tests/test_cases/examples/collection/collection.xsd')
+    >>> pprint(xs.to_dict('tests/test_cases/examples/collection/collection.xml'))
+    {'@xsi:schemaLocation': 'http://example.com/ns/collection collection.xsd',
+     'object': {'@available': True,
+                 '@id': 'b0836217462',
+                 'author': {'@id': 'PAR',
+                            'born': '1841-02-25',
+                            'dead': '1919-12-03',
+                            'name': 'Pierre-Auguste Renoir',
+                            'qualification': 'painter'},
+                 'estimation': Decimal('10000.00'),
+                 'position': 1,
+                 'title': 'The Umbrellas',
+                 'year': '1886'},
+                {'@available': True,
+                 '@id': 'b0836217463',
+                 'author': {'@id': 'JM',
+                            'born': '1893-04-20',
+                            'dead': '1983-12-25',
+                            'name': 'Joan Miró',
+                            'qualification': 'painter, sculptor and ceramicist'},
+                 'position': 2,
+                 'title': None,
+                 'year': '1925'}}
+
+
+Authors
+=======
+Davide Brunato and others who have contributed with code or with sample cases.
+
+License
+=======
+This software is distributed under the terms of the MIT License.
+See the file 'LICENSE' in the root directory of the present
+distribution, or http://opensource.org/licenses/MIT.
+
+

_service:tar_scm:xmlschema-1.5.2.tar.gz/README.rst -> _service:tar_scm:xmlschema-1.9.2.tar.gz/README.rst Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/doc/api.rst -> _service:tar_scm:xmlschema-1.9.2.tar.gz/doc/api.rst Changed

@@ -37,6 +37,7 @@
 .. autofunction:: xmlschema.validate
 .. autofunction:: xmlschema.is_valid
 .. autofunction:: xmlschema.iter_errors
+.. autofunction:: xmlschema.iter_decode
 .. autofunction:: xmlschema.to_dict
 .. autofunction:: xmlschema.to_json
 .. autofunction:: xmlschema.from_json
@@ -59,7 +60,9 @@
 
     .. autoattribute:: root
     .. automethod:: get_text
+    .. autoattribute:: name
     .. autoattribute:: url
+    .. autoattribute:: base_url
 
     .. autoattribute:: tag
     .. autoattribute:: id
@@ -69,7 +72,6 @@
     .. autoattribute:: no_namespace_schema_location
     .. autoattribute:: target_prefix
     .. autoattribute:: default_namespace
-    .. autoattribute:: base_url
     .. autoattribute:: root_elements
     .. autoattribute:: simple_types
     .. autoattribute:: complex_types
@@ -186,8 +188,10 @@
 
     .. autoattribute:: root
     .. autoattribute:: text
+    .. autoattribute:: name
     .. autoattribute:: url
     .. autoattribute:: base_url
+    .. autoattribute:: filepath
     .. autoattribute:: namespace
 
     .. automethod:: parse
@@ -313,7 +317,7 @@
 .. autoclass:: xmlschema.validators.Xsd11ComplexType
 .. autoclass:: xmlschema.validators.XsdComplexType
 
-    .. autoattribute:: content_type
+    .. autoattribute:: content
 
 .. autoclass:: xmlschema.validators.XsdSimpleType

_service:tar_scm:xmlschema-1.5.2.tar.gz/doc/components.rst -> _service:tar_scm:xmlschema-1.9.2.tar.gz/doc/components.rst Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/doc/conf.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/doc/conf.py Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/doc/extras.rst -> _service:tar_scm:xmlschema-1.9.2.tar.gz/doc/extras.rst Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/doc/testing.rst -> _service:tar_scm:xmlschema-1.9.2.tar.gz/doc/testing.rst Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/doc/usage.rst -> _service:tar_scm:xmlschema-1.9.2.tar.gz/doc/usage.rst Changed

@@ -79,6 +79,51 @@
     >>> schema = xmlschema.XMLSchema(schema_file, base_url='tests/test_cases/examples/vehicles/')
 
 
+Non standard options for schema instance creation
+-------------------------------------------------
+
+Other options for schema instance creation are available using non-standard
+methods. Most cases require to use the *build* option to delay the schema
+build after the loading of all schema resources. For example:
+
+.. doctest::
+
+    >>> schema_file = open('tests/test_cases/examples/vehicles/vehicles.xsd')
+    >>> schema = xmlschema.XMLSchema(schema_file, build=False)
+    >>> _ = schema.include_schema('tests/test_cases/examples/vehicles/cars.xsd')
+    >>> _ = schema.include_schema('tests/test_cases/examples/vehicles/bikes.xsd')
+    >>> schema.build()
+
+Another option, available from release v1.6.1, is to provide a list of schema sources,
+particurlaly useful when sources have no locations associated:
+
+.. doctest::
+
+    >>> sources = open('tests/test_cases/examples/vehicles/vehicles.xsd'),
+    ...            open('tests/test_cases/examples/vehicles/cars.xsd'),
+    ...            open('tests/test_cases/examples/vehicles/bikes.xsd'),
+    ...            open('tests/test_cases/examples/vehicles/types.xsd')
+    >>> schema = xmlschema.XMLSchema(sources)
+
+or similarly to the previous example one can use the method :meth:`add_schema()`:
+
+.. doctest::
+
+    >>> schema_file = open('tests/test_cases/examples/vehicles/vehicles.xsd')
+    >>> schema = xmlschema.XMLSchema(schema_file, build=False)
+    >>> _ = schema.add_schema(open('tests/test_cases/examples/vehicles/cars.xsd'))
+    >>> _ = schema.add_schema(open('tests/test_cases/examples/vehicles/bikes.xsd'))
+    >>> _ = schema.add_schema(open('tests/test_cases/examples/vehicles/types.xsd'))
+    >>> schema.build()
+
+
+.. note::
+    Anyway the advice is to build intermediate XSD schemas intead for loading
+    all the schemas needed in a standard way, because XSD mechanisms of imports,
+    includes, redefines and overrides are usually supported when you submit your
+    schemas to other XSD validators.
+
+
 Validation
 ==========

_service:tar_scm:xmlschema-1.5.2.tar.gz/requirements-dev.txt -> _service:tar_scm:xmlschema-1.9.2.tar.gz/requirements-dev.txt Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/setup.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/setup.py Changed

@@ -1,6 +1,6 @@
 #! /usr/bin/env python
 #
-# Copyright (c) 2016-2020, SISSA (International School for Advanced Studies).
+# Copyright (c) 2016-2021, SISSA (International School for Advanced Studies).
 # All rights reserved.
 # This file is distributed under the terms of the MIT License.
 # See the file 'LICENSE' in the root directory of the present
@@ -9,14 +9,16 @@
 # @author Davide Brunato <brunato@sissa.it>
 #
 from setuptools import setup, find_packages
+from pathlib import Path
 
-with open("README.rst") as readme:
+
+with Path(__file__).parent.joinpath('README.rst').open() as readme:
     long_description = readme.read()
 
 
 setup(
     name='xmlschema',
-    version='1.5.2',
+    version='1.9.2',
     packages=find_packages(include='xmlschema', 'xmlschema.*'),
     include_package_data=True,
     entry_points={
@@ -27,12 +29,13 @@
         
     },
     python_requires='>=3.6',
-    install_requires='elementpath>=2.1.2, <3.0.0',
+    install_requires='elementpath>=2.4.0, <3.0.0',
     extras_require={
-        'codegen': 'elementpath>=2.1.2, <3.0.0', 'jinja2',
-        'dev': 'tox', 'coverage', 'lxml', 'elementpath>=2.1.2, <3.0.0',
-                'memory_profiler', 'Sphinx', 'sphinx_rtd_theme', 'jinja2',
-        'docs': 'elementpath>=2.1.2, <3.0.0', 'Sphinx', 'sphinx_rtd_theme', 'jinja2'
+        'codegen': 'elementpath>=2.4.0, <3.0.0', 'jinja2',
+        'dev': 'tox', 'coverage', 'lxml', 'elementpath>=2.4.0, <3.0.0',
+                'memory_profiler', 'Sphinx', 'sphinx_rtd_theme', 'jinja2',
+                'flake8', 'mypy', 'lxml-stubs',
+        'docs': 'elementpath>=2.4.0, <3.0.0', 'Sphinx', 'sphinx_rtd_theme', 'jinja2'
     },
     author='Davide Brunato',
     author_email='brunato@sissa.it',
@@ -55,6 +58,7 @@
         'Programming Language :: Python :: 3.7',
         'Programming Language :: Python :: 3.8',
         'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
         'Programming Language :: Python :: Implementation :: CPython',
         'Programming Language :: Python :: Implementation :: PyPy',
         'Topic :: Software Development :: Libraries',

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/check_memory.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/check_memory.py Changed

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/templates/filters/unknown_filter_test.jinja Added

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/test_all.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_all.py Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/test_cases/examples/collection/collection.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/examples/collection/collection.py Changed

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/features/decoder/data4-mixed.xml Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/features/decoder/long-sequence-1.xsd Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/features/decoder/mixed-content.xsd Added

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/test_cases/features/decoder/simple-types.xsd -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/features/decoder/simple-types.xsd Changed

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_237 Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_237/dir1 Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_237/dir1/issue_237.xsd Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_237/dir1/stockquoteservice.wsdl Added

@@ -0,0 +1,31 @@
+<?xml version="1.0"?>
+<definitions name="StockQuote"
+             targetNamespace="http://example.com/stockquote/service"
+             xmlns:tns="http://example.com/stockquote/service"
+             xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
+             xmlns:defs="http://example.com/stockquote/definitions"
+             xmlns="http://schemas.xmlsoap.org/wsdl/">
+
+   <import namespace="http://example.com/stockquote/definitions"
+           location="../dir2/stockquote.wsdl"/>
+
+    <binding name="StockQuoteBinding" type="defs:StockQuotePortType">
+        <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
+        <operation name="GetLastTradePrice">
+           <soap:operation soapAction="http://example.com/GetLastTradePrice"/>
+           <input>
+               <soap:body use="literal"/>
+           </input>
+           <output>
+               <soap:body use="literal"/>
+           </output>
+        </operation>
+    </binding>
+
+    <service name="StockQuoteService">
+        <documentation>My first service</documentation>
+        <port name="StockQuotePort" binding="tns:StockQuoteBinding">
+           <soap:address location="http://example.com/stockquote"/>
+        </port>
+    </service>
+</definitions>
\ No newline at end of file

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_237/dir2 Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_237/dir2/issue_237a.xsd Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_237/dir2/issue_237b.xsd Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_237/dir2/stockquote.wsdl Added

@@ -0,0 +1,26 @@
+<?xml version="1.0"?>
+
+<definitions name="StockQuote"
+             targetNamespace="http://example.com/stockquote/definitions"
+             xmlns:tns="http://example.com/stockquote/definitions"
+             xmlns:xsd1="http://example.com/stockquote/schemas"
+             xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
+             xmlns="http://schemas.xmlsoap.org/wsdl/">
+
+    <import namespace="http://example.com/stockquote/schemas" location="./stockquote.xsd" />
+
+    <message name="GetLastTradePriceInput">
+        <part name="body" element="xsd1:TradePriceRequest"/>
+    </message>
+
+    <message name="GetLastTradePriceOutput">
+        <part name="body" element="xsd1:TradePrice"/>
+    </message>
+
+    <portType name="StockQuotePortType">
+        <operation name="GetLastTradePrice">
+           <input message="tns:GetLastTradePriceInput"/>
+           <output message="tns:GetLastTradePriceOutput"/>
+        </operation>
+    </portType>
+</definitions>
\ No newline at end of file

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_237/dir2/stockquote.xsd Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_243 Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_243/issue_243.xml Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_243/issue_243.xsd Added

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns:vc="http://www.w3.org/2007/XMLSchema-versioning" elementFormDefault="qualified"
+    attributeFormDefault="unqualified" vc:minVersion="1.1"
+    xmlns:am="http://www.test.com/XMLSchema/manifest/2021"
+    targetNamespace="http://www.test.com/XMLSchema/manifest/2021"
+    xmlns="http://www.test.com/XMLSchema/manifest/2021">
+    <xs:element name="manifest">
+        <xs:complexType>
+            <xs:sequence>
+                <xs:element name="session">
+                    <xs:complexType>
+                        <xs:sequence>
+                            <xs:element name="userId" nillable="true">
+                                <xs:simpleType>
+                                    <xs:restriction base="xs:string">
+                                        <xs:minLength value="1"/>
+                                    </xs:restriction>
+                                </xs:simpleType>
+                            </xs:element>
+                            <xs:element name="sessionId" nillable="true">
+                                <xs:simpleType>
+                                    <xs:restriction base="xs:integer">
+                                        <xs:minInclusive value="0"/>
+                                    </xs:restriction>
+                                </xs:simpleType>
+                            </xs:element>
+                        </xs:sequence>
+                        <xs:attribute name="anonymous" type="xs:boolean" use="required">
+                        </xs:attribute>
+                        <xs:assert
+                            test="((@anonymous eq true()) and am:userId@xsi:nil and am:sessionId@xsi:nil) or ((@anonymous eq false()) and am:userIdnode() and am:sessionIdnode())"
+                        />
+                    </xs:complexType>
+                </xs:element>
+            </xs:sequence>
+        </xs:complexType>
+    </xs:element>
+</xs:schema>
+

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_245 Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_245/issue_245-valid.xml Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_245/issue_245.xml Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_245/issue_245.xsd Added

@@ -0,0 +1,94 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns:vc="http://www.w3.org/2007/XMLSchema-versioning" elementFormDefault="qualified"
+    attributeFormDefault="unqualified" vc:minVersion="1.1"
+    targetNamespace="http://www.test.com/XMLSchema/data/2021"
+    xmlns="http://www.test.com/XMLSchema/data/2021"
+    xmlns:ad="http://www.test.com/XMLSchema/data/2021">
+    <xs:element name="assessment">
+        <xs:annotation>
+            <xs:documentation>Data about the performed tests.</xs:documentation>
+        </xs:annotation>
+        <xs:complexType>
+            <xs:sequence>
+                <xs:element maxOccurs="unbounded" minOccurs="0" name="part" type="AssessmentPart">
+                    <xs:key name="circle_id_key">
+                        <xs:annotation>
+                            <xs:documentation>For ContrastVisionTest. 
+
+Since all parts are types we can not add keys and keyrefs to them. As such, we add the constraints here.</xs:documentation>
+                        </xs:annotation>
+                        <xs:selector xpath="ad:screen_elements/ad:contrast_circles/ad:circle"/>
+                        <xs:field xpath="@circle_id"/>
+                    </xs:key>
+                    <xs:keyref name="circle_id_keyref" refer="circle_id_key">
+                        <xs:selector xpath="ad:events/ad:circle_pressed"/>
+                        <xs:field xpath="@circle_id"/>
+                    </xs:keyref>
+                </xs:element>
+            </xs:sequence>
+        </xs:complexType>
+    </xs:element>
+    <xs:complexType abstract="true" name="AssessmentPart">
+        <xs:annotation>
+            <xs:documentation>Base type for the assessment element.</xs:documentation>
+        </xs:annotation>
+    </xs:complexType>
+    <xs:complexType abstract="true" name="AssessmentTest">
+        <xs:annotation>
+            <xs:documentation>Base type for a test.</xs:documentation>
+        </xs:annotation>
+        <xs:complexContent>
+            <xs:extension base="AssessmentPart"/>
+        </xs:complexContent>
+    </xs:complexType>
+    <xs:complexType name="ContrastVisionTest">
+        <xs:complexContent>
+            <xs:extension base="AssessmentTest">
+                <xs:sequence>
+                    <xs:element name="screen_elements">
+                        <xs:complexType>
+                            <xs:sequence>
+                                <xs:element name="contrast_circles">
+                                    <xs:complexType>
+                                        <xs:sequence>
+                                            <xs:element maxOccurs="3" name="circle" minOccurs="3">
+                                                <xs:complexType>
+                                                  <xs:attribute name="circle_id" use="required">
+                                                  <xs:annotation>
+                                                  <xs:documentation>The id of this circle, used to reference the circle presses.</xs:documentation>
+                                                  </xs:annotation>
+                                                  <xs:simpleType>
+                                                  <xs:restriction base="xs:integer">
+                                                  <xs:minInclusive value="0"/>
+                                                  <xs:maxInclusive value="9"/>
+                                                  </xs:restriction>
+                                                  </xs:simpleType>
+                                                  </xs:attribute>
+                                                </xs:complexType>
+                                            </xs:element>
+                                        </xs:sequence>
+                                    </xs:complexType>
+                                </xs:element>
+                            </xs:sequence>
+                        </xs:complexType>
+                    </xs:element>
+                    <xs:element name="events">
+                        <xs:complexType>
+                            <xs:sequence>
+                                <xs:element maxOccurs="unbounded" minOccurs="0"
+                                    name="circle_pressed">
+                                    <xs:complexType>
+                                        <xs:attribute name="circle_id" type="xs:integer"
+                                            use="required"/>
+                                    </xs:complexType>
+                                </xs:element>
+                            </xs:sequence>
+                        </xs:complexType>
+                    </xs:element>
+                </xs:sequence>
+            </xs:extension>
+        </xs:complexContent>
+    </xs:complexType>
+</xs:schema>

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_259 Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_259/issue_259-1.xsd Added

@@ -0,0 +1,65 @@
+<?xml version="1.0"?>
+<xs:schema
+  xmlns:xs="http://www.w3.org/2001/XMLSchema"
+  xmlns:vc="http://www.w3.org/2007/XMLSchema-versioning"
+  elementFormDefault="qualified"
+  vc:minVersion="1.1">
+
+  <xs:complexType name="ConfigurationType">
+    <xs:all>
+      <xs:element name="DefaultProt1" type="ProtocolDefault" minOccurs="0" maxOccurs="1"/>
+      <xs:element name="DefaultProt2" type="ProtocolDefault" minOccurs="0" maxOccurs="1"/>
+      
+      <xs:element name="DefaultProt13" type="ProtocolDefault" minOccurs="0" maxOccurs="1"/>
+      <xs:element name="connectionChannel" type="connectionChannel" maxOccurs="1" >
+        <xs:unique name="redChannelNameUniqueness">
+          <xs:selector xpath="redChannel"/>
+          <xs:field xpath="@name"/>
+        </xs:unique>
+      </xs:element>
+    </xs:all>
+  </xs:complexType>
+
+  <xs:complexType name="connectionChannel">
+    <xs:all>
+      <xs:element name="Prot1" type="Protocol" minOccurs="0" maxOccurs="1"/>
+      <xs:element name="Prot2" type="Protocol" minOccurs="0" maxOccurs="1"/>
+      
+      <xs:element name="Prot13" type="Protocol" minOccurs="0" maxOccurs="1"/>
+      <xs:element name="redChannel" type="redChannelType" minOccurs="1" maxOccurs="8"/>
+    </xs:all>
+    <xs:attribute name="name" use="required">
+      <xs:simpleType>
+        <xs:restriction base="xs:string">
+          <xs:minLength value="1"/>
+          <xs:maxLength value="63"/>
+          <xs:pattern value="(a-zA-Z0-9\._\-)*"/>
+        </xs:restriction>
+      </xs:simpleType>
+    </xs:attribute>
+  </xs:complexType>
+
+
+  <xs:element name="Configuration" type="ConfigurationType">
+    <xs:unique name="connectionChannelNameUniqueness">
+      <xs:selector xpath="connectionChannel"/>
+      <xs:field xpath="@name"/>
+    </xs:unique>
+  </xs:element>
+
+
+  <xs:complexType name="redChannelType">
+    <xs:attribute name="name" use="required" type="xs:string"/>
+  </xs:complexType>
+
+  <xs:complexType name="ProtocolDefault">
+  <xs:attribute name="interfaceIdentifier" use="optional" type="xs:unsignedByte"/>
+  <xs:attribute name="outgoingDirectionIdentifier" use="optional" type="xs:unsignedByte"/>
+</xs:complexType>
+
+  <xs:complexType name="Protocol">
+  <xs:attribute name="interfaceIdentifier" use="optional" type="xs:unsignedByte"/>
+  <xs:attribute name="outgoingDirectionIdentifier" use="optional" type="xs:unsignedByte"/>
+</xs:complexType>
+
+</xs:schema>
\ No newline at end of file

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_259/issue_259-2.xsd Added

@@ -0,0 +1,42 @@
+<?xml version="1.0"?>
+<xs:schema
+  xmlns:xs="http://www.w3.org/2001/XMLSchema"
+  xmlns:vc="http://www.w3.org/2007/XMLSchema-versioning"
+  elementFormDefault="qualified"
+  vc:minVersion="1.1">
+
+  <xs:redefine schemaLocation="issue_259-1.xsd">
+    <xs:complexType name="ConfigurationType">
+      <xs:complexContent>
+        <xs:extension base="ConfigurationType">
+          <xs:all>
+            <xs:element name="MyProtDefault" type="CustomProtocolDefault" minOccurs="0" maxOccurs="1"/>
+          </xs:all>
+        </xs:extension>
+      </xs:complexContent>
+    </xs:complexType>
+
+
+    <xs:complexType name="redChannelType">
+      <xs:complexContent>
+        <xs:extension base="redChannelType">
+          <xs:all>
+            <xs:element name="MyProt" type="CustomProtocol" minOccurs="0" maxOccurs="1"/>
+          </xs:all>
+        </xs:extension>
+      </xs:complexContent>
+    </xs:complexType>
+  </xs:redefine>
+
+
+  <xs:complexType name="CustomProtocolDefault">
+        <xs:attribute name="interfaceIdentifier" use="optional" type="xs:unsignedByte"/>
+        <xs:attribute name="outgoingDirectionIdentifier" use="optional" type="xs:unsignedByte"/>
+  </xs:complexType>
+
+    <xs:complexType name="CustomProtocol">
+        <xs:attribute name="interfaceIdentifier" use="optional" type="xs:unsignedByte"/>
+        <xs:attribute name="outgoingDirectionIdentifier" use="optional" type="xs:unsignedByte"/>
+  </xs:complexType>
+
+</xs:schema>
\ No newline at end of file

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_265 Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_265/issue_265-1.xsd Added

@@ -0,0 +1,120 @@
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+    <xs:complexType name="studentInfoHuelle" abstract="true"/>
+
+	<xs:complexType name="studentInfoMinimal">
+		<xs:complexContent>
+			<xs:extension base="studentInfoHuelle">
+				<xs:sequence>
+					<xs:element name="vorname" type="sbtTextNotEmpty" minOccurs="1"/>
+					<xs:element name="nachname" type="sbtTextNotEmpty" minOccurs="1"/>
+					<xs:element name="geburtsdatum" type="xs:date" minOccurs="1"/>
+					<xs:element name="geschlecht" type="geschlechtTyp" minOccurs="1"/>
+				</xs:sequence>
+			</xs:extension>
+		</xs:complexContent>
+	</xs:complexType>
+
+	<xs:complexType name="studentInfoBasis">
+		<xs:complexContent>
+			<xs:extension base="studentInfoMinimal">
+				<xs:sequence>
+					<xs:element name="staatsbuergerschaft" type="staatTyp" minOccurs="0"/>
+					<xs:element name="akadgrad" type="akadTyp" minOccurs="0"/>
+					<xs:element name="akadnach" type="akadTyp" minOccurs="0"/>
+				</xs:sequence>
+			</xs:extension>
+		</xs:complexContent>
+	</xs:complexType>
+
+	<xs:complexType name="studentInfoExtended">
+		<xs:complexContent>
+			<xs:extension base="studentInfoBasis">
+				<xs:sequence>
+					<xs:element name="bpk" type="bpkTyp" minOccurs="0"/>
+					<xs:element name="svnr" type="svnrTyp" minOccurs="0"/>
+					<xs:element name="ekz" type="ekzTyp" minOccurs="0"/>
+				</xs:sequence>
+			</xs:extension>
+		</xs:complexContent>
+	</xs:complexType>
+
+	<xs:complexType name="studentInfoBasisAdressen">
+		<xs:complexContent>
+			<xs:extension base="studentInfoExtended">
+				<xs:sequence>
+					<xs:element name="adressen" type="adressenListe"/>
+				</xs:sequence>
+			</xs:extension>
+		</xs:complexContent>
+	</xs:complexType>
+
+	<xs:complexType name="UniStudentInfo">
+		<xs:complexContent>
+			<xs:extension base="studentInfoBasisAdressen">
+				<xs:sequence>
+					<xs:element name="studierendenkey" type="Studierendenkey" minOccurs="1" maxOccurs="1"/>
+				</xs:sequence>
+			</xs:extension>
+		</xs:complexContent>
+	</xs:complexType>
+
+  <xs:complexType name="FullStudentInfo">
+		<xs:complexContent>
+			<xs:extension base="UniStudentInfo">
+				<xs:sequence>
+                  <xs:element name="studienliste" type="studienliste"/>
+                  <xs:element name="studienbeitrag" type="KontostandUniInfo"/>
+                </xs:sequence>
+            </xs:extension>
+        </xs:complexContent>
+  </xs:complexType>
+
+	
+
+	<xs:simpleType name="sbtTextNotEmpty">
+		<xs:restriction base="xs:string"/>
+	</xs:simpleType>
+
+	<xs:simpleType name="geschlechtTyp">
+		<xs:restriction base="xs:string"/>
+	</xs:simpleType>
+
+	<xs:simpleType name="staatTyp">
+		<xs:restriction base="xs:string"/>
+	</xs:simpleType>
+
+	<xs:simpleType name="akadTyp">
+		<xs:restriction base="xs:string"/>
+	</xs:simpleType>
+
+	<xs:simpleType name="bpkTyp">
+		<xs:restriction base="xs:string"/>
+	</xs:simpleType>
+
+	<xs:simpleType name="svnrTyp">
+		<xs:restriction base="xs:string"/>
+	</xs:simpleType>
+
+	<xs:simpleType name="ekzTyp">
+		<xs:restriction base="xs:string"/>
+	</xs:simpleType>
+
+	<xs:simpleType name="adressenListe">
+		<xs:restriction base="xs:string"/>
+	</xs:simpleType>
+
+	<xs:simpleType name="Studierendenkey">
+		<xs:restriction base="xs:string"/>
+	</xs:simpleType>
+
+	<xs:simpleType name="studienliste">
+		<xs:restriction base="xs:string"/>
+	</xs:simpleType>
+
+	<xs:simpleType name="KontostandUniInfo">
+		<xs:restriction base="xs:string"/>
+	</xs:simpleType>
+
+</xs:schema>
\ No newline at end of file

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_265/issue_265-2-invalid.xsd Added

@@ -0,0 +1,28 @@
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:redefine schemaLocation="issue_265-1.xsd">
+      <xs:complexType name="FullStudentInfo">
+        <xs:complexContent>
+          <xs:restriction base="FullStudentInfo">
+            <xs:sequence>
+              <xs:element name="vorname" type="sbtTextNotEmpty" minOccurs="1"/>
+              <xs:element name="nachname" type="sbtTextNotEmpty" minOccurs="1"/>
+              <xs:element name="geburtsdatum" type="xs:date" minOccurs="1"/>
+              <xs:element name="geschlecht" type="geschlechtTyp" minOccurs="1"/>
+              <xs:element name="staatsbuergerschaft" type="staatTyp" minOccurs="0"/>
+              <xs:element name="akadgrad" type="akadTyp" minOccurs="0"/>
+              <xs:element name="akadnach" type="akadTyp" minOccurs="0"/>
+              <xs:element name="bpk" type="bpkTyp" minOccurs="0"/>
+              <xs:element name="svnr" type="svnrTyp" minOccurs="0"/>
+              <xs:element name="ekz" type="ekzTyp" minOccurs="0"/>
+              <xs:element name="adressen" type="adressenListe"/>
+              <xs:element name="studierendenkey" type="Studierendenkey" minOccurs="1" maxOccurs="1"/>
+              <xs:element name="studienbeitrag" type="KontostandUniInfo"/>
+            </xs:sequence>
+          </xs:restriction>
+        </xs:complexContent>
+      </xs:complexType>
+  </xs:redefine>
+
+</xs:schema>
\ No newline at end of file

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_265/issue_265-2-override.xsd Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_266 Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_266/issue_266-1.xml Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_266/issue_266-1.xsd Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_266/issue_266-2.xml Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_266/issue_266-2.xsd Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_266/issue_266b-1.xsd Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_266/issue_266b-2.xsd Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_273 Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_273/issue_273.xml Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_273/issue_273.xsd Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_276 Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_276/dummy.xml Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/issues/issue_276/schema.xsd Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/mypy Added

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/mypy/schema_source.py Added

@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+
+def main() -> None:
+    import io
+    from pathlib import Path
+    from typing import cast, IO
+    from xml.etree import ElementTree
+
+    import xmlschema
+
+    case_dir = Path(__file__).parent.parent
+    col_xsd = case_dir.joinpath('examples/collection/collection.xsd')
+
+    schema = xmlschema.XMLSchema10(str(col_xsd))
+    print(f"{schema} from filepath")
+
+    with open(str(col_xsd)) as fp:
+        schema = xmlschema.XMLSchema10(fp)
+    print(f"{schema} from open(filepath)")
+
+    with open(str(col_xsd), mode='rb') as bfp:
+        schema = xmlschema.XMLSchema10(bfp)
+    print(f"{schema} from open(filepath, mode='rb'), mode binary")
+
+    with col_xsd.open() as fp:
+        schema = xmlschema.XMLSchema10(cast(IOstr, fp))
+    print(f"{schema} from IOstr")
+
+    with col_xsd.open(mode='rb') as bfp:
+        schema = xmlschema.XMLSchema10(cast(IOstr, bfp))
+    print(f"{schema} from IObytes")
+
+    with col_xsd.open() as fp:
+        schema = xmlschema.XMLSchema10(io.StringIO(fp.read()))
+    print(f"{schema} from io.StringIO()")
+
+    with col_xsd.open(mode='rb') as bfp:
+        schema = xmlschema.XMLSchema10(io.BytesIO(bfp.read()))
+    print(f"{schema} from io.BytesIO()")
+
+    xt = ElementTree.parse(col_xsd)
+    namespaces = {
+        'xs': "http://www.w3.org/2001/XMLSchema",
+        '': "http://example.com/ns/collection",
+    }
+    schema = xmlschema.XMLSchema10(xt, build=False)
+    schema.namespaces.update(namespaces)  # FIXME? Provide an init argument?
+    schema.build()
+    print(f"{schema} from ElementTree.ElementTree")
+
+    schema = xmlschema.XMLSchema10(xt.getroot(), build=False)
+    schema.namespaces.update(namespaces)
+    schema.build()
+    print(f"{schema} from ElementTree.Element")
+
+    schema = xmlschema.XMLSchema10(xmlschema.XMLResource(str(col_xsd)))
+    print(f"{schema} from xmlschema.XMLResource()")
+
+
+if __name__ == '__main__':
+    main()

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/mypy/simple_types.py Added

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/test_cases/testfiles -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_cases/testfiles Changed

@@ -8,19 +8,19 @@
 #
 
 # Cases with schema examples
-examples/collection/collection.xsd --inspect
-examples/collection/collection.xsd --inspect --version=1.1
-examples/collection/collection.xml
+examples/collection/collection.xsd --inspect --codegen
+examples/collection/collection.xsd --inspect --version=1.1 --codegen
+examples/collection/collection.xml --codegen
 examples/collection/collection2.xsd --inspect   # key constraint
 examples/collection/collection2.xml --errors 1
 examples/collection/collection3.xsd      # key and keyref constraints
 examples/collection/collection3.xml --errors 1
 examples/collection/collection3bis.xsd
 examples/collection/collection3bis.xml --errors 1
-examples/collection/collection4.xml      # Many XML comments inserted
-examples/vehicles/vehicles.xsd --inspect
-examples/vehicles/vehicles.xsd --inspect --version=1.1
-examples/vehicles/vehicles.xml
+examples/collection/collection4.xml --codegen # Many XML comments inserted
+examples/vehicles/vehicles.xsd --inspect --codegen
+examples/vehicles/vehicles.xsd --inspect --version=1.1 --codegen
+examples/vehicles/vehicles.xml --codegen
 examples/vehicles/vehicles-1_error.xml --errors=1
 examples/vehicles/vehicles-2_errors.xml --errors=2
 examples/vehicles/vehicles-3_errors.xml --errors=3
@@ -32,8 +32,12 @@
 
 features/builtins/builtins.xsd
 features/builtins/builtins.xml
+
 features/decoder/simple-types.xsd
 features/decoder/data2.xml --errors=2
+features/decoder/mixed-content.xsd
+features/decoder/data4-mixed.xml
+
 features/derivations/complex-extensions.xsd --errors=1
 features/derivations/complex-with-simple-content-restriction.xsd
 features/derivations/list_types.xsd --errors=1
@@ -118,3 +122,16 @@
 issues/issue_222/issue_222.xml -L '' issue_222.xsd
 issues/issue_223/issue_223.xsd
 issues/issue_223/issue_223.xml -L '' issue_223.xsd --errors=1  # pattern matching with \n ending
+issues/issue_243/issue_243.xml --version=1.1 -L '' issue_243.xsd
+issues/issue_245/issue_245.xml --version=1.1 --errors=2  # duplicated key value with xsi:type
+issues/issue_245/issue_245-valid.xml --version=1.1
+issues/issue_259/issue_259-2.xsd --version=1.1
+issues/issue_265/issue_265-1.xsd
+issues/issue_265/issue_265-2-invalid.xsd --errors=1
+issues/issue_265/issue_265-2-override.xsd --version=1.1
+issues/issue_266/issue_266-1.xsd
+issues/issue_266/issue_266-1.xml
+issues/issue_266/issue_266-2.xsd
+issues/issue_266/issue_266-2.xml
+issues/issue_276/schema.xsd
+issues/issue_276/dummy.xml

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/test_codegen.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_codegen.py Changed

@@ -14,12 +14,17 @@
 import os
 import datetime
 import ast
+import logging
 import platform
 import importlib.util
+import tempfile
+from collections import namedtuple
 from pathlib import Path
 from textwrap import dedent
 from xml.etree import ElementTree
 
+from elementpath import datatypes
+
 from xmlschema import XMLSchema10, XMLSchema11
 from xmlschema.names import XSD_ANY_TYPE, XSD_STRING, XSD_FLOAT
 
@@ -45,6 +50,7 @@
             'float': 'float',
             'double': 'double',
             'integer': 'int',
+            'decimal': 'float',
             'unsignedByte': 'unsigned short',
             'nonNegativeInteger': 'unsigned int',
             'positiveInteger': 'unsigned int',
@@ -80,23 +86,37 @@
 <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
     xmlns:tns="http://xmlschema.test/ns" 
     targetNamespace="http://xmlschema.test/ns">
+
   <xs:element name="root" type="xs:string" />
+
   <xs:complexType name="type3">
     <xs:sequence>
       <xs:element name="elem1" type="tns:type1" />
       <xs:element name="elem2" type="tns:type2" />
     </xs:sequence>
   </xs:complexType>
+
   <xs:complexType name="type2">
     <xs:sequence>
       <xs:element name="elem1" type="tns:type1" />
-      <xs:element name="elem4" type="tns:type4" />
+      <xs:element name="elem4" type="tns:type4" maxOccurs="10" />
     </xs:sequence>
   </xs:complexType>
+
   <xs:simpleType name="type4">
     <xs:restriction base="xs:string" />
   </xs:simpleType>
+
   <xs:complexType name="type1" />
+
+  <xs:simpleType name="type5">
+    <xs:restriction base="xs:decimal" />
+  </xs:simpleType>
+  
+  <xs:simpleType name="type6">
+    <xs:restriction base="xs:float" />
+  </xs:simpleType>
+
 </xs:schema>
 """
 
@@ -104,18 +124,19 @@
 @unittest.skipIf(jinja2 is None, "jinja2 library is not installed!")
 class TestAbstractGenerator(unittest.TestCase):
 
+    schema_class = XMLSchema10
     generator_class = DemoGenerator
 
     @classmethod
     def setUpClass(cls):
-        cls.schema = XMLSchema10(XSD_TEST)
+        cls.schema = cls.schema_class(XSD_TEST)
         cls.searchpath = Path(__file__).absolute().parent.joinpath('templates/filters/')
         cls.generator = cls.generator_class(cls.schema, str(cls.searchpath))
 
         cls.col_dir = casepath('examples/collection')
         cls.col_xsd_file = casepath('examples/collection/collection.xsd')
         cls.col_xml_file = casepath('examples/collection/collection.xml')
-        cls.col_schema = XMLSchema10(cls.col_xsd_file)
+        cls.col_schema = cls.schema_class(cls.col_xsd_file)
 
     def test_formal_language(self):
         self.assertEqual(self.generator_class.formal_language, 'Demo')
@@ -245,6 +266,54 @@
         with self.assertRaises(jinja2.TemplateSyntaxError):
             self.generator.render('wrong-template.jinja')
 
+        logger = logging.getLogger('xmlschema-codegen')
+
+        with self.assertLogs(logger, level=logging.DEBUG):
+            self.generator.render('unknown')
+
+    def test_render_to_files(self):
+        with tempfile.TemporaryDirectory() as outdir:
+            files = self.generator.render_to_files('name_filter_test.jinja', output_dir=outdir)
+            self.assertListEqual(files, os.path.join(outdir, 'name_filter_test'))
+
+            files = self.generator.render_to_files(
+                'name_filter_test.jinja', 'namespace_filter_test.jinja', output_dir=outdir)
+            self.assertListEqual(files, os.path.join(outdir, 'namespace_filter_test'))
+
+        with tempfile.TemporaryDirectory() as outdir:
+            files = self.generator.render_to_files(
+                'name_filter_test.jinja', 'namespace_filter_test.jinja', output_dir=outdir
+            )
+            self.assertSetEqual(set(files), {
+                os.path.join(outdir, 'name_filter_test'),
+                os.path.join(outdir, 'namespace_filter_test'),
+            })
+
+        with tempfile.TemporaryDirectory() as outdir:
+            files = self.generator.render_to_files('name*', output_dir=outdir)
+
+            self.assertSetEqual(set(files), {
+                os.path.join(outdir, 'name_filter_test'),
+                os.path.join(outdir, 'namespace_filter_test'),
+            })
+
+        with tempfile.TemporaryDirectory() as outdir:
+            with self.assertRaises(TypeError):
+                self.generator.render_to_files(
+                    'name_filter_test.jinja', False, output_dir=outdir)
+
+            with self.assertRaises(jinja2.TemplateSyntaxError):
+                self.generator.render_to_files('wrong-template.jinja', output_dir=outdir)
+
+            logger = logging.getLogger('xmlschema-codegen')
+
+            with self.assertLogs(logger, level=logging.DEBUG):
+                with self.assertRaises(jinja2.TemplateSyntaxError):
+                    self.generator.render_to_files('*', output_dir=outdir)
+
+            with self.assertLogs(logger, level=logging.DEBUG):
+                self.generator.render_to_files('unknown', output_dir=outdir)
+
     def test_language_type_filter(self):
         self.assertListEqual(self.generator.render('demo_type_filter_test.jinja'), 'str')
 
@@ -277,45 +346,206 @@
             with self.assertRaises(KeyError):
                 self.generator.filters'instance_filter'(dt)
 
+    def test_map_type(self):
+        self.assertEqual(self.generator.map_type(None), '')
+        self.assertEqual(self.generator.map_type(self.schema.elements'root'), 'str')
+        self.assertEqual(self.generator.map_type(self.schema.types'type1'), '')
+        self.assertEqual(self.generator.map_type(self.schema.types'type2'), '')
+        self.assertEqual(self.generator.map_type(self.schema.types'type4'), 'str')
+        self.assertEqual(self.generator.map_type(self.schema.types'type5'), 'float')
+        self.assertEqual(self.generator.map_type(self.schema.types'type6'), 'float')
+
+        date_type = self.schema.meta_schema.types'date'
+        self.assertEqual(self.generator.map_type(date_type), '')
+
     def test_name_filter(self):
         xsd_element = self.schema.elements'root'
         self.assertEqual(self.generator.filters'name'(xsd_element), 'root')
         self.assertListEqual(self.generator.render('name_filter_test.jinja'), 'root')
 
+        self.assertEqual(self.generator.name(None), 'none')
+        self.assertEqual(self.generator.name(''), '')
+        self.assertEqual(self.generator.name('foo'), 'foo')
+        self.assertEqual(self.generator.name('{http://xmlschema.test/ns}foo'), 'foo')
+        self.assertEqual(self.generator.name('ns:foo'), 'foo')
+        self.assertEqual(self.generator.name('0:foo'), '')
+        self.assertEqual(self.generator.name('1'), 'none')
+
+        FakeElement = namedtuple('XsdElement', 'local_name name')
+        fake_element = FakeElement(1, 2)
+        self.assertEqual(self.generator.name(fake_element), '')
+
     def test_qname_filter(self):
         xsd_element = self.schema.elements'root'
         self.assertEqual(self.generator.filters'qname'(xsd_element), 'tns__root')
         self.assertListEqual(self.generator.render('qname_filter_test.jinja'), 'tns__root')
 
+        self.assertEqual(self.generator.qname(None), 'none')
+        self.assertEqual(self.generator.qname(''), '')
+        self.assertEqual(self.generator.qname('{wrong'), 'none')
+        self.assertEqual(self.generator.qname('foo'), 'foo')
+        self.assertEqual(self.generator.qname('{http://xmlschema.test/ns}foo'), 'tns__foo')
+        self.assertEqual(self.generator.qname('{http://unknown.test/ns}foo'), 'foo')
+        self.assertEqual(self.generator.qname('ns:foo'), 'ns__foo')
+        self.assertEqual(self.generator.qname('0:foo'), 'none')
+        self.assertEqual(self.generator.qname('1'), 'none')
+
     def test_namespace_filter(self):
         xsd_element = self.schema.elements'root'
         tns = 'http://xmlschema.test/ns'
         self.assertEqual(self.generator.filters'namespace'(xsd_element), tns)
         self.assertListEqual(self.generator.render('namespace_filter_test.jinja'), tns)
 
+        self.assertEqual(self.generator.namespace(None), '')
+        self.assertEqual(self.generator.namespace(''), '')
+        self.assertEqual(self.generator.namespace('{wrong'), '')
+        self.assertEqual(self.generator.namespace('foo'), '')
+        self.assertEqual(self.generator.namespace('{bar}foo'), 'bar')
+        self.assertEqual(self.generator.namespace('tns:foo'), 'http://xmlschema.test/ns')
+        self.assertEqual(self.generator.namespace('0:foo'), '')
+        self.assertEqual(self.generator.namespace('1'), '')
+
+        qname = datatypes.QName('http://xmlschema.test/ns', 'tns:foo')
+        self.assertEqual(self.generator.namespace(qname), 'http://xmlschema.test/ns')
+
     def test_type_name_filter(self):
         xsd_element = self.schema.elements'root'
         self.assertEqual(self.generator.filters'type_name'(xsd_element), 'string')
         self.assertListEqual(self.generator.render('type_name_filter_test.jinja'), 'string')
 
+        self.assertEqual(self.generator.type_name(None), 'none')
+
+        unnamed_type = self.col_schema.types'objType'.content5.type
+        self.assertEqual(self.generator.type_name(unnamed_type), 'none')
+
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:complexType name="a_type"/>
+                <xs:complexType name="bType"/>
+                <xs:complexType name="c"/>
+                <xs:complexType name="c-1"/>
+                <xs:complexType name="c.2"/>
+            </xs:schema>"""))
+
+        self.assertEqual(self.generator.type_name(schema.types'a_type'), 'a')
+        self.assertEqual(self.generator.type_name(schema.types'bType'), 'b')
+        self.assertEqual(self.generator.type_name(schema.types'c'), 'c')
+
+        self.assertEqual(self.generator.type_name(schema.types'a_type', suffix='Type'), 'aType')
+        self.assertEqual(self.generator.type_name(schema.types'bType', suffix='Type'), 'bType')
+        self.assertEqual(self.generator.type_name(schema.types'c', suffix='Type'), 'cType')
+
+        self.assertEqual(self.generator.type_name(schema.types'c-1'), 'c_1')
+        self.assertEqual(self.generator.type_name(schema.types'c.2'), 'c_2')
+
     def test_type_qname_filter(self):
         xsd_element = self.schema.elements'root'
         self.assertEqual(self.generator.filters'type_qname'(xsd_element), 'xs__string')
         self.assertListEqual(
             self.generator.render('type_qname_filter_test.jinja'), 'xs__string')
 
+        self.assertEqual(self.generator.type_qname(None), 'none')
+
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                    xmlns:tns="http://xmlschema.test/ns"
+                    targetNamespace="http://xmlschema.test/ns">
+               <xs:complexType name="a_type"/>
+               <xs:complexType name="bType"/>
+               <xs:complexType name="c"/>
+               <xs:complexType name="c-1"/>
+               <xs:complexType name="c.2"/>
+            </xs:schema>"""))
+
+        self.assertEqual(self.generator.type_qname(schema.types'a_type'), 'tns__a')
+        self.assertEqual(self.generator.type_qname(schema.types'bType'), 'tns__b')
+        self.assertEqual(self.generator.type_qname(schema.types'c'), 'tns__c')
+
+        self.assertEqual(self.generator.type_qname(schema.types'a_type', suffix='Type'),
+                         'tns__aType')
+        self.assertEqual(self.generator.type_qname(schema.types'bType', suffix='Type'),
+                         'tns__bType')
+        self.assertEqual(self.generator.type_qname(schema.types'c', suffix='Type'),
+                         'tns__cType')
+
+        self.assertEqual(self.generator.type_qname(schema.types'c-1'), 'tns__c_1')
+        self.assertEqual(self.generator.type_qname(schema.types'c.2'), 'tns__c_2')
+
     def test_sort_types_filter(self):
         xsd_types = self.schema.types
+        sorted_types = xsd_types'type4', xsd_types'type5', xsd_types'type6',
+                        xsd_types'type1', xsd_types'type2', xsd_types'type3'
+
+        self.assertListEqual(
+            self.generator.filters'sort_types'(xsd_types), sorted_types
+        )
+        self.assertListEqual(
+            self.generator.filters'sort_types'(xsd_types.values()), sorted_types
+        )
         self.assertListEqual(
-            self.generator.filters'sort_types'(xsd_types),
-            xsd_types'type4', xsd_types'type1', xsd_types'type2', xsd_types'type3'
+            self.generator.filters'sort_types'(list(xsd_types.values())), sorted_types
         )
+
         self.assertListEqual(
-            self.generator.render('sort_types_filter_test.jinja'), 'type4type1type2type3'
+            self.generator.render('sort_types_filter_test.jinja'),
+            'type4type5type6type1type2type3'
         )
 
-    def test_extension_test(self):
-        return
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+                <xs:complexType name="type1">
+                    <xs:sequence>
+                        <xs:element name="elem1" type="xs:string" />
+                        <xs:element name="elem2" type="type2" />
+                    </xs:sequence>
+                </xs:complexType>
+                
+                <xs:complexType name="type2">
+                    <xs:sequence>
+                        <xs:element name="elem1" type="type1" />
+                        <xs:element name="elem2" type="xs:string" />
+                    </xs:sequence>
+                </xs:complexType>
+
+            </xs:schema>"""))
+
+        with self.assertRaises(ValueError) as ec:
+            self.generator.sort_types(schema.types)
+        self.assertIn("circularity found", str(ec.exception))
+
+        self.assertListEqual(
+            self.generator.sort_types(schema.types, accept_circularity=True),
+            list(schema.types.values())
+        )
+
+    def test_unknown_filter(self):
+        logger = logging.getLogger('xmlschema-codegen')
+
+        with self.assertLogs(logger, level=logging.DEBUG):
+            self.assertListEqual(self.generator.render('unknown_filter_test.jinja'), )
+
+    def test_is_derivation(self):
+        self.assertFalse(self.generator.extension(self.schema.types'type1'))
+        self.assertFalse(self.generator.extension(self.schema.types'type1', 'tns:type1'))
+        self.assertFalse(self.generator.restriction(self.schema.types'type1', 'tns:type1'))
+        self.assertFalse(self.generator.derivation(self.schema.types'type1', 'type1'))
+        self.assertFalse(self.generator.restriction(self.schema.types'type6', 'xs:decimal'))
+        self.assertFalse(self.generator.restriction(self.schema.types'type6', None))
+        self.assertFalse(self.generator.derivation(self.schema.types'type1', 'tns0:type1'))
+
+        self.assertTrue(self.generator.derivation(self.schema.types'type1', 'tns:type1'))
+        self.assertTrue(self.generator.restriction(self.schema.types'type6', 'xs:float'))
+
+    def test_multi_sequence(self):
+        self.assertFalse(self.generator.multi_sequence(self.schema.types'type3'))
+        self.assertTrue(self.generator.multi_sequence(self.schema.types'type2'))
+        self.assertFalse(self.generator.multi_sequence(self.schema.types'type5'))
+
+
+@unittest.skipIf(jinja2 is None, "jinja2 library is not installed!")
+class TestAbstractGenerator11(TestAbstractGenerator):
+    schema_class = XMLSchema11
 
 
 @unittest.skipIf(jinja2 is None, "jinja2 library is not installed!")
@@ -326,6 +556,15 @@
     def test_formal_language(self):
         self.assertEqual(PythonGenerator.formal_language, 'Python')
 
+    def test_map_type(self):
+        self.assertEqual(self.generator.map_type(None), '')
+        self.assertEqual(self.generator.map_type(self.schema.elements'root'), 'str')
+        self.assertEqual(self.generator.map_type(self.schema.types'type1'), '')
+        self.assertEqual(self.generator.map_type(self.schema.types'type2'), '')
+        self.assertEqual(self.generator.map_type(self.schema.types'type4'), 'str')
+        self.assertEqual(self.generator.map_type(self.schema.types'type5'), 'decimal.Decimal')
+        self.assertEqual(self.generator.map_type(self.schema.types'type6'), 'float')
+
     def test_language_type_filter(self):
         self.assertListEqual(
             self.generator.render('python_type_filter_test.jinja'), 'str'
@@ -364,7 +603,7 @@
             spec = importlib.util.spec_from_file_location('collection', 'collection.py')
             module = importlib.util.module_from_spec(spec)
             spec.loader.exec_module(module)
-        except Exception:
+        except SyntaxError:
             pass
         else:
             col_data = module.CollectionBinding.fromsource('collection.xml')
@@ -374,6 +613,11 @@
             os.chdir(cwd)
 
 
+@unittest.skipIf(jinja2 is None, "jinja2 library is not installed!")
+class TestPythonGenerator11(TestPythonGenerator):
+    schema_class = XMLSchema11
+
+
 if __name__ == '__main__':
     import platform
     header_template = "Test xmlschema code generators with Python {} on {}"

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/test_converters.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_converters.py Changed

@@ -35,10 +35,14 @@
         cls.col_xsd_filename = cls.casepath('examples/collection/collection.xsd')
         cls.col_xml_filename = cls.casepath('examples/collection/collection.xml')
         cls.col_xml_root = ElementTree.parse(cls.col_xml_filename).getroot()
-        cls.col_lxml_root = lxml_etree.parse(cls.col_xml_filename).getroot()
         cls.col_nsmap = fetch_namespaces(cls.col_xml_filename)
         cls.col_namespace = cls.col_nsmap'col'
 
+        if lxml_etree is not None:
+            cls.col_lxml_root = lxml_etree.parse(cls.col_xml_filename).getroot()
+        else:
+            cls.col_lxml_root = None
+
     @classmethod
     def casepath(cls, relative_path):
         return str(Path(__file__).parent.joinpath('test_cases', relative_path))
@@ -196,9 +200,10 @@
         self.assertIsNone(etree_elements_assert_equal(self.col_xml_root, root, strict=False))
 
         # Decode from lxml.etree.Element tree
-        obj2 = col_schema.decode(self.col_lxml_root)
-        self.assertIn("'@xmlns:col'", repr(obj2))
-        self.assertEqual(obj1, obj2)
+        if self.col_lxml_root is not None:
+            obj2 = col_schema.decode(self.col_lxml_root)
+            self.assertIn("'@xmlns:col'", repr(obj2))
+            self.assertEqual(obj1, obj2)
 
         # Decode from ElementTree.Element tree providing namespaces
         obj2 = col_schema.decode(self.col_xml_root, namespaces=self.col_nsmap)
@@ -232,10 +237,11 @@
         self.assertIsNone(etree_elements_assert_equal(self.col_xml_root, root, strict=False))
 
         # Decode from lxml.etree.Element tree
-        obj2 = col_schema.decode(self.col_lxml_root, preserve_root=True)
-        self.assertIn("'col:collection'", repr(obj2))
-        self.assertIn("'@xmlns:col'", repr(obj2))
-        self.assertEqual(obj1, obj2)
+        if self.col_lxml_root is not None:
+            obj2 = col_schema.decode(self.col_lxml_root, preserve_root=True)
+            self.assertIn("'col:collection'", repr(obj2))
+            self.assertIn("'@xmlns:col'", repr(obj2))
+            self.assertEqual(obj1, obj2)
 
         # Decode from ElementTree.Element tree providing namespaces
         obj2 = col_schema.decode(self.col_xml_root, namespaces=self.col_nsmap, preserve_root=True)
@@ -270,9 +276,10 @@
         self.assertIsNone(etree_elements_assert_equal(self.col_xml_root, root, strict=False))
 
         # Decode from lxml.etree.Element tree
-        obj2 = col_schema.decode(self.col_lxml_root)
-        self.assertIn("'@xmlns:col'", repr(obj2))
-        self.assertEqual(obj1, obj2)
+        if self.col_lxml_root is not None:
+            obj2 = col_schema.decode(self.col_lxml_root)
+            self.assertIn("'@xmlns:col'", repr(obj2))
+            self.assertEqual(obj1, obj2)
 
         # Decode from ElementTree.Element tree providing namespaces
         obj2 = col_schema.decode(self.col_xml_root, namespaces=self.col_nsmap)
@@ -306,10 +313,11 @@
         self.assertIsNone(etree_elements_assert_equal(self.col_xml_root, root, strict=False))
 
         # Decode from lxml.etree.Element tree
-        obj2 = col_schema.decode(self.col_lxml_root, preserve_root=True)
-        self.assertIn("'col:collection'", repr(obj2))
-        self.assertIn("'@xmlns:col'", repr(obj2))
-        self.assertEqual(obj1, obj2)
+        if self.col_lxml_root is not None:
+            obj2 = col_schema.decode(self.col_lxml_root, preserve_root=True)
+            self.assertIn("'col:collection'", repr(obj2))
+            self.assertIn("'@xmlns:col'", repr(obj2))
+            self.assertEqual(obj1, obj2)
 
         # Decode from ElementTree.Element tree providing namespaces
         obj2 = col_schema.decode(self.col_xml_root, namespaces=self.col_nsmap, preserve_root=True)
@@ -358,7 +366,8 @@
         self.assertEqual(obj1, col_schema.decode(self.col_xml_root, namespaces=self.col_nsmap))
 
         # With lxml.etree namespaces are mapped
-        self.assertEqual(obj1, col_schema.decode(self.col_lxml_root))
+        if self.col_lxml_root is not None:
+            self.assertEqual(obj1, col_schema.decode(self.col_lxml_root))
 
         root = col_schema.encode(obj2, path='./col:collection', namespaces=self.col_nsmap)
         self.assertIsNone(etree_elements_assert_equal(self.col_xml_root, root, strict=False))
@@ -385,7 +394,8 @@
         self.assertEqual(obj1, col_schema.decode(self.col_xml_root, namespaces=self.col_nsmap))
 
         # With lxml.etree namespaces are mapped
-        self.assertEqual(obj1, col_schema.decode(self.col_lxml_root))
+        if self.col_lxml_root is not None:
+            self.assertEqual(obj1, col_schema.decode(self.col_lxml_root))
 
         root = col_schema.encode(obj2, path='./col:collection', namespaces=self.col_nsmap)
         self.assertIsNone(etree_elements_assert_equal(self.col_xml_root, root, strict=False))
@@ -416,7 +426,8 @@
         self.assertEqual(obj1, col_schema.decode(self.col_xml_root, namespaces=self.col_nsmap))
 
         # With lxml.etree namespaces are mapped
-        self.assertEqual(obj1, col_schema.decode(self.col_lxml_root))
+        if self.col_lxml_root is not None:
+            self.assertEqual(obj1, col_schema.decode(self.col_lxml_root))
 
         root = col_schema.encode(obj2, path='./col:collection', namespaces=self.col_nsmap)
         self.assertIsNone(etree_elements_assert_equal(self.col_xml_root, root, strict=False))
@@ -443,7 +454,8 @@
         self.assertEqual(obj1, col_schema.decode(self.col_xml_root, namespaces=self.col_nsmap))
 
         # With lxml.etree namespaces are mapped
-        self.assertEqual(obj1, col_schema.decode(self.col_lxml_root))
+        if self.col_lxml_root is not None:
+            self.assertEqual(obj1, col_schema.decode(self.col_lxml_root))
 
         root = col_schema.encode(obj2, path='./col:collection', namespaces=self.col_nsmap)
         self.assertIsNone(etree_elements_assert_equal(self.col_xml_root, root, strict=False))
@@ -479,9 +491,10 @@
         ))
 
         # With lxml.etree namespaces are mapped
-        self.assertIsNone(etree_elements_assert_equal(
-            obj1, col_schema.decode(self.col_lxml_root)
-        ))
+        if self.col_lxml_root is not None:
+            self.assertIsNone(etree_elements_assert_equal(
+                obj1, col_schema.decode(self.col_lxml_root)
+            ))
 
         root = col_schema.encode(obj2, path='./col:collection', namespaces=self.col_nsmap)
         self.assertIsNone(etree_elements_assert_equal(self.col_xml_root, root, strict=False))

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/test_dataobjects.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_dataobjects.py Changed

@@ -12,13 +12,8 @@
 import xml.etree.ElementTree as ElementTree
 from pathlib import Path
 
-try:
-    import lxml.etree as lxml_etree
-except ImportError:
-    lxml_etree = None
-
-from xmlschema import XMLSchema, fetch_namespaces, etree_tostring, \
-    XMLSchemaValidationError, DataElement, DataElementConverter
+from xmlschema import XMLSchema10, XMLSchema11, fetch_namespaces, etree_tostring, \
+    XMLSchemaValidationError, DataElement, DataElementConverter, XMLResource
 
 from xmlschema.helpers import is_etree_element
 from xmlschema.dataobjects import DataBindingMeta, DataBindingConverter
@@ -43,6 +38,11 @@
         self.assertEqual(DataElement('foo', attrib=attrib).get('a'), 10)
         self.assertIsNone(DataElement('foo', attrib=attrib).get('c'))
 
+        data_element = DataElement('foo')
+        data_element.set('b', 9)
+        self.assertIsNone(data_element.get('a'))
+        self.assertEqual(data_element.get('b'), 9)
+
     def test_namespaces(self):
         self.assertEqual(DataElement('foo').nsmap, {})
         nsmap = {'tns': 'http://xmlschema.test/ns'}
@@ -57,6 +57,7 @@
 
 class TestDataObjects(unittest.TestCase):
 
+    schema_class = XMLSchema10
     converter = DataElementConverter
 
     @classmethod
@@ -64,10 +65,9 @@
         cls.col_xsd_filename = cls.casepath('examples/collection/collection.xsd')
         cls.col_xml_filename = cls.casepath('examples/collection/collection.xml')
         cls.col_xml_root = ElementTree.parse(cls.col_xml_filename).getroot()
-        cls.col_lxml_root = lxml_etree.parse(cls.col_xml_filename).getroot()
         cls.col_nsmap = fetch_namespaces(cls.col_xml_filename)
         cls.col_namespace = cls.col_nsmap'col'
-        cls.col_schema = XMLSchema(cls.col_xsd_filename, converter=cls.converter)
+        cls.col_schema = cls.schema_class(cls.col_xsd_filename, converter=cls.converter)
 
     @classmethod
     def casepath(cls, relative_path):
@@ -97,6 +97,42 @@
         self.assertEqual(col_data1.prefixed_name, 'object')
         self.assertEqual(col_data1.local_name, 'object')
 
+    def test_xsd_version(self):
+        self.assertEqual(DataElement(tag=self.col_xml_root.tag).xsd_version, '1.0')
+
+        xsd_element = self.col_schema.elements'person'
+        data_element = DataElement(tag=self.col_xml_root.tag, xsd_element=xsd_element)
+        self.assertEqual(data_element.xsd_version, self.col_schema.XSD_VERSION)
+
+    def test_xsd_element_binding(self):
+        xsd_element = self.col_schema.elements'person'
+        data_element = DataElement(tag=self.col_xml_root.tag, xsd_element=xsd_element)
+        data_element.xsd_element = xsd_element
+
+        with self.assertRaises(TypeError) as ec:
+            DataElement(tag=xsd_element.name, xsd_element=self.col_schema)
+        self.assertIn("invalid type for attribute 'xsd_element'", str(ec.exception))
+
+        with self.assertRaises(ValueError) as ec:
+            data_element.xsd_element = self.col_schema.elements'collection'
+        self.assertIn('the instance is already bound to another XSD element', str(ec.exception))
+
+    def test_xsd_type_binding(self):
+        xsd_type = self.col_schema.elements'person'.type
+        data_element = DataElement(tag=self.col_xml_root.tag, xsd_type=xsd_type)
+
+        with self.assertRaises(TypeError) as ec:
+            DataElement(tag=self.col_xml_root.tag, xsd_type=self.col_schema)
+        self.assertIn("invalid type for attribute 'xsd_type'", str(ec.exception))
+
+        with self.assertRaises(ValueError) as ec:
+            data_element.xsd_element = self.col_schema.elements'collection'
+        self.assertIn('the instance is already bound to another XSD type', str(ec.exception))
+
+        with self.assertRaises(ValueError) as ec:
+            data_element.xsd_type = self.col_schema.elements'collection'.type
+        self.assertIn('the instance is already bound to another XSD type', str(ec.exception))
+
     def test_mutable_mapping_api(self):
         data_element = DataElement('root')
 
@@ -167,6 +203,9 @@
         self.assertTrue(is_etree_element(obj))
         self.assertIsInstance(etree_tostring(obj), str)
         self.assertIsNone(etree_elements_assert_equal(obj, self.col_xml_root, strict=False))
+        self.assertIsNone(
+            etree_elements_assert_equal(obj, col_data.encode(converter=self.converter))
+        )
 
         with self.assertRaises(ValueError) as ec:
             col_data.xsd_type = col_data0.xsd_type
@@ -210,12 +249,34 @@
         self.assertTrue(xml_source.endswith('</col:collection>'))
 
     def test_validation(self):
+        with self.assertRaises(ValueError) as ec:
+            DataElement(self.col_xml_root).validate()
+        self.assertIn("has no schema bindings", str(ec.exception))
+
         col_data = self.col_schema.decode(self.col_xml_filename)
 
         self.assertIsNone(col_data.validate())
         self.assertTrue(col_data.is_valid())
         self.assertListEqual(list(col_data.iter_errors()), )
 
+        col_data = self.col_schema.decode(self.col_xml_root)
+        self.assertEqual(col_data.nsmap, {})
+        self.assertTrue(col_data.is_valid())
+
+        # FIXME: are namespaces really needed for validation of data elements???
+        #  (that use iter_encode() instead of iter_decode() ...)
+        self.assertTrue(col_data.is_valid(namespaces={
+            'col': 'http://example.com/ns/collection',
+            'xsi': 'http://www.w3.org/2001/XMLSchema-instance'
+        }))
+
+        # Encoding back using the default namespace is simple with
+        # data elements because you still have the original tags.
+        self.assertTrue(col_data.is_valid(namespaces={
+            '': 'http://example.com/ns/collection',
+            'xsi': 'http://www.w3.org/2001/XMLSchema-instance'
+        }))
+
     def test_invalid_value_type(self):
         col_data = self.col_schema.decode(self.col_xml_filename)
         self.assertTrue(col_data.is_valid())
@@ -266,12 +327,36 @@
         self.assertFalse(col_data.is_valid(max_depth=1))
         self.assertFalse(col_data.is_valid(max_depth=2))
 
+    def test_converter_class(self):
+        converter = self.converter()
+        self.assertFalse(converter.lossy)
+        self.assertTrue(converter.losslessly)
+
+        class MyDataElement(DataElement):
+            pass
+
+        col_data = self.col_schema.decode(self.col_xml_filename, converter=converter)
+        self.assertIsInstance(col_data, DataElement)
+        self.assertNotIsInstance(col_data, MyDataElement)
+
+        converter = self.converter(data_element_class=MyDataElement)
+        self.assertIs(converter.data_element_class, MyDataElement)
+        self.assertIs(converter.copy().data_element_class, MyDataElement)
+
+        self.col_schema.maps.clear_bindings()  # needed for DataBindingConverter ...
+        col_data = self.col_schema.decode(self.col_xml_filename, converter=converter)
+        self.assertIsInstance(col_data, MyDataElement)
+
+        with self.assertRaises(ValueError) as ec:
+            converter.element_encode(col_data, col_data0.xsd_element)
+        self.assertEqual("Unmatched tag", str(ec.exception))
+
 
 class TestDataBindings(TestDataObjects):
 
     converter = DataBindingConverter
 
-    def test_data_element_metaclass(self):
+    def test_data_binding_metaclass(self):
         xsd_element = self.col_schema.elements'collection'
         collection_class = DataBindingMeta(xsd_element.local_name.title(), (DataElement,),
                                            {'xsd_element': xsd_element})
@@ -279,7 +364,15 @@
         self.assertEqual(collection_class.__qualname__, 'Collection')
         self.assertIsNone(collection_class.__module__)
         self.assertEqual(collection_class.namespace, 'http://example.com/ns/collection')
-        self.assertEqual(collection_class.xsd_version, '1.0')
+        self.assertEqual(collection_class.xsd_version, self.col_schema.XSD_VERSION)
+
+        with self.assertRaises(AttributeError) as ec:
+            DataBindingMeta(xsd_element.local_name.title(), (DataElement,), {})
+        self.assertIn("attribute 'xsd_element' is required", str(ec.exception))
+
+        with self.assertRaises(TypeError) as ec:
+            DataBindingMeta(xsd_element.local_name.title(), (DataElement,), {'xsd_element': None})
+        self.assertIn("None is not an XSD element", str(ec.exception))
 
     def test_element_binding(self):
         xsd_element = self.col_schema.elements'collection'
@@ -298,7 +391,7 @@
             xsd_element.binding = None
 
     def test_schema_bindings(self):
-        schema = XMLSchema(self.col_xsd_filename)
+        schema = self.schema_class(self.col_xsd_filename)
         schema.maps.create_bindings()
 
         col_element_class = schema.elements'collection'.binding
@@ -314,6 +407,38 @@
             etree_elements_assert_equal(col_data.encode(), self.col_xml_root, strict=False)
         )
 
+        source = XMLResource(self.col_xml_filename, allow='local')
+        col_data2 = col_element_class.fromsource(source, converter=self.converter)
+
+        self.assertEqual(len(list(col_data.iter())), len(list(col_data2.iter())))
+        for data_element, data_element2 in zip(col_data.iter(), col_data2.iter()):
+            self.assertEqual(data_element.tag, data_element2.tag)
+
+    def test_binding_instance(self):
+        xsd_element = self.col_schema.elements'collection'
+        xsd_element.binding = None
+
+        try:
+            binding_class = xsd_element.get_binding()
+            collection_element = binding_class(tag=xsd_element.name)
+            collection_element._encoder = xsd_element
+
+            with self.assertRaises(ValueError) as ec:
+                binding_class(tag=xsd_element.name,
+                              xsd_element=self.col_schema.elements'person')
+            self.assertIn('already bound to another XSD element', str(ec.exception))
+
+        finally:
+            xsd_element.binding = None
+
+
+class TestDataObjects11(TestDataObjects):
+    schema_class = XMLSchema11
+
+
+class TestDataBindings11(TestDataBindings):
+    schema_class = XMLSchema11
+
 
 if __name__ == '__main__':
     import platform

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/test_documents.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_documents.py Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/test_etree.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_etree.py Changed

@@ -11,7 +11,11 @@
 import unittest
 import os
 import platform
-import lxml.etree
+
+try:
+    import lxml.etree as lxml_etree
+except ImportError:
+    lxml_etree = None
 
 from xmlschema.etree import ElementTree, PyElementTree, ParseError, \
     SafeXMLParser, etree_tostring
@@ -94,8 +98,9 @@
                                  '</root>')
         self.assertEqual(etree_tostring(root, method='text'), '\n  text1\n  text2')
 
+    @unittest.skipIf(lxml_etree is None, 'lxml is not installed ...')
     def test_lxml_element_string_serialization(self):
-        elem = lxml.etree.Element('element')
+        elem = lxml_etree.Element('element')
         self.assertEqual(etree_tostring(elem), '<element/>')
         self.assertEqual(etree_tostring(elem, xml_declaration=True), '<element/>')
 
@@ -119,7 +124,7 @@
         self.assertEqual(etree_tostring(elem, method='html'), '<element></element>')
         self.assertEqual(etree_tostring(elem, method='text'), '')
 
-        root = lxml.etree.XML('<root>\n'
+        root = lxml_etree.XML('<root>\n'
                               '  text1\n'
                               '  <elem>text2</elem>\n'
                               '</root>')
@@ -220,8 +225,9 @@
         self.assertIsNone(etree_elements_assert_equal(e1, e1))
         self.assertIsNone(etree_elements_assert_equal(e1, e2))
 
-        e2 = lxml.etree.XML('<a><b1>text<c1 a="1"/></b1>\n<b2/><b3/></a>\n')
-        self.assertIsNone(etree_elements_assert_equal(e1, e2))
+        if lxml_etree is not None:
+            e2 = lxml_etree.XML('<a><b1>text<c1 a="1"/></b1>\n<b2/><b3/></a>\n')
+            self.assertIsNone(etree_elements_assert_equal(e1, e2))
 
         e2 = ElementTree.XML('<a><b1>text<c1 a="1"/></b1>\n<b2/><b3/><b4/></a>\n')
         with self.assertRaises(AssertionError) as ctx:
@@ -263,8 +269,9 @@
         self.assertIsNone(etree_elements_assert_equal(e1, e2))
         self.assertIsNone(etree_elements_assert_equal(e1, e2, skip_comments=False))
 
-        e2 = lxml.etree.XML('<a><b1>text<c1 a="1"/></b1>\n<b2/><b3/></a>\n')
-        self.assertIsNone(etree_elements_assert_equal(e1, e2))
+        if lxml_etree is not None:
+            e2 = lxml_etree.XML('<a><b1>text<c1 a="1"/></b1>\n<b2/><b3/></a>\n')
+            self.assertIsNone(etree_elements_assert_equal(e1, e2))
 
         e1 = ElementTree.XML('<a><b1>+1</b1></a>')
         e2 = ElementTree.XML('<a><b1>+ 1 </b1></a>')

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/test_helpers.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_helpers.py Changed

@@ -28,7 +28,7 @@
     base64_binary_validator, hex_binary_validator, \
     int_validator, long_validator, unsigned_byte_validator, \
     unsigned_short_validator, negative_int_validator, error_type_validator
-from xmlschema.validators.models import OccursCounter
+from xmlschema.validators.particles import OccursCalculator
 
 
 class TestHelpers(unittest.TestCase):
@@ -46,13 +46,20 @@
             'a1': 'extension', 'a2': ' restriction', 'a3': '#all', 'a4': 'other',
             'a5': 'restriction extension restriction ', 'a6': 'other restriction'
         })
-        values = ('extension', 'restriction')
+        values = {'extension', 'restriction'}
         self.assertEqual(get_xsd_derivation_attribute(elem, 'a1', values), 'extension')
         self.assertEqual(get_xsd_derivation_attribute(elem, 'a2', values), ' restriction')
-        self.assertEqual(get_xsd_derivation_attribute(elem, 'a3', values), 'extension restriction')
+
+        result = get_xsd_derivation_attribute(elem, 'a3', values)
+        self.assertSetEqual(set(result.strip().split()),
+                            set('extension restriction'.split()))
+
         self.assertRaises(ValueError, get_xsd_derivation_attribute, elem, 'a4', values)
-        self.assertEqual(get_xsd_derivation_attribute(elem, 'a5', values),
-                         'restriction extension restriction ')
+
+        result = get_xsd_derivation_attribute(elem, 'a5', values)
+        self.assertEqual(set(result.strip().split()),
+                         set('restriction extension restriction'.split()))
+
         self.assertRaises(ValueError, get_xsd_derivation_attribute, elem, 'a6', values)
         self.assertEqual(get_xsd_derivation_attribute(elem, 'a7', values), '')
 
@@ -139,42 +146,42 @@
         with self.assertRaises(TypeError):
             list(iter_nested_items(10, 20, list_class=tuple))
 
-    def test_occurs_counter_class(self):
-        counter = OccursCounter()
-        self.assertEqual(repr(counter), 'OccursCounter(0, 0)')
+    def test_occurs_calculator_class(self):
+        counter = OccursCalculator()
+        self.assertEqual(repr(counter), 'OccursCalculator(0, 0)')
 
-        other = OccursCounter()  # Only for test isolation, usually it's a particle.
+        other = OccursCalculator()  # Only for test isolation, usually it's a particle.
         other.min_occurs = 5
         other.max_occurs = 10
 
         counter += other
-        self.assertEqual(repr(counter), 'OccursCounter(5, 10)')
+        self.assertEqual(repr(counter), 'OccursCalculator(5, 10)')
         counter *= other
-        self.assertEqual(repr(counter), 'OccursCounter(25, 100)')
+        self.assertEqual(repr(counter), 'OccursCalculator(25, 100)')
 
-        counter = OccursCounter()
+        counter = OccursCalculator()
         counter.max_occurs = None
-        self.assertEqual(repr(counter), 'OccursCounter(0, None)')
-        self.assertEqual(repr(counter * other), 'OccursCounter(0, None)')
-        self.assertEqual(repr(counter + other), 'OccursCounter(5, None)')
-        self.assertEqual(repr(counter * other), 'OccursCounter(25, None)')
+        self.assertEqual(repr(counter), 'OccursCalculator(0, None)')
+        self.assertEqual(repr(counter * other), 'OccursCalculator(0, None)')
+        self.assertEqual(repr(counter + other), 'OccursCalculator(5, None)')
+        self.assertEqual(repr(counter * other), 'OccursCalculator(25, None)')
 
         counter.reset()
-        self.assertEqual(repr(counter), 'OccursCounter(0, 0)')
+        self.assertEqual(repr(counter), 'OccursCalculator(0, 0)')
 
         counter.max_occurs = None
         other.min_occurs = other.max_occurs = 0
-        self.assertEqual(repr(counter * other), 'OccursCounter(0, 0)')
+        self.assertEqual(repr(counter * other), 'OccursCalculator(0, 0)')
 
         counter.reset()
         other.min_occurs = 0
         other.max_occurs = None
-        self.assertEqual(repr(counter * other), 'OccursCounter(0, 0)')
-        self.assertEqual(repr(counter + other), 'OccursCounter(0, None)')
-        self.assertEqual(repr(counter + other), 'OccursCounter(0, None)')
+        self.assertEqual(repr(counter * other), 'OccursCalculator(0, 0)')
+        self.assertEqual(repr(counter + other), 'OccursCalculator(0, None)')
+        self.assertEqual(repr(counter + other), 'OccursCalculator(0, None)')
 
         counter.max_occurs = 1
-        self.assertEqual(repr(counter * other), 'OccursCounter(0, None)')
+        self.assertEqual(repr(counter * other), 'OccursCalculator(0, None)')
 
     def test_get_namespace(self):
         self.assertEqual(get_namespace(''), '')
@@ -211,8 +218,8 @@
         self.assertEqual(local_name(XSD_SCHEMA), 'schema')
         self.assertEqual(local_name('schema'), 'schema')
         self.assertEqual(local_name(''), '')
-        self.assertEqual(local_name(None), None)
 
+        self.assertRaises(TypeError, local_name, None)
         self.assertRaises(ValueError, local_name, '{ns name')
         self.assertRaises(TypeError, local_name, 1.0)
         self.assertRaises(TypeError, local_name, 0)
@@ -228,7 +235,7 @@
 
         self.assertEqual(get_prefixed_qname('', namespaces), '')
         self.assertEqual(get_prefixed_qname(None, namespaces), None)
-        # self.assertEqual(get_prefixed_qname(0, namespaces), 0)
+        self.assertEqual(get_prefixed_qname('{uri}element', namespaces), '{uri}element')
 
         self.assertEqual(get_prefixed_qname(XSI_TYPE, {}), XSI_TYPE)
         self.assertEqual(get_prefixed_qname(None, {}), None)

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/test_memory.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_memory.py Changed

@@ -11,8 +11,10 @@
 import unittest
 import os
 import decimal
+import pathlib
 import subprocess
 import sys
+import tempfile
 
 try:
     import memory_profiler
@@ -69,44 +71,62 @@
         lazy_iterparse_mem = self.check_memory_profile(output)
 
         self.assertLess(parse_mem, 2)
-        self.assertLessEqual(lazy_iterparse_mem, parse_mem / decimal.Decimal('1.75'))
-        self.assertLessEqual(lazy_iterparse_mem, iterparse_mem)
+        self.assertLess(lazy_iterparse_mem, parse_mem)
+        self.assertLess(lazy_iterparse_mem, iterparse_mem)
 
     def test_decode_memory_usage(self):
-        test_dir = os.path.dirname(__file__) or '.'
-        xsd10_schema_file = os.path.join(
-            os.path.dirname(os.path.abspath(test_dir)),
-            'xmlschema/schemas/XSD_1.0/XMLSchema.xsd'
-        )
-
-        cmd = sys.executable, os.path.join(test_dir, 'check_memory.py'), '5', xsd10_schema_file
-        output = subprocess.check_output(cmd, universal_newlines=True)
-        decode_mem = self.check_memory_profile(output)
-
-        cmd = sys.executable, os.path.join(test_dir, 'check_memory.py'), '6', xsd10_schema_file
-        output = subprocess.check_output(cmd, universal_newlines=True)
-        lazy_decode_mem = self.check_memory_profile(output)
-
-        self.assertLess(decode_mem, 2.6)
-        self.assertLessEqual(lazy_decode_mem, decode_mem / decimal.Decimal('1.1'))
+        with tempfile.TemporaryDirectory() as dirname:
+            python_script = pathlib.Path(__file__).parent.joinpath('check_memory.py')
+            xsd_file = pathlib.Path(__file__).parent.absolute().joinpath(
+                'test_cases/features/decoder/long-sequence-1.xsd'
+            )
+            xml_file = pathlib.Path(dirname).joinpath('data.xml')
+
+            with xml_file.open('w') as fp:
+                fp.write('<data ')
+                fp.write('xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ')
+                fp.write(f'xsi:noNamespaceSchemaLocation="{xsd_file.as_uri()}">\n')
+                for k in range(1000):
+                    fp.write('<chunk><a><b1/><b2/><b3/></a></chunk>\n')
+                fp.write('</data>\n')
+
+            cmd = sys.executable, python_script, '5', str(xml_file)
+            output = subprocess.check_output(cmd, universal_newlines=True)
+            decode_mem = self.check_memory_profile(output)
+
+            cmd = sys.executable, python_script, '6', str(xml_file)
+            output = subprocess.check_output(cmd, universal_newlines=True)
+            lazy_decode_mem = self.check_memory_profile(output)
+
+        self.assertLessEqual(decode_mem, 2.6)
+        self.assertLessEqual(lazy_decode_mem, 1.8)
 
     def test_validate_memory_usage(self):
-        test_dir = os.path.dirname(__file__) or '.'
-        xsd10_schema_file = os.path.join(
-            os.path.dirname(os.path.abspath(test_dir)),
-            'xmlschema/schemas/XSD_1.0/XMLSchema.xsd'
-        )
-
-        cmd = sys.executable, os.path.join(test_dir, 'check_memory.py'), '7', xsd10_schema_file
-        output = subprocess.check_output(cmd, universal_newlines=True)
-        validate_mem = self.check_memory_profile(output)
-
-        cmd = sys.executable, os.path.join(test_dir, 'check_memory.py'), '8', xsd10_schema_file
-        output = subprocess.check_output(cmd, universal_newlines=True)
-        lazy_validate_mem = self.check_memory_profile(output)
-
-        self.assertLess(validate_mem, 2.6)
-        self.assertLessEqual(lazy_validate_mem, validate_mem / decimal.Decimal('1.1'))
+        with tempfile.TemporaryDirectory() as dirname:
+            python_script = pathlib.Path(__file__).parent.joinpath('check_memory.py')
+            xsd_file = pathlib.Path(__file__).parent.absolute().joinpath(
+                'test_cases/features/decoder/long-sequence-1.xsd'
+            )
+            xml_file = pathlib.Path(dirname).joinpath('data.xml')
+
+            with xml_file.open('w') as fp:
+                fp.write('<data ')
+                fp.write('xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ')
+                fp.write(f'xsi:noNamespaceSchemaLocation="{xsd_file.as_uri()}">\n')
+                for k in range(1000):
+                    fp.write('<chunk><a><b1/><b2/><b3/></a></chunk>\n')
+                fp.write('</data>\n')
+
+            cmd = sys.executable, python_script, '7', str(xml_file)
+            output = subprocess.check_output(cmd, universal_newlines=True)
+            validate_mem = self.check_memory_profile(output)
+
+            cmd = sys.executable, python_script, '8', str(xml_file)
+            output = subprocess.check_output(cmd, universal_newlines=True)
+            lazy_validate_mem = self.check_memory_profile(output)
+
+            self.assertLess(validate_mem, 2.6)
+            self.assertLess(lazy_validate_mem, 1.8)
 
 
 if __name__ == '__main__':

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/test_namespaces.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_namespaces.py Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/test_package.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_package.py Changed

@@ -16,6 +16,7 @@
 import os
 import re
 import importlib
+import pathlib
 
 
 class TestPackaging(unittest.TestCase):
@@ -30,12 +31,10 @@
         )
         cls.get_version = re.compile(r"(?:\brelease|__version__)(?:\s*=\s*)(\'^\'*\'|\"^\"*\")")
 
-    def test_missing_debug_statements(self):
+    def test_forgotten_debug_statements(self):
         # Exclude explicit debug statements written in the code
         exclude = {
-            'regex.py': 240, 241,
-            'codepoints.py': 534,
-            'cli.py': 117, 133, 137, 140,
+            'cli.py': 'print(',
         }
 
         message = "\nFound a debug missing statement at line %d or file %r: %r"
@@ -53,7 +52,7 @@
                 continue
 
             match = self.missing_debug.search(line)
-            if match is None or filename.endswith('/cli.py') and match.group(0) == 'print(':
+            if match is None or match.group(0) in file_excluded:
                 continue
             self.assertIsNone(match, message % (lineno, filename, match.group(0)))
 
@@ -82,6 +81,19 @@
                         message % (lineno, filename, match.group(1).strip('\'\"'), version)
                     )
 
+    def test_elementpath_requirement(self):
+        package_dir = pathlib.Path(__file__).parent.parent
+        ep_requirement = None
+        for line in fileinput.input(str(package_dir.joinpath('requirements-dev.txt'))):
+            if 'elementpath' in line:
+                ep_requirement = line.strip()
+
+        self.assertIsNotNone(ep_requirement, msg="Missing elementpath in requirements-dev.txt")
+
+        for line in fileinput.input(str(package_dir.joinpath('setup.py'))):
+            if 'elementpath' in line:
+                self.assertIn(ep_requirement, line, msg="Unmatched requirement in setup.py")
+
     def test_base_schema_files(self):
         et = importlib.import_module('xml.etree.ElementTree')
         schemas_dir = os.path.join(self.source_dir, 'schemas')

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/test_resources.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_resources.py Changed

@@ -12,13 +12,15 @@
 
 import unittest
 import os
+import pathlib
 import platform
 import warnings
 from io import StringIO, BytesIO
 from urllib.error import URLError
 from urllib.request import urlopen
 from urllib.parse import urlsplit, uses_relative
-from pathlib import Path, PureWindowsPath, PurePath
+from pathlib import Path, PurePath, PureWindowsPath, PurePosixPath
+from unittest.mock import patch, MagicMock
 
 try:
     import lxml.etree as lxml_etree
@@ -29,16 +31,19 @@
     fetch_schema, fetch_schema_locations, XMLResource, XMLResourceError, XMLSchema
 from xmlschema.etree import ElementTree, etree_element, py_etree_element, is_etree_element
 from xmlschema.names import XSD_NAMESPACE
+import xmlschema.resources
 from xmlschema.resources import is_url, is_local_url, is_remote_url, \
     url_path_is_file, normalize_locations, LazySelector
 from xmlschema.testing import SKIP_REMOTE_TESTS
 
 
-TEST_CASES_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'test_cases/')
+TEST_CASES_DIR = str(pathlib.Path(__file__).absolute().parent.joinpath('test_cases'))
+
+DRIVE_REGEX = '/a-zA-Z:' if platform.system() == 'Windows' else ''
 
 
 def casepath(relative_path):
-    return os.path.join(TEST_CASES_DIR, relative_path)
+    return str(pathlib.Path(TEST_CASES_DIR).joinpath(relative_path))
 
 
 def is_windows_path(path):
@@ -95,6 +100,46 @@
             expected_path = PurePath(expected_parts.path)
         self.assertEqual(path, expected_path, "%r: Paths differ." % url)
 
+    def test_path_from_uri(self):
+        _PurePath = xmlschema.resources._PurePath
+        _PosixPurePath = xmlschema.resources._PurePosixPath
+        _WindowsPurePath = xmlschema.resources._PureWindowsPath
+
+        with self.assertRaises(ValueError) as ec:
+            _PurePath.from_uri('')
+        self.assertEqual(str(ec.exception), 'Empty URI provided!')
+
+        path = _PurePath.from_uri('https://example.com/names/?name=foo')
+        self.assertIsInstance(path, _PosixPurePath)
+        self.assertEqual(str(path), '/names')
+
+        path = _PosixPurePath.from_uri('file:///home/foo/names/?name=foo')
+        self.assertIsInstance(path, _PosixPurePath)
+        self.assertEqual(str(path), '/home/foo/names')
+
+        path = _PosixPurePath.from_uri('file:///home/foo/names#foo')
+        self.assertIsInstance(path, _PosixPurePath)
+        self.assertEqual(str(path), '/home/foo/names')
+
+        path = _PosixPurePath.from_uri('file:///home\\foo\\names#foo')
+        self.assertIsInstance(path, _WindowsPurePath)
+        self.assertTrue(path.as_posix().endswith('/home/foo/names'))
+
+        path = _PosixPurePath.from_uri('file:///c:/home/foo/names/')
+        self.assertIsInstance(path, _WindowsPurePath)
+        self.assertEqual(str(path), r'c:\home\foo\names')
+        self.assertEqual(path.as_uri(), 'file:///c:/home/foo/names')
+
+        path = _PosixPurePath.from_uri('file:c:/home/foo/names/')
+        self.assertIsInstance(path, _WindowsPurePath)
+        self.assertEqual(str(path), r'c:\home\foo\names')
+        self.assertEqual(path.as_uri(), 'file:///c:/home/foo/names')
+
+        with self.assertRaises(ValueError) as ec:
+            _PurePath.from_uri('file://c:/home/foo/names/')
+        self.assertEqual(str(ec.exception), "Invalid URI 'file://c:/home/foo/names/'")
+
+    @unittest.skipIf(platform.system() == 'Windows', "Run only on posix systems")
     def test_normalize_url_posix(self):
         url1 = "https://example.com/xsd/other_schema.xsd"
         self.check_url(normalize_url(url1, base_url="/path_my_schema/schema.xsd"), url1)
@@ -112,19 +157,20 @@
         cwd = os.getcwd()
         cwd_url = 'file://{}/'.format(cwd) if cwd.startswith('/') else 'file:///{}/'.format(cwd)
 
+        self.check_url(normalize_url('other.xsd', keep_relative=True), 'file:other.xsd')
         self.check_url(normalize_url('file:other.xsd', keep_relative=True), 'file:other.xsd')
         self.check_url(normalize_url('file:other.xsd'), cwd_url + 'other.xsd')
-        self.check_url(normalize_url('file:other.xsd', 'http://site/base', True), 'file:other.xsd')
+        self.check_url(normalize_url('file:other.xsd', 'https://site/base', True), 'file:other.xsd')
         self.check_url(normalize_url('file:other.xsd', 'http://site/base'), cwd_url + 'other.xsd')
 
-        self.check_url(normalize_url('dummy path.xsd'), cwd_url + 'dummy path.xsd')
+        self.check_url(normalize_url('dummy path.xsd'), cwd_url + 'dummy%20path.xsd')
         self.check_url(normalize_url('dummy path.xsd', 'http://site/base'),
                        'http://site/base/dummy%20path.xsd')
         self.check_url(normalize_url('dummy path.xsd', 'file://host/home/'),
-                       'file://host/home/dummy path.xsd')
+                       PurePath('//host/home/dummy path.xsd').as_uri())
 
-        url = "file://c:/Downloads/file.xsd"
-        self.check_url(normalize_url(url, base_url="file://d:/Temp/"), url)
+        url = "file:///c:/Downloads/file.xsd"
+        self.check_url(normalize_url(url, base_url="file:///d:/Temp/"), url)
 
     def test_normalize_url_windows(self):
         win_abs_path1 = 'z:\\Dir_1_0\\Dir2-0\\schemas/XSD_1.0/XMLSchema.xsd'
@@ -132,90 +178,217 @@
         self.check_url(normalize_url(win_abs_path1), win_abs_path1)
 
         self.check_url(normalize_url('k:\\Dir3\\schema.xsd', win_abs_path1),
-                       'file:///k:\\Dir3\\schema.xsd')
+                       'file:///k:/Dir3/schema.xsd')
         self.check_url(normalize_url('k:\\Dir3\\schema.xsd', win_abs_path2),
-                       'file:///k:\\Dir3\\schema.xsd')
+                       'file:///k:/Dir3/schema.xsd')
+
         self.check_url(normalize_url('schema.xsd', win_abs_path2),
-                       'file:///z:\\Dir-1.0\\Dir-2_0/schema.xsd')
+                       'file:///z:/Dir-1.0/Dir-2_0/schema.xsd')
         self.check_url(normalize_url('xsd1.0/schema.xsd', win_abs_path2),
-                       'file:///z:\\Dir-1.0\\Dir-2_0/xsd1.0/schema.xsd')
-        self.check_url(normalize_url('file:///\\k:\\Dir A\\schema.xsd'),
-                       'file:///k:\\Dir A\\schema.xsd')
+                       'file:///z:/Dir-1.0/Dir-2_0/xsd1.0/schema.xsd')
+
+        with self.assertRaises(ValueError) as ec:
+            normalize_url('file:///\\k:\\Dir A\\schema.xsd')
+        self.assertIn("Invalid URI", str(ec.exception))
+
+    def test_normalize_url_unc_paths__issue_246(self):
+        url = PureWindowsPath(r'\\host\share\file.xsd').as_uri()
+        self.assertNotEqual(normalize_url(r'\\host\share\file.xsd'), url)  # file://host/share/file.xsd
+        self.assertEqual(normalize_url(r'\\host\share\file.xsd'), url.replace('file://', 'file:////'))
+
+    def test_normalize_url_unc_paths__issue_268(self,):
+        unc_path = r'\\filer01\MY_HOME\dev\XMLSCHEMA\test.xsd'
+        url = PureWindowsPath(unc_path).as_uri()
+        self.assertEqual(str(PureWindowsPath(unc_path)), unc_path)
+        self.assertEqual(url, 'file://filer01/MY_HOME/dev/XMLSCHEMA/test.xsd')
+
+        # Same UNC path as URI with the host inserted in path path.
+        url_host_in_path = url.replace('file://', 'file:////')
+        self.assertEqual(url_host_in_path, 'file:////filer01/MY_HOME/dev/XMLSCHEMA/test.xsd')
+
+        self.assertEqual(normalize_url(unc_path), url_host_in_path)
+
+        with patch.object(os, 'name', 'nt'):
+            self.assertEqual(os.name, 'nt')
+            path = PurePath(unc_path)
+            self.assertIs(path.__class__, PureWindowsPath)
+            self.assertEqual(path.as_uri(), url)
+
+            self.assertEqual(xmlschema.resources.os.name, 'nt')
+            path = xmlschema.resources._PurePath(unc_path)
+            self.assertIs(path.__class__, xmlschema.resources._PureWindowsPath)
+            self.assertEqual(path.as_uri(), url_host_in_path)
+            self.assertEqual(normalize_url(unc_path), url_host_in_path)
+
+        with patch.object(os, 'name', 'posix'):
+            self.assertEqual(os.name, 'posix')
+            path = PurePath(unc_path)
+            self.assertIs(path.__class__, PurePosixPath)
+            self.assertEqual(str(path), unc_path)
+            self.assertRaises(ValueError, path.as_uri)  # Not recognized as UNC path
+
+            self.assertEqual(xmlschema.resources.os.name, 'posix')
+            path = xmlschema.resources._PurePath(unc_path)
+            self.assertIs(path.__class__, xmlschema.resources._PurePosixPath)
+            self.assertEqual(str(path), unc_path)
+            self.assertNotEqual(path.as_uri(), url)
+            self.assertEqual(normalize_url(unc_path), url_host_in_path)
+
+    def test_normalize_url_with_base_unc_path(self,):
+        base_unc_path = '\\\\filer01\\MY_HOME\\'
+        base_url = PureWindowsPath(base_unc_path).as_uri()
+        self.assertEqual(str(PureWindowsPath(base_unc_path)), base_unc_path)
+        self.assertEqual(base_url, 'file://filer01/MY_HOME/')
+
+        # Same UNC path as URI with the host inserted in path path.
+        base_url_host_in_path = base_url.replace('file://', 'file:////')
+        self.assertEqual(base_url_host_in_path, 'file:////filer01/MY_HOME/')
+
+        self.assertEqual(normalize_url(base_unc_path), base_url_host_in_path)
+
+        with patch.object(os, 'name', 'nt'):
+            self.assertEqual(os.name, 'nt')
+            path = PurePath('dir/file')
+            self.assertIs(path.__class__, PureWindowsPath)
+
+            url = normalize_url(r'dev\XMLSCHEMA\test.xsd', base_url=base_unc_path)
+            self.assertEqual(url, 'file:////filer01/MY_HOME/dev/XMLSCHEMA/test.xsd')
+
+            url = normalize_url(r'dev\XMLSCHEMA\test.xsd', base_url=base_url)
+            self.assertEqual(url, 'file:////filer01/MY_HOME/dev/XMLSCHEMA/test.xsd')
+
+            url = normalize_url(r'dev\XMLSCHEMA\test.xsd', base_url=base_url_host_in_path)
+            self.assertEqual(url, 'file:////filer01/MY_HOME/dev/XMLSCHEMA/test.xsd')
+
+        with patch.object(os, 'name', 'posix'):
+            self.assertEqual(os.name, 'posix')
+            path = PurePath('dir/file')
+            self.assertIs(path.__class__, PurePosixPath)
+
+            url = normalize_url(r'dev\XMLSCHEMA\test.xsd', base_url=base_unc_path)
+            self.assertEqual(url, 'file:////filer01/MY_HOME/dev/XMLSCHEMA/test.xsd')
+
+            url = normalize_url(r'dev/XMLSCHEMA/test.xsd', base_url=base_url)
+            self.assertEqual(url, 'file:////filer01/MY_HOME/dev/XMLSCHEMA/test.xsd')
+
+            url = normalize_url(r'dev/XMLSCHEMA/test.xsd', base_url=base_url_host_in_path)
+            self.assertEqual(url, 'file:////filer01/MY_HOME/dev/XMLSCHEMA/test.xsd')
 
     def test_normalize_url_slashes(self):
         # Issue #116
-        self.assertEqual(
-            normalize_url('//anaconda/envs/testenv/lib/python3.6/'
-                          'site-packages/xmlschema/validators/schemas/'),
-            'file:///anaconda/envs/testenv/lib/python3.6/'
-            'site-packages/xmlschema/validators/schemas/'
-        )
-        self.assertEqual(normalize_url('/root/dir1/schema.xsd'), 'file:///root/dir1/schema.xsd')
-        self.assertEqual(normalize_url('//root/dir1/schema.xsd'), 'file:///root/dir1/schema.xsd')
-        self.assertEqual(normalize_url('////root/dir1/schema.xsd'), 'file:///root/dir1/schema.xsd')
+        url = '//anaconda/envs/testenv/lib/python3.6/site-packages/xmlschema/validators/schemas/'
+        if os.name == 'posix':
+            self.assertEqual(normalize_url(url), pathlib.PurePath(url).as_uri())
+        else:
+            # On Windows // is interpreted as a network share UNC path
+            self.assertEqual(os.name, 'nt')
+            self.assertEqual(normalize_url(url),
+                             pathlib.PurePath(url).as_uri().replace('file://', 'file:////'))
 
+        self.assertRegex(normalize_url('/root/dir1/schema.xsd'),
+                         f'file://{DRIVE_REGEX}/root/dir1/schema.xsd')
+
+        self.assertRegex(normalize_url('////root/dir1/schema.xsd'),
+                         f'file://{DRIVE_REGEX}/root/dir1/schema.xsd')
+        self.assertRegex(normalize_url('dir2/schema.xsd', '////root/dir1'),
+                         f'file://{DRIVE_REGEX}/root/dir1/dir2/schema.xsd')
+
+        self.assertEqual(normalize_url('//root/dir1/schema.xsd'),
+                         'file:////root/dir1/schema.xsd')
         self.assertEqual(normalize_url('dir2/schema.xsd', '//root/dir1/'),
-                         'file:///root/dir1/dir2/schema.xsd')
+                         f'file:////root/dir1/dir2/schema.xsd')
         self.assertEqual(normalize_url('dir2/schema.xsd', '//root/dir1'),
-                         'file:///root/dir1/dir2/schema.xsd')
-        self.assertEqual(normalize_url('dir2/schema.xsd', '////root/dir1'),
-                         'file:///root/dir1/dir2/schema.xsd')
+                         f'file:////root/dir1/dir2/schema.xsd')
 
     def test_normalize_url_hash_character(self):
-        self.check_url(normalize_url('issue #000.xml', 'file:///dir1/dir2/'),
-                       'file:///dir1/dir2/issue %23000.xml')
-        self.check_url(normalize_url('data.xml', 'file:///dir1/dir2/issue 000'),
-                       'file:///dir1/dir2/issue 000/data.xml')
-        self.check_url(normalize_url('data.xml', '/dir1/dir2/issue #000'),
-                       '/dir1/dir2/issue %23000/data.xml')
+        url = normalize_url('issue #000.xml', 'file:///dir1/dir2/')
+        self.assertRegex(url, f'file://{DRIVE_REGEX}/dir1/dir2/issue%20%23000.xml')
+
+        url = normalize_url('data.xml', 'file:///dir1/dir2/issue%20001')
+        self.assertRegex(url, f'file://{DRIVE_REGEX}/dir1/dir2/issue%20001/data.xml')
+
+        url = normalize_url('data.xml', '/dir1/dir2/issue #002')
+        self.assertRegex(url, f'{DRIVE_REGEX}/dir1/dir2/issue%20%23002/data.xml')
 
     def test_is_url_function(self):
         self.assertTrue(is_url(self.col_xsd_file))
         self.assertFalse(is_url('http://example.com'))
+        self.assertTrue(is_url(b'http://example.com'))
         self.assertFalse(is_url(' \t<root/>'))
+        self.assertFalse(is_url(b'  <root/>'))
         self.assertFalse(is_url('line1\nline2'))
         self.assertFalse(is_url(None))
 
     def test_is_local_url_function(self):
         self.assertTrue(is_local_url(self.col_xsd_file))
+        self.assertTrue(is_local_url(Path(self.col_xsd_file)))
+
         self.assertTrue(is_local_url('/home/user/'))
+        self.assertFalse(is_local_url('<home/>'))
         self.assertTrue(is_local_url('/home/user/schema.xsd'))
         self.assertTrue(is_local_url('  /home/user/schema.xsd  '))
         self.assertTrue(is_local_url('C:\\Users\\foo\\schema.xsd'))
         self.assertTrue(is_local_url(' file:///home/user/schema.xsd'))
         self.assertFalse(is_local_url('http://example.com/schema.xsd'))
 
+        self.assertTrue(is_local_url(b'/home/user/'))
+        self.assertFalse(is_local_url(b'<home/>'))
+        self.assertTrue(is_local_url(b'/home/user/schema.xsd'))
+        self.assertTrue(is_local_url(b'  /home/user/schema.xsd  '))
+        self.assertTrue(is_local_url(b'C:\\Users\\foo\\schema.xsd'))
+        self.assertTrue(is_local_url(b' file:///home/user/schema.xsd'))
+        self.assertFalse(is_local_url(b'http://example.com/schema.xsd'))
+
     def test_is_remote_url_function(self):
         self.assertFalse(is_remote_url(self.col_xsd_file))
+
         self.assertFalse(is_remote_url('/home/user/'))
+        self.assertFalse(is_remote_url('<home/>'))
         self.assertFalse(is_remote_url('/home/user/schema.xsd'))
         self.assertFalse(is_remote_url(' file:///home/user/schema.xsd'))
         self.assertTrue(is_remote_url('  http://example.com/schema.xsd'))
 
+        self.assertFalse(is_remote_url(b'/home/user/'))
+        self.assertFalse(is_remote_url(b'<home/>'))
+        self.assertFalse(is_remote_url(b'/home/user/schema.xsd'))
+        self.assertFalse(is_remote_url(b' file:///home/user/schema.xsd'))
+        self.assertTrue(is_remote_url(b'  http://example.com/schema.xsd'))
+
     def test_url_path_is_file_function(self):
         self.assertTrue(url_path_is_file(self.col_xml_file))
+        self.assertTrue(url_path_is_file(normalize_url(self.col_xml_file)))
         self.assertFalse(url_path_is_file(self.col_dir))
         self.assertFalse(url_path_is_file('http://example.com/'))
 
+        with patch('platform.system', MagicMock(return_value="Windows")):
+            self.assertFalse(url_path_is_file('file:///c:/Windows/unknown'))
+
     def test_normalize_locations_function(self):
         locations = normalize_locations(
             ('tns0', 'alpha'), ('tns1', 'http://example.com/beta'), base_url='/home/user'
         )
-        self.assertListEqual(locations, ('tns0', 'file:///home/user/alpha'),
-                                         ('tns1', 'http://example.com/beta'))
+        self.assertEqual(locations00, 'tns0')
+        self.assertRegex(locations01, f'file://{DRIVE_REGEX}/home/user/alpha')
+        self.assertEqual(locations10, 'tns1')
+        self.assertEqual(locations11, 'http://example.com/beta')
 
         locations = normalize_locations(
             {'tns0': 'alpha', 'tns1': 'http://example.com/beta'}, base_url='/home/user'
         )
-        self.assertListEqual(locations, ('tns0', 'file:///home/user/alpha'),
-                                         ('tns1', 'http://example.com/beta'))
+        self.assertEqual(locations00, 'tns0')
+        self.assertRegex(locations01, f'file://{DRIVE_REGEX}/home/user/alpha')
+        self.assertEqual(locations10, 'tns1')
+        self.assertEqual(locations11, 'http://example.com/beta')
 
         locations = normalize_locations(
             {'tns0': 'alpha', 'beta', 'tns1': 'http://example.com/beta'}, base_url='/home/user'
         )
-        self.assertListEqual(locations, ('tns0', 'file:///home/user/alpha'),
-                                         ('tns0', 'file:///home/user/beta'),
-                                         ('tns1', 'http://example.com/beta'))
+        self.assertEqual(locations00, 'tns0')
+        self.assertRegex(locations01, f'file://{DRIVE_REGEX}/home/user/alpha')
+        self.assertEqual(locations10, 'tns0')
+        self.assertRegex(locations11, f'file://{DRIVE_REGEX}/home/user/beta')
+        self.assertEqual(locations20, 'tns1')
+        self.assertEqual(locations21, 'http://example.com/beta')
 
         locations = normalize_locations(
             {'tns0': 'alpha', 'tns1': 'http://example.com/beta'}, keep_relative=True
@@ -235,16 +408,16 @@
         self.assertRaises(XMLResourceError, fetch_resource, wrong_path)
 
         right_path = casepath('resources/dummy file.txt')
-        self.assertTrue(fetch_resource(right_path).endswith('dummy file.txt'))
+        self.assertTrue(fetch_resource(right_path).endswith('dummy%20file.txt'))
 
         right_path = Path(casepath('resources/dummy file.txt')).relative_to(os.getcwd())
-        self.assertTrue(fetch_resource(str(right_path), '/home').endswith('dummy file.txt'))
+        self.assertTrue(fetch_resource(str(right_path), '/home').endswith('dummy%20file.txt'))
 
         with self.assertRaises(XMLResourceError):
             fetch_resource(str(right_path.parent.joinpath('dummy_file.txt')), '/home')
 
         ambiguous_path = casepath('resources/dummy file #2.txt')
-        self.assertTrue(fetch_resource(ambiguous_path).endswith('dummy file %232.txt'))
+        self.assertTrue(fetch_resource(ambiguous_path).endswith('dummy%20file%20%232.txt'))
 
         with urlopen(fetch_resource(ambiguous_path)) as res:
             self.assertEqual(res.read(), b'DUMMY CONTENT')
@@ -275,6 +448,7 @@
         self.assertEqual(resource.source, self.vh_xml_file)
         self.assertEqual(resource.root.tag, '{http://example.com/vehicles}vehicles')
         self.check_url(resource.url, self.vh_xml_file)
+        self.assertTrue(resource.filepath.endswith('vehicles.xml'))
         self.assertIsNone(resource.text)
         with self.assertRaises(XMLResourceError) as ctx:
             resource.load()
@@ -294,6 +468,42 @@
         with self.assertRaises(XMLResourceError):
             resource.load()
 
+    def test_xml_resource_from_url_in_bytes(self):
+        resource = XMLResource(self.vh_xml_file.encode('utf-8'), lazy=False)
+        self.assertEqual(resource.source, self.vh_xml_file.encode('utf-8'))
+        self.assertEqual(resource.root.tag, '{http://example.com/vehicles}vehicles')
+        self.check_url(resource.url, self.vh_xml_file)
+        self.assertIsNone(resource.text)
+        resource.load()
+        self.assertTrue(resource.text.startswith('<?xml'))
+
+    def test_xml_resource_from_path(self):
+        path = Path(self.vh_xml_file)
+
+        resource = XMLResource(path, lazy=True)
+        self.assertIs(resource.source, path)
+        self.assertEqual(resource.root.tag, '{http://example.com/vehicles}vehicles')
+        self.check_url(resource.url, path.as_uri())
+        self.assertTrue(resource.filepath.endswith('vehicles.xml'))
+        self.assertIsNone(resource.text)
+        with self.assertRaises(XMLResourceError) as ctx:
+            resource.load()
+        self.assertIn('cannot load a lazy resource', str(ctx.exception))
+        self.assertIsNone(resource.text)
+
+        resource = XMLResource(path, lazy=False)
+        self.assertEqual(resource.source, path)
+        self.assertEqual(resource.root.tag, '{http://example.com/vehicles}vehicles')
+        self.check_url(resource.url, path.as_uri())
+        self.assertIsNone(resource.text)
+        resource.load()
+        self.assertTrue(resource.text.startswith('<?xml'))
+
+        resource = XMLResource(path, lazy=False)
+        resource._url = resource._url:-12 + 'unknown.xml'
+        with self.assertRaises(XMLResourceError):
+            resource.load()
+
     def test_xml_resource_from_element_tree(self):
         vh_etree = ElementTree.parse(self.vh_xml_file)
         vh_root = vh_etree.getroot()
@@ -302,6 +512,7 @@
         self.assertEqual(resource.source, vh_etree)
         self.assertEqual(resource.root.tag, '{http://example.com/vehicles}vehicles')
         self.assertIsNone(resource.url)
+        self.assertIsNone(resource.filepath)
         self.assertIsNone(resource.text)
         resource.load()
         self.assertIsNone(resource.text)
@@ -310,6 +521,7 @@
         self.assertEqual(resource.source, vh_root)
         self.assertEqual(resource.root.tag, '{http://example.com/vehicles}vehicles')
         self.assertIsNone(resource.url)
+        self.assertIsNone(resource.filepath)
         self.assertIsNone(resource.text)
         resource.load()
         self.assertIsNone(resource.text)
@@ -323,6 +535,7 @@
         self.assertEqual(resource.source, vh_etree)
         self.assertEqual(resource.root.tag, '{http://example.com/vehicles}vehicles')
         self.assertIsNone(resource.url)
+        self.assertIsNone(resource.filepath)
         self.assertIsNone(resource.text)
         resource.load()
         self.assertIsNone(resource.text)
@@ -331,6 +544,7 @@
         self.assertEqual(resource.source, vh_root)
         self.assertEqual(resource.root.tag, '{http://example.com/vehicles}vehicles')
         self.assertIsNone(resource.url)
+        self.assertIsNone(resource.filepath)
         self.assertIsNone(resource.text)
         resource.load()
         self.assertIsNone(resource.text)
@@ -463,7 +677,7 @@
         self.assertRaises(TypeError, XMLResource, b'<UNSUPPORTED_DATA_TYPE/>')
 
         with self.assertRaises(TypeError) as ctx:
-            XMLResource('<root/>', base_url=b'/home')
+            XMLResource('<root/>', base_url=b'/home')
         self.assertIn(' ', str(ctx.exception))
 
     def test_xml_resource_namespace(self):
@@ -544,12 +758,12 @@
         with self.assertRaises(TypeError) as ctx:
             XMLResource("https://xmlschema.test/vehicles.xsd", allow=None)
         self.assertEqual(str(ctx.exception),
-                         "invalid type <class 'NoneType'> for the attribute 'allow'")
+                         "invalid type <class 'NoneType'> for argument 'allow'")
 
         with self.assertRaises(ValueError) as ctx:
             XMLResource("https://xmlschema.test/vehicles.xsd", allow='any')
         self.assertEqual(str(ctx.exception),
-                         "'allow' attribute: 'any' is not a security mode")
+                         "'allow' argument: 'any' is not a security mode")
 
     def test_xml_resource_defuse(self):
         resource = XMLResource(self.vh_xml_file, defuse='never', lazy=True)
@@ -631,6 +845,26 @@
             resource = XMLResource(fp.read(), base_url='/foo')
             self.assertEqual(resource.base_url, '/foo')
 
+        base_url = Path(self.vh_xml_file).parent
+        resource = XMLResource('vehicles.xml', base_url)
+        self.assertEqual(resource.base_url, base_url.as_uri())
+
+        resource = XMLResource('vehicles.xml', str(base_url))
+        self.assertEqual(resource.base_url, base_url.as_uri())
+
+        resource = XMLResource('vehicles.xml', str(base_url).encode())
+        self.assertEqual(resource.base_url, base_url.as_uri())
+        self.assertEqual(resource.base_url, base_url.as_uri())
+
+        with self.assertRaises(TypeError):
+            XMLResource(self.vh_xml_file, base_url=False)
+
+        with self.assertRaises(ValueError):
+            XMLResource(self.vh_xml_file, base_url='<root/>')
+
+        with self.assertRaises(ValueError):
+            XMLResource(self.vh_xml_file, base_url=b'<root/>')
+
     def test_xml_resource_is_local(self):
         resource = XMLResource(self.vh_xml_file)
         self.assertTrue(resource.is_local())
@@ -723,7 +957,10 @@
         resource = XMLResource(self.vh_xml_file)
         resource.close()
         xml_file = resource.open()
-        self.assertTrue(callable(xml_file.read))
+        try:
+            self.assertTrue(callable(xml_file.read))
+        finally:
+            resource.close()
 
         with open(self.vh_xml_file) as xml_file:
             resource = XMLResource(source=xml_file)
@@ -1069,20 +1306,30 @@
 
         resource = XMLResource(source)
         locations = resource.get_locations()
-        self.assertListEqual(locations, ('http://example.com/ns1', 'file:///loc1'),
-                                         ('http://example.com/ns2', 'file:///loc2'))
+        self.assertEqual(len(locations), 2)
+        self.assertEqual(locations00, 'http://example.com/ns1')
+        self.assertRegex(locations01, f'file://{DRIVE_REGEX}/loc1')
+        self.assertEqual(locations10, 'http://example.com/ns2')
+        self.assertRegex(locations11, f'file://{DRIVE_REGEX}/loc2')
 
         locations = resource.get_locations(root_only=True)
-        self.assertListEqual(locations, ('http://example.com/ns1', 'file:///loc1'))
+        self.assertEqual(len(locations), 1)
+        self.assertEqual(locations00, 'http://example.com/ns1')
+        self.assertRegex(locations01, f'file://{DRIVE_REGEX}/loc1')
 
     @unittest.skipIf(SKIP_REMOTE_TESTS or platform.system() == 'Windows',
                      "Remote networks are not accessible or avoid SSL "
                      "verification error on Windows.")
     def test_remote_resource_loading(self):
-        with urlopen("https://raw.githubusercontent.com/brunato/xmlschema/master/"
-                     "tests/test_cases/examples/collection/collection.xsd") as rh:
+        url = "https://raw.githubusercontent.com/brunato/xmlschema/master/" \
+              "tests/test_cases/examples/collection/collection.xsd"
+
+        with urlopen(url) as rh:
             col_xsd_resource = XMLResource(rh)
 
+        self.assertEqual(col_xsd_resource.url, url)
+        self.assertIsNone(col_xsd_resource.filepath)
+
         self.assertEqual(col_xsd_resource.namespace, XSD_NAMESPACE)
         self.assertIsNone(col_xsd_resource.seek(0))
         col_xsd_resource.load()
@@ -1106,7 +1353,7 @@
         self.assertTrue(isinstance(vh_schema, XMLSchema))
 
         xsd_source = """
-        <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+        <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
                 xmlns:vh="http://example.com/vehicles">
             <xs:import namespace="http://example.com/vehicles" schemaLocation="{}"/>
         </xs:schema>""".format(self.vh_xsd_file)
@@ -1206,6 +1453,43 @@
             _ = resource.parent_map
         self.assertEqual("cannot create the parent map of a lazy resource", str(ctx.exception))
 
+    def test_get_nsmap(self):
+        source = '<a xmlns="uri1"><b1 xmlns:x="uri2"><c1/><c2/></b1><b2 xmlns="uri3"/></a>'
+        alien_elem = ElementTree.XML('<a/>')
+
+        root = ElementTree.XML(source)
+        resource = XMLResource(root)
+
+        self.assertListEqual(resource.get_nsmap(root), )
+        self.assertListEqual(resource.get_nsmap(root1), )
+        self.assertListEqual(resource.get_nsmap(alien_elem), )
+
+        if lxml_etree is not None:
+            root = lxml_etree.XML(source)
+            resource = XMLResource(root)
+
+            self.assertListEqual(resource.get_nsmap(root), ('', 'uri1'))
+            self.assertListEqual(resource.get_nsmap(root0), ('x', 'uri2'), ('', 'uri1'))
+            self.assertListEqual(resource.get_nsmap(root1), ('', 'uri3'))
+            self.assertListEqual(resource.get_nsmap(alien_elem), )
+
+        resource = XMLResource(source)
+        root = resource.root
+
+        self.assertListEqual(resource.get_nsmap(root), ('', 'uri1'))
+        self.assertListEqual(resource.get_nsmap(root0), ('', 'uri1'), ('x', 'uri2'))
+        self.assertListEqual(resource.get_nsmap(root1), ('', 'uri1'), ('', 'uri3'))
+        self.assertListEqual(resource.get_nsmap(alien_elem), )
+
+        resource = XMLResource(StringIO(source), lazy=True)
+        root = resource.root
+        self.assertTrue(resource.is_lazy())
+
+        self.assertListEqual(resource.get_nsmap(root), ('', 'uri1'))
+        self.assertListEqual(resource.get_nsmap(root0), )
+        self.assertListEqual(resource.get_nsmap(root1), )
+        self.assertListEqual(resource.get_nsmap(alien_elem), )
+
     def test_xml_subresource(self):
         resource = XMLResource(self.vh_xml_file, lazy=True)
         with self.assertRaises(XMLResourceError) as ctx:
@@ -1221,10 +1505,11 @@
             resource.subresource(None)
         self.assertEqual("None is not an element or the XML resource tree", str(ctx.exception))
 
-        resource = XMLResource(lxml_etree.parse(self.vh_xml_file).getroot())
-        root = resource.root
-        subresource = resource.subresource(root0)
-        self.assertIs(subresource.root, resource.root0)
+        if lxml_etree is not None:
+            resource = XMLResource(lxml_etree.parse(self.vh_xml_file).getroot())
+            root = resource.root
+            subresource = resource.subresource(root0)
+            self.assertIs(subresource.root, resource.root0)
 
         xml_text = '<a><b1 xmlns:x="tns0"><c1 xmlns:y="tns1"/><c2/></b1><b2/></a>'
         resource = XMLResource(xml_text)
@@ -1232,6 +1517,14 @@
         subresource = resource.subresource(root0)
         self.assertIs(subresource.root, resource.root0)
 
+    def test_loading_from_unrelated_dirs__issue_237(self):
+        relative_path = str(pathlib.Path(__file__).parent.joinpath(
+            'test_cases/issues/issue_237/dir1/issue_237.xsd'
+        ))
+        schema = XMLSchema(relative_path)
+        self.assertEqual(schema.maps.namespaces''1.name, 'issue_237a.xsd')
+        self.assertEqual(schema.maps.namespaces''2.name, 'issue_237b.xsd')
+
 
 if __name__ == '__main__':
     header_template = "Test xmlschema's XML resources with Python {} on platform {}"

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/test_schemas.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_schemas.py Changed

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_typing.py Added

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+#
+# Copyright (c), 2018-2020, SISSA (International School for Advanced Studies).
+# All rights reserved.
+# This file is distributed under the terms of the MIT License.
+# See the file 'LICENSE' in the root directory of the present
+# distribution, or http://opensource.org/licenses/MIT.
+#
+# @author Davide Brunato <brunato@sissa.it>
+#
+"""Tests about static typing of xmlschema objects."""
+
+import unittest
+import subprocess
+import re
+from pathlib import Path
+
+try:
+    import mypy
+except ImportError:
+    mypy = None
+
+
+@unittest.skipIf(mypy is None, "mypy is not installed")
+class TestTyping(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.cases_dir = Path(__file__).parent.joinpath('test_cases/mypy')
+        cls.config_file = Path(__file__).parent.parent.joinpath('mypy.ini')
+        cls.error_pattern = re.compile(r'Found \d+ error', re.IGNORECASE)
+
+    def check_mypy_output(self, testfile, *options):
+        cmd = 'mypy', '--config-file', str(self.config_file), testfile
+        if options:
+            cmd.extend(str(opt) for opt in options)
+        process = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+        self.assertEqual(process.stderr, b'')
+        output = process.stdout.decode('utf-8').strip()
+        output_lines = output.split('\n')
+
+        self.assertGreater(len(output_lines), 0, msg=output)
+        self.assertNotRegex(output_lines-1, self.error_pattern, msg=output)
+        return output_lines
+
+    def test_simple_types(self):
+        case_path = self.cases_dir.joinpath('simple_types.py')
+        output_lines = self.check_mypy_output(case_path, '--strict', '--no-warn-unused-ignores')
+        self.assertTrue(output_lines0.startswith('Success:'), msg='\n'.join(output_lines))
+
+
+if __name__ == '__main__':
+    unittest.main()

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/test_validation.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_validation.py Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/test_wsdl.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/test_wsdl.py Changed

@@ -11,7 +11,7 @@
 """Tests concerning WSDL documents. Examples from WSDL 1.1 definition document."""
 
 import unittest
-import os
+import pathlib
 
 from xmlschema import XMLSchemaValidationError, XMLSchema10, XMLSchema11
 from xmlschema.etree import ElementTree, ParseError
@@ -20,11 +20,11 @@
     WsdlInput, SoapHeader
 
 
-TEST_CASES_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'test_cases/')
+TEST_CASES_DIR = str(pathlib.Path(__file__).absolute().parent.joinpath('test_cases'))
 
 
 def casepath(relative_path):
-    return os.path.join(TEST_CASES_DIR, relative_path)
+    return str(pathlib.Path(TEST_CASES_DIR).joinpath(relative_path))
 
 
 WSDL_DOCUMENT_EXAMPLE = """<?xml version="1.0"?>
@@ -895,6 +895,22 @@
             WsdlBinding(elem, wsdl_document)
         self.assertIn("missing fault 'exception'", str(ctx.exception))
 
+    def test_loading_from_unrelated_dirs__issue_237(self):
+        relpath = str(pathlib.Path(__file__).parent.joinpath(
+            'test_cases/issues/issue_237/dir1/stockquoteservice.wsdl'
+        ))
+        wsdl_document = Wsdl11Document(relpath)
+        self.assertIn('http://example.com/stockquote/schemas', wsdl_document.imports)
+        self.assertEqual(
+            wsdl_document.imports'http://example.com/stockquote/schemas'.name,
+            'stockquote.xsd'
+        )
+        self.assertIn('http://example.com/stockquote/definitions', wsdl_document.imports)
+        self.assertEqual(
+            wsdl_document.imports'http://example.com/stockquote/definitions'.name,
+            'stockquote.wsdl'
+        )
+
 
 if __name__ == '__main__':
     import platform

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/validation/test_decoding.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/validation/test_decoding.py Changed

@@ -1,3 +1,4 @@
+
 #!/usr/bin/env python
 #
 # Copyright (c), 2016-2020, SISSA (International School for Advanced Studies).
@@ -10,7 +11,9 @@
 #
 import unittest
 import os
+import json
 from decimal import Decimal
+from collections.abc import MutableMapping, MutableSequence, Set
 import base64
 
 try:
@@ -23,10 +26,11 @@
 from xmlschema import XMLSchemaValidationError, ParkerConverter, BadgerFishConverter, \
     AbderaConverter, JsonMLConverter, ColumnarConverter
 
+from xmlschema.names import XSD_STRING
 from xmlschema.etree import ElementTree
 from xmlschema.converters import UnorderedConverter
 from xmlschema.validators import XMLSchema11
-from xmlschema.testing import XsdValidatorTestCase
+from xmlschema.testing import XsdValidatorTestCase, etree_elements_assert_equal
 
 VEHICLES_DICT = {
     '@xmlns:vh': 'http://example.com/vehicles',
@@ -326,6 +330,17 @@
 }
 
 
+def iter_nested_iterables(obj):
+    if not isinstance(obj, (MutableMapping, MutableSequence, Set, tuple)):
+        yield obj
+    else:
+        for item in obj.values() if isinstance(obj, MutableMapping) else obj:
+            if not isinstance(item, (MutableMapping, MutableSequence, Set, tuple)):
+                yield item
+            else:
+                yield from iter_nested_iterables(item)
+
+
 class TestDecoding(XsdValidatorTestCase):
     TEST_CASES_DIR = os.path.join(os.path.dirname(__file__), '../test_cases')
 
@@ -394,7 +409,7 @@
 
     def test_date_decoding(self):
         # Issue #136
-        schema = xmlschema.XMLSchema("""<?xml version="1.0" encoding="utf-8"?>
+        schema = self.schema_class("""<?xml version="1.0" encoding="utf-8"?>
             <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" version="1.0">
                 <xs:element name="Date">
                     <xs:simpleType>
@@ -569,9 +584,51 @@
         xd = self.vh_schema.to_dict(xt, '/vh:vehicles/vh:bikes', namespaces=self.vh_namespaces)
         self.assertEqual(xd'vh:bike', VEHICLES_DICT'vh:bikes''vh:bike')
 
+    def test_max_depth_argument(self):
+        schema = self.schema_class(self.col_xsd_file)
+        self.assertEqual(
+            schema.decode(self.col_xml_file, max_depth=1),
+            {'@xmlns:col': 'http://example.com/ns/collection',
+             '@xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+             '@xsi:schemaLocation': 'http://example.com/ns/collection collection.xsd'})
+
+        xmlschema.limits.MAX_XML_DEPTH = 1
+        with self.assertRaises(XMLSchemaValidationError):
+            schema.decode(self.col_xml_file)
+        xmlschema.limits.MAX_XML_DEPTH = 9999
+
+        self.assertEqual(
+            schema.decode(self.col_xml_file, max_depth=2),
+            {'@xmlns:col': 'http://example.com/ns/collection',
+             '@xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+             '@xsi:schemaLocation': 'http://example.com/ns/collection collection.xsd',
+             'object': {'@id': 'b0836217462', '@available': True},
+                        {'@id': 'b0836217463', '@available': True}})
+
+    def test_value_hook_argument(self):
+        schema = self.schema_class(self.col_xsd_file)
+
+        def ascii_strings(value, xsd_type):
+            try:
+                if not isinstance(value, str) or \
+                        xsd_type.primitive_type.name != XSD_STRING:
+                    return value
+            except AttributeError:
+                return value
+            else:
+                return value.encode('utf-8')
+
+        obj = schema.decode(self.col_xml_file, value_hook=ascii_strings)
+        self.assertNotEqual(obj, schema.decode(self.col_xml_file))
+        root = schema.encode(obj)
+        self.assertIsNone(etree_elements_assert_equal(
+            root, ElementTree.parse(self.col_xml_file).getroot(), strict=False
+        ))
+        self.assertEqual(obj'object'0'title', b'The Umbrellas')
+
     def test_non_global_schema_path(self):
         # Issue #157
-        xs = xmlschema.XMLSchema("""<?xml version="1.0" encoding="UTF-8"?>
+        xs = self.schema_class("""<?xml version="1.0" encoding="UTF-8"?>
         <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
                 xmlns:foo="http://example.com/foo" 
                 targetNamespace="http://example.com/foo">
@@ -635,6 +692,11 @@
         self.assertEqual(xs.decode('<dt>2001-04-15</dt>', datetime_types=True),
                          datatypes.Date10.fromstring('2001-04-15'))
 
+        xs = self.get_schema('<xs:attribute name="dt" type="xs:date"/>')
+        self.assertEqual(xs.attributes'dt'.decode('2001-04-15'), '2001-04-15')
+        self.assertEqual(xs.attributes'dt'.decode('2001-04-15', datetime_types=True),
+                         datatypes.Date10.fromstring('2001-04-15'))
+
     def test_duration_type(self):
         xs = self.get_schema('<xs:element name="td" type="xs:duration"/>')
         self.assertEqual(xs.decode('<td>P5Y3MT60H30.001S</td>'), 'P5Y3MT60H30.001S')
@@ -703,22 +765,66 @@
         xsd_string = self.casepath('issues/issue_022/xsd_string.xsd')
         xml_string_1 = self.casepath('issues/issue_022/xml_string_1.xml')
         xml_string_2 = self.casepath('issues/issue_022/xml_string_2.xml')
-        xsd_schema = xmlschema.XMLSchema(xsd_string)
+        xsd_schema = self.schema_class(xsd_string)
         xml_data_1 = xsd_schema.to_dict(xml_string_1)
         xml_data_2 = xsd_schema.to_dict(xml_string_2)
         self.assertTrue(isinstance(xml_data_1'bar', type(xml_data_2'bar')),
                         msg="XSD with an array that return a single element from "
                             "xml must still yield a list.")
 
-    def test_any_type(self):
-        any_type = xmlschema.XMLSchema.meta_schema.types'anyType'
+    def test_any_type_decoding(self):
+        any_type = self.schema_class.meta_schema.types'anyType'
         xml_data_1 = ElementTree.Element('dummy')
         self.assertIsNone(any_type.decode(xml_data_1))
         xml_data_2 = ElementTree.fromstring('<root>\n    <child_1/>\n    <child_2/>\n</root>')
-        self.assertIsNone(any_type.decode(xml_data_2))  # Currently no decoding yet
+
+        # Fix for processContents='lax' (issue 273, previously result was None)
+        self.assertEqual(any_type.decode(xml_data_2), {'child_1': None, 'child_2': None})
+
+    def test_skip_wildcard_decoding(self):
+        schema = self.schema_class("""<?xml version="1.0" encoding="UTF-8"?>
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:element name="foo">
+                    <xs:complexType>
+                        <xs:sequence>
+                            <xs:any processContents="skip"/>
+                        </xs:sequence>
+                    </xs:complexType>
+                </xs:element>
+            </xs:schema>""")
+
+        self.assertIsNone(schema.decode('<foo><bar/></foo>'))
+
+        obj = schema.decode('<foo><bar/></foo>', process_skipped=True)
+        self.assertEqual(obj, {'bar': None})
+
+        root = schema.encode(obj)
+        self.assertEqual(root.tag, 'foo')
+        self.assertEqual(len(root), 0)
+
+        root = schema.encode(obj, process_skipped=True)
+        self.assertEqual(root.tag, 'foo')
+        self.assertEqual(len(root), 1)
+        self.assertEqual(root0.tag, 'bar')
+
+    def test_any_type_decoding__issue_273(self):
+        schema = self.schema_class(self.casepath('issues/issue_273/issue_273.xsd'))
+        data = schema.to_dict(self.casepath('issues/issue_273/issue_273.xml'))
+
+        self.assertDictEqual(data, {
+            '@x': 'QA01_sequence',
+            '@y': 2500,
+            'QA01': 
+                {'qa01_elem01': '13',
+                 'qa01_elem02': '5139',
+                 'qa01_elem03': '170',
+                 'qa01_elem04': {'@these': 'attributes', '@get': 'dropped', '$': '0'},
+                 'qa01_elem05': '56',
+                 'qa01_elem06': '11141178'
+                 }})
 
     def test_choice_model_decoding__issue_041(self):
-        schema = xmlschema.XMLSchema(self.casepath('issues/issue_041/issue_041.xsd'))
+        schema = self.schema_class(self.casepath('issues/issue_041/issue_041.xsd'))
         data = schema.to_dict(self.casepath('issues/issue_041/issue_041.xml'))
         self.assertEqual(data, {
             '@xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
@@ -728,7 +834,7 @@
         })
 
     def test_cdata_decoding(self):
-        schema = xmlschema.XMLSchema(self.casepath('issues/issue_046/issue_046.xsd'))
+        schema = self.schema_class(self.casepath('issues/issue_046/issue_046.xsd'))
         xml_file = self.casepath('issues/issue_046/issue_046.xml')
         self.assertEqual(
             schema.decode(xml_file, cdata_prefix='#'),
@@ -754,13 +860,23 @@
         xs = self.get_schema('<xs:element name="hex" type="xs:hexBinary"/>')
 
         obj = xs.decode('<hex> 9AFD </hex>')
-        self.assertEqual(obj, ' 9AFD ')
+        self.assertEqual(obj, '9AFD')  # Value string is collapsed anyway
         self.assertIsInstance(obj, str)
 
         obj = xs.decode('<hex> 9AFD </hex>', binary_types=True)
         self.assertEqual(obj, '9AFD')
         self.assertIsInstance(obj, datatypes.HexBinary)
 
+        xs = self.get_schema('<xs:attribute name="hex" type="xs:hexBinary"/>')
+
+        obj = xs.attributes'hex'.decode(' 9AFD ')
+        self.assertEqual(obj, '9AFD')
+        self.assertIsInstance(obj, str)
+
+        obj = xs.attributes'hex'.decode(' 9AFD ', binary_types=True)
+        self.assertEqual(obj, '9AFD')
+        self.assertIsInstance(obj, datatypes.HexBinary)
+
     def test_base64_binary_type(self):
         base64_code_type = self.st_schema.types'base64Code'
         self.check_decode(base64_code_type, base64.b64encode(b'ok'), XMLSchemaValidationError)
@@ -769,6 +885,18 @@
         expected_value = datatypes.Base64Binary(base64_value)
         self.check_decode(base64_code_type, base64_value, expected_value)
 
+        # Attribute
+        xs = self.get_schema('<xs:attribute name="b64" type="xs:base64Binary"/>')
+
+        obj = xs.attributes'b64'.decode(base64_value.decode())
+        self.assertEqual(obj, expected_value)
+        self.assertIsInstance(obj, str)
+
+        obj = xs.attributes'b64'.decode(base64_value.decode(), binary_types=True)
+        self.assertEqual(obj, expected_value)
+        self.assertIsInstance(obj, datatypes.Base64Binary)
+
+        # Element
         xs = self.get_schema('<xs:element name="b64" type="xs:base64Binary"/>')
 
         obj = xs.decode('<b64>{}</b64>'.format(base64_value.decode()))
@@ -835,7 +963,7 @@
             </xs:complexType>
         </xs:schema>
         """
-        xsd_schema = xmlschema.XMLSchema(xsd_string)
+        xsd_schema = self.schema_class(xsd_string)
         xml_string_1 = "<foo><bar>0</bar></foo>"
         xml_string_2 = """<?xml version="1.0" encoding="UTF-8"?>
         <foo xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
@@ -848,7 +976,7 @@
         self.check_etree_elements(ElementTree.fromstring(xml_string_2), xsd_schema.encode(obj))
 
     def test_default_namespace__issue_077(self):
-        xs = xmlschema.XMLSchema("""<?xml version="1.0" encoding="UTF-8"?>
+        xs = self.schema_class("""<?xml version="1.0" encoding="UTF-8"?>
         <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
             targetNamespace="http://example.com/foo">
           <xs:element name="foo" type="xs:string" />
@@ -951,7 +1079,7 @@
         data = schema.decode(self.casepath('issues/issue_204/issue_204_3.xml'),
                              validation='lax', keep_unknown=True)
         self.assertEqual(set(x for x in data0 if x0 != '@'), {'child2', 'unknown', 'child5'})
-        self.assertEqual(data0'unknown', {'a': {'$': '1'}, 'b': None})
+        self.assertEqual(data0'unknown', {'a': '1', 'b': None})
 
         data = schema.decode(self.casepath('issues/issue_204/issue_204_2.xml'), validation='skip')
         self.assertEqual(set(x for x in data if x0 != '@'), {'child2', 'child5'})
@@ -959,7 +1087,7 @@
         data = schema.decode(self.casepath('issues/issue_204/issue_204_3.xml'),
                              validation='skip', keep_unknown=True)
         self.assertEqual(set(x for x in data if x0 != '@'), {'child2', 'unknown', 'child5'})
-        self.assertEqual(data'unknown', {'a': {'$': '1'}, 'b': None})
+        self.assertEqual(data'unknown', {'a': '1', 'b': None})
 
     def test_error_message__issue_115(self):
         schema = self.schema_class(self.casepath('issues/issue_115/Rotation.xsd'))
@@ -1007,13 +1135,13 @@
             </xs:schema>"""
 
         schema = self.schema_class(xsd_text)
-        result = schema.to_dict(
-            """<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+        xml_source = """<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
               <ExtensionSub xsi:type="ExtensionType">
                 <Content>my content</Content>
               </ExtensionSub>
             </root>"""
-        )
+
+        result = schema.to_dict(xml_source)
         expected = {
             "@xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
             "ExtensionSub": {
@@ -1023,12 +1151,17 @@
         }
         self.assertEqual(result, expected)
 
+        root = schema.to_etree(result)
+        self.assertIsNone(etree_elements_assert_equal(
+            root, ElementTree.XML(xml_source), strict=False
+        ))
+
     def test_issue_190(self):
         # Changed is_single() for XsdElement to check also parent group.
         schema = self.schema_class(self.casepath('issues/issue_190/issue_190.xsd'))
         self.assertEqual(
             schema.to_dict(self.casepath('issues/issue_190/issue_190.xml')),
-            {'a': {'c': {'$': '1'}}, 'b': {'c': {'$': '1'}, 'e': {'$': '1'}}}
+            {'a': {'c': '1'}, 'b': {'c': '1', 'e': '1'}}
         )
 
     def test_issue_200(self):
@@ -1044,6 +1177,31 @@
                            path='/na:main/na:item@doc_id=2'),
         self.assertIn('is not an element of the schema', str(ctx.exception))
 
+    def test_issue_238__decode_bytes_strings(self):
+        with open(self.vh_xml_file, 'rb') as fp:
+            vh_xml_data = fp.read()
+
+        self.assertIsInstance(vh_xml_data, bytes)
+
+        obj = self.vh_schema.decode(vh_xml_data)
+
+        # ElementTree accepts also bytes but emits Unicode strings only
+        for value in iter_nested_iterables(obj):
+            self.assertNotIsInstance(value, bytes)
+
+    def test_issue_240__decode_unicode_to_json(self):
+        schema = self.get_schema('<xs:element name="chars" type="xs:string"/>')
+
+        xml_data = '<chars>øæå</chars>'
+        obj = xmlschema.to_dict(xml_data, schema=schema, decimal_type=str)
+        self.assertEqual(obj, 'øæå')
+        self.assertEqual(obj, schema.decode(xml_data, decimal_type=str))
+
+        json_data = json.dumps(obj, indent=4)
+        self.assertEqual(obj, 'øæå')
+        self.assertIsInstance(obj, str)
+        self.assertEqual(json_data.encode("utf-8"), b'"\\u00f8\\u00e6\\u00e5"')
+
 
 class TestDecoding11(TestDecoding):
     schema_class = XMLSchema11
@@ -1059,6 +1217,11 @@
         self.assertEqual(xs.decode('<dt>2001-04-15</dt>', datetime_types=True),
                          datatypes.Date.fromstring('2001-04-15'))
 
+        xs = self.get_schema('<xs:attribute name="dt" type="xs:date"/>')
+        self.assertEqual(xs.attributes'dt'.decode('2001-04-15'), '2001-04-15')
+        self.assertEqual(xs.attributes'dt'.decode('2001-04-15', datetime_types=True),
+                         datatypes.Date.fromstring('2001-04-15'))
+
     def test_derived_duration_types(self):
         xs = self.get_schema('<xs:element name="td" type="xs:yearMonthDuration"/>')
         self.assertEqual(xs.decode('<td>P0Y4M</td>'), 'P0Y4M')

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/validation/test_encoding.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/validation/test_encoding.py Changed

@@ -13,12 +13,18 @@
 import unittest
 from textwrap import dedent
 
+try:
+    import lxml.etree as lxml_etree
+except ImportError:
+    lxml_etree = None
+
 from elementpath import datatypes
 
 from xmlschema import XMLSchemaEncodeError, XMLSchemaValidationError
 from xmlschema.converters import UnorderedConverter
 from xmlschema.etree import etree_element, etree_tostring, ElementTree
 from xmlschema.helpers import local_name, is_etree_element
+from xmlschema.resources import XMLResource
 from xmlschema.validators.exceptions import XMLSchemaChildrenValidationError
 from xmlschema.validators import XMLSchema11
 from xmlschema.testing import XsdValidatorTestCase
@@ -305,8 +311,10 @@
         message_lines = 
         try:
             schema.encode(rotation_data)
-        except Exception as err:
+        except XMLSchemaValidationError as err:
             message_lines = str(err).split('\n')
+            self.assertIsNone(err.source)
+            self.assertIsNone(err.path)
 
         self.assertTrue(message_lines, msg="Empty error message!")
         self.assertEqual(message_lines-4, 'Instance:')
@@ -318,6 +326,11 @@
                    'roll="0.0" pitch="0.0" yaw="-1.0" />'
         self.assertEqual(message_lines-2.strip(), text)
 
+        # With 'lax' validation a dummy resource is assigned to source attribute
+        _, errors = schema.encode(rotation_data, validation='lax')
+        self.assertIsInstance(errors0.source, XMLResource)
+        self.assertEqual(errors0.path, '/{http://www.example.org/Rotation/}rotation')
+
     def test_max_occurs_sequence(self):
         # Issue #119
         schema = self.get_schema("""
@@ -568,6 +581,85 @@
         self.assertIsNone(elem.text)
         self.assertEqual(elem.attrib, {'b1': 'false', 'b2': 'false', 'b3': 'false'})
 
+    def test_encode_sub_tree(self):
+        """Test encoding data of a non-root element"""
+        data = {
+            "@id": "PAR",
+            "name": "Pierre-Auguste Renoir",
+            "born": "1841-02-25",
+            "dead": "1919-12-03",
+            "qualification": "painter",
+        }
+        elem = self.col_schema.encode(
+            data,
+            path=".//author",
+            namespaces=self.col_namespaces,
+        )
+        self.assertEqual(
+            etree_tostring(elem),
+            dedent(
+                """\
+                <author id="PAR">
+                    <name>Pierre-Auguste Renoir</name>
+                    <born>1841-02-25</born>
+                    <dead>1919-12-03</dead>
+                    <qualification>painter</qualification>
+                </author>"""
+            )
+        )
+
+    @unittest.skipIf(lxml_etree is None, "The lxml library is not available.")
+    def test_lxml_encode(self):
+        """Test encode with etree_element_class=lxml.etree.Element"""
+        xd = {
+            "@xmlns:col": "http://example.com/ns/collection",
+            "@xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
+            "@xsi:schemaLocation": "http://example.com/ns/collection collection.xsd",
+            "object": 
+                {
+                    "@id": "b0836217463",
+                    "@available": True,
+                    "position": 2,
+                    "title": None,
+                    "year": "1925",
+                    "author": {
+                        "@id": "JM",
+                        "name": "Joan Miró",
+                        "born": "1893-04-20",
+                        "dead": "1983-12-25",
+                        "qualification": "painter, sculptor and ceramicist",
+                    },
+                },
+            ,
+        }
+
+        elem = self.col_schema.encode(
+            xd,
+            path="./col:collection",
+            namespaces=self.col_namespaces,
+            etree_element_class=lxml_etree.Element,
+        )
+
+        self.assertEqual(
+            etree_tostring(elem, namespaces=self.col_namespaces),
+            dedent(
+                """\
+                <col:collection xmlns:col="http://example.com/ns/collection" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://example.com/ns/collection collection.xsd">
+                    <object id="b0836217463" available="true">
+                        <position>2</position>
+                        <title/>
+                        <year>1925</year>
+                        <author id="JM">
+                            <name>Joan Miró</name>
+                            <born>1893-04-20</born>
+                            <dead>1983-12-25</dead>
+                            <qualification>painter, sculptor and ceramicist</qualification>
+                        </author>
+                    </object>
+                </col:collection>"""
+            )
+        )
+
 
 class TestEncoding11(TestEncoding):
     schema_class = XMLSchema11

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/validation/test_validation.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/validation/test_validation.py Changed

@@ -113,24 +113,60 @@
 
     def test_max_depth_argument(self):
         schema = self.schema_class(self.col_xsd_file)
-        self.assertEqual(
-            schema.decode(self.col_xml_file, max_depth=1),
-            {'@xmlns:col': 'http://example.com/ns/collection',
-             '@xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
-             '@xsi:schemaLocation': 'http://example.com/ns/collection collection.xsd'})
-
-        xmlschema.limits.MAX_XML_DEPTH = 1
-        with self.assertRaises(XMLSchemaValidationError):
-            schema.decode(self.col_xml_file)
-        xmlschema.limits.MAX_XML_DEPTH = 9999
-
-        self.assertEqual(
-            schema.decode(self.col_xml_file, max_depth=2),
-            {'@xmlns:col': 'http://example.com/ns/collection',
-             '@xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
-             '@xsi:schemaLocation': 'http://example.com/ns/collection collection.xsd',
-             'object': {'@id': 'b0836217462', '@available': True},
-                        {'@id': 'b0836217463', '@available': True}})
+        invalid_col_xml_file = self.casepath('examples/collection/collection-1_error.xml')
+        self.assertFalse(schema.is_valid(invalid_col_xml_file))
+        self.assertTrue(schema.is_valid(invalid_col_xml_file, max_depth=1))
+        self.assertTrue(schema.is_valid(invalid_col_xml_file, max_depth=2))
+        self.assertFalse(schema.is_valid(invalid_col_xml_file, max_depth=3))
+
+        root = ElementTree.parse(invalid_col_xml_file).getroot()
+        xsd_element = schema.elements'collection'
+        self.assertFalse(xsd_element.is_valid(root))
+        self.assertTrue(xsd_element.is_valid(root, max_depth=1))
+        self.assertTrue(xsd_element.is_valid(root, max_depth=2))
+        self.assertFalse(xsd_element.is_valid(root, max_depth=3))
+
+        # Need to provide namespace explicitly because the default namespace
+        # is set with xpathDefaultNamespace, that is '' in this case.
+        xsd_element = schema.find('collection/object', namespaces={'': schema.target_namespace})
+
+        self.assertTrue(xsd_element.is_valid(root0))
+        self.assertFalse(xsd_element.is_valid(root1))
+        self.assertTrue(xsd_element.is_valid(root1, max_depth=1))
+        self.assertFalse(xsd_element.is_valid(root1, max_depth=2))
+
+    def test_extra_validator(self):
+        # Related to issue 227
+
+        def bikes_validator(elem, xsd_element_):
+            if elem.tag == '{http://example.com/vehicles}bike' and \
+                    xsd_element_.name == elem.tag and \
+                    elem.attrib'make' != 'Harley-Davidson':
+                raise XMLSchemaValidationError(xsd_element_, elem, 'not an Harley-Davidson')
+
+        with self.assertRaises(XMLSchemaValidationError) as ec:
+            self.vh_schema.validate(self.vh_xml_file, extra_validator=bikes_validator)
+        self.assertIn('Reason: not an Harley-Davidson', str(ec.exception))
+
+        root = ElementTree.parse(self.vh_xml_file).getroot()
+        xsd_element = self.vh_schema.elements'vehicles'
+        with self.assertRaises(XMLSchemaValidationError) as ec:
+            xsd_element.validate(root, extra_validator=bikes_validator)
+        self.assertIn('Reason: not an Harley-Davidson', str(ec.exception))
+
+        with self.assertRaises(XMLSchemaValidationError) as ec:
+            self.vh_schema.decode(self.vh_xml_file, extra_validator=bikes_validator)
+        self.assertIn('Reason: not an Harley-Davidson', str(ec.exception))
+
+        def bikes_validator(elem, xsd_element_):
+            if elem.tag == '{http://example.com/vehicles}bike' and \
+                    xsd_element_.name == elem.tag and \
+                    elem.attrib'make' != 'Harley-Davidson':
+                yield XMLSchemaValidationError(xsd_element_, elem, 'not an Harley-Davidson')
+
+        with self.assertRaises(XMLSchemaValidationError) as ec:
+            self.vh_schema.validate(self.vh_xml_file, extra_validator=bikes_validator)
+        self.assertIn('Reason: not an Harley-Davidson', str(ec.exception))
 
     def test_issue_064(self):
         self.check_validity(self.st_schema, '<name xmlns="ns"></name>', False)
@@ -240,6 +276,21 @@
         with self.assertRaises(ElementTree.ParseError):
             schema.is_valid(malformed_xml_file)
 
+    def test_issue_238__validate_bytes_strings(self):
+        schema = xmlschema.XMLSchema(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+              <xs:element name="value" type="xs:int"/>
+            </xs:schema>"""))
+
+        self.assertTrue(schema.is_valid('<value>11</value>'))
+        self.assertTrue(schema.is_valid(b'<value>\n11\n</value>'))
+
+        with open(self.col_xml_file, 'rb') as fp:
+            col_xml_data = fp.read()
+
+        self.assertIsInstance(col_xml_data, bytes)
+        self.assertTrue(self.col_schema.is_valid(col_xml_data))
+
 
 class TestValidation11(TestValidation):
     schema_class = XMLSchema11

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/validators/test_attributes.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/validators/test_attributes.py Changed

@@ -9,9 +9,10 @@
 # @author Davide Brunato <brunato@sissa.it>
 #
 import unittest
+from textwrap import dedent
 
 from xmlschema import XMLSchemaParseError, XMLSchemaValidationError
-from xmlschema.validators import XMLSchema11, XsdAttribute
+from xmlschema.validators import XMLSchema11, XsdAttribute, XsdAttributeGroup
 from xmlschema.testing import XsdValidatorTestCase
 from xmlschema.names import XSI_NAMESPACE, XSD_ANY_SIMPLE_TYPE, XSD_STRING
 
@@ -104,8 +105,10 @@
             </xs:attributeGroup>
             <xs:attribute name="phone" type="xs:string" default="555-0100"/>
         </xs:schema>""")
-        self.assertTrue(schema.attribute_groups'contact''phone'.qualified)
-        self.assertEqual(schema.attribute_groups'contact''phone'.default, '555-0100')
+
+        xsd_attribute = schema.attribute_groups'contact''phone'
+        self.assertTrue(xsd_attribute.qualified)
+        self.assertEqual(xsd_attribute.default, '555-0100')
 
         schema = self.check_schema("""
         <xs:attributeGroup name="extra">
@@ -113,8 +116,10 @@
         </xs:attributeGroup>
         <xs:attribute name="phone" type="xs:string" fixed="555-0100"/>
         """)
-        self.assertEqual(schema.attribute_groups'extra''phone'.fixed, '555-0100')
-        self.assertIsNone(schema.attribute_groups'extra''phone'.annotation)
+
+        xsd_attribute = schema.attribute_groups'extra''phone'
+        self.assertEqual(xsd_attribute.fixed, '555-0100')
+        self.assertIsNone(xsd_attribute.annotation)
 
         schema = self.check_schema("""
         <xs:attributeGroup name="extra">
@@ -124,8 +129,10 @@
         </xs:attributeGroup>
         <xs:attribute name="phone" type="xs:string" fixed="555-0100"/>
         """)
-        self.assertEqual(schema.attribute_groups'extra''phone'.fixed, '555-0100')
-        self.assertIsNotNone(schema.attribute_groups'extra''phone'.annotation)
+
+        xsd_attribute = schema.attribute_groups'extra''phone'
+        self.assertEqual(xsd_attribute.fixed, '555-0100')
+        self.assertIsNotNone(xsd_attribute.annotation)
 
         self.check_schema("""
         <xs:attributeGroup name="extra">
@@ -295,6 +302,63 @@
             self.assertEqual(ctx.exception.message,
                              "xs:ID key attributes cannot have a fixed value")
 
+    def test_attribute_group_mapping(self):
+        schema = self.get_schema("""
+            <xs:attributeGroup name="attrs">
+                <xs:attribute name="a1" type="xs:string"/>
+                <xs:attribute name="a2" type="xs:string"/>
+            </xs:attributeGroup>""")
+
+        attribute_group = schema.attribute_groups'attrs'
+        self.assertEqual(repr(attribute_group), "XsdAttributeGroup(name='attrs')")
+
+        with self.assertRaises(ValueError) as ec:
+            attribute_group'a3' = attribute_group'a2'
+        self.assertEqual("'a2' name and key 'a3' mismatch", str(ec.exception))
+
+        xsd_attribute = attribute_group'a2'
+        del attribute_group'a2'
+        self.assertNotIn('a2', attribute_group)
+        attribute_group'a2' = xsd_attribute
+
+    def test_attribute_group_reference(self):
+        schema = self.get_schema("""
+            <xs:attributeGroup name="alpha">
+                <xs:attribute name="name" type="xs:string"/>
+                <xs:attributeGroup ref="beta"/>
+            </xs:attributeGroup>
+            <xs:attributeGroup name="beta">
+                <xs:attribute name="foo" type="xs:string"/>
+                <xs:attribute name="bar" type="xs:string"/>
+            </xs:attributeGroup>""")
+
+        # ref="beta" does not imply a reference but only a copy
+        # of the attributes of referred attribute group.
+        attribute_group = schema.attribute_groups'alpha'
+        self.assertNotIn('beta', attribute_group)
+        self.assertEqual(len(attribute_group), 3)
+        self.assertIn('name', attribute_group)
+        self.assertIn('foo', attribute_group)
+        self.assertIn('bar', attribute_group)
+
+    def test_missing_attribute_group_name(self):
+        schema = self.get_schema("""
+            <xs:attributeGroup>
+                <xs:annotation/>
+                <xs:attribute name="a1" type="xs:string"/>
+                <xs:attribute name="a2" type="xs:string"/>
+            </xs:attributeGroup>""", validation='lax')
+
+        self.assertEqual(len(schema.all_errors), 2)
+        self.assertTrue(isinstance(schema.all_errors0, XMLSchemaParseError))
+        self.assertIn("missing required attribute 'name'", str(schema.all_errors0))
+        self.assertTrue(isinstance(schema.all_errors1, XMLSchemaParseError))
+        self.assertIn("missing key field '@name'", str(schema.all_errors1))
+
+        self.assertEqual(len(schema.attribute_groups), 0)
+        attribute_group = XsdAttributeGroup(schema.root0, schema, parent=None)
+        self.assertIsNone(attribute_group.name)
+
     def test_missing_attribute_group_reference(self):
         self.check_schema("""
         <xs:attributeGroup name="alpha">
@@ -303,7 +367,18 @@
         </xs:attributeGroup>
         """, XMLSchemaParseError)
 
-        schema = self.check_schema("""
+        self.check_schema("""
+        <xs:attributeGroup name="alpha">
+            <xs:attribute name="name" type="xs:string"/>
+            <xs:attributeGroup ref="x:beta"/>  
+        </xs:attributeGroup>
+        <xs:attributeGroup name="beta">
+            <xs:attribute name="foo" type="xs:string"/>
+            <xs:attribute name="bar" type="xs:string"/>
+        </xs:attributeGroup>
+        """, XMLSchemaParseError)
+
+        schema = self.get_schema("""
             <xs:attributeGroup name="alpha">
                 <xs:attribute name="name" type="xs:string"/>
                 <xs:attributeGroup name="beta"/>  
@@ -311,6 +386,61 @@
             """, validation='lax')
         self.assertTrue(isinstance(schema.all_errors1, XMLSchemaParseError))
 
+    def test_attribute_wildcards(self):
+        schema = self.get_schema("""
+            <xs:attributeGroup name="attrs">
+                <xs:attribute name="a1" type="xs:string"/>
+                <xs:attribute name="a2" type="xs:string"/>
+                <xs:anyAttribute namespace="other"/>
+            </xs:attributeGroup>""")
+
+        attribute_group = schema.attribute_groups'attrs'
+        self.assertEqual(len(attribute_group), 3)
+        self.assertIn(None, attribute_group)
+
+        schema = self.get_schema("""
+            <xs:attributeGroup name="attrs">
+                <xs:attribute name="a1" type="xs:string"/>
+                <xs:attribute name="a2" type="xs:string"/>
+                <xs:anyAttribute namespace="other"/>
+                <xs:anyAttribute namespace="#all"/>
+                <xs:attribute name="a3" type="xs:string"/>
+            </xs:attributeGroup>""", validation='lax')
+
+        self.assertEqual(len(schema.all_errors), 3)
+        self.assertTrue(isinstance(schema.all_errors0, XMLSchemaParseError))
+        self.assertIn("Unexpected child with tag 'xs:anyAttribute'", str(schema.all_errors0))
+        self.assertTrue(isinstance(schema.all_errors1, XMLSchemaParseError))
+        self.assertIn("more anyAttribute declarations", str(schema.all_errors1))
+        self.assertTrue(isinstance(schema.all_errors2, XMLSchemaParseError))
+        self.assertIn("another declaration after anyAttribute", str(schema.all_errors2))
+
+    def test_duplicated_attribute(self):
+        with self.assertRaises(XMLSchemaParseError) as ec:
+            self.get_schema("""
+                <xs:attributeGroup name="attrs">
+                    <xs:attribute name="a1" type="xs:string"/>
+                    <xs:attribute name="a2" type="xs:string"/>
+                    <xs:attribute name="a2" type="xs:string"/>
+                </xs:attributeGroup>""")
+
+        self.assertIn("multiple declaration for attribute 'a2'", str(ec.exception))
+
+    def test_duplicated_attribute_group_ref(self):
+        with self.assertRaises(XMLSchemaParseError) as ec:
+            self.get_schema("""
+                <xs:attributeGroup name="attrs">
+                    <xs:attribute name="a1" type="xs:string"/>
+                    <xs:attributeGroup ref="other"/>
+                    <xs:attributeGroup ref="other"/>
+                </xs:attributeGroup>
+                <xs:attributeGroup name="other">
+                    <xs:attribute name="a2" type="xs:string"/>
+                    <xs:attribute name="a3" type="xs:string"/>
+                </xs:attributeGroup>""")
+
+        self.assertIn("duplicated attributeGroup 'other'", str(ec.exception))
+
     def test_scope_property(self):
         schema = self.check_schema("""
         <xs:attribute name="global_attr" type="xs:string"/>
@@ -402,6 +532,51 @@
 
     schema_class = XMLSchema11
 
+    def test_target_namespace(self):
+        xs = self.get_schema('<xs:attribute name="a" type="xs:string"/>')
+        self.assertEqual(xs.attributes'a'.target_namespace, '')
+
+        with self.assertRaises(XMLSchemaParseError) as ec:
+            self.get_schema('<xs:attribute name="foo" targetNamespace="bar" type="xs:string"/>')
+        self.assertIn("'targetNamespace' is prohibited", str(ec.exception))
+
+        xs = self.get_schema(dedent("""\
+            <xs:attributeGroup name="attrs">
+                <xs:attribute name="a" type="xs:string" 
+                    targetNamespace="http://xmlschema.test/ns"/>
+                <xs:attribute ref="b"/>
+            </xs:attributeGroup>
+            <xs:attribute name="b" type="xs:string"/>"""))
+
+        self.assertNotIn('a', xs.attribute_groups'attrs')
+        self.assertIn('{http://xmlschema.test/ns}a', xs.attribute_groups'attrs')
+
+        xsd_attribute = xs.attribute_groups'attrs''{http://xmlschema.test/ns}a'
+        self.assertEqual(xsd_attribute.target_namespace, 'http://xmlschema.test/ns')
+        self.assertEqual(xs.attribute_groups'attrs''b'.target_namespace, '')
+
+    def test_prohibited_and_fixed_incompatibility(self):
+        with self.assertRaises(XMLSchemaParseError) as ec:
+            self.get_schema(dedent("""\
+                <xs:attributeGroup name="attrs">
+                    <xs:attribute name="a" type="xs:string" 
+                        use="prohibited" fixed="foo"/>
+                </xs:attributeGroup>"""))
+
+        self.assertIn("'fixed' with use=prohibited is not allowed in XSD 1.1", str(ec.exception))
+
+    def test_inheritable_attribute(self):
+        xs = self.get_schema(dedent("""\
+            <xs:attributeGroup name="attrs">
+                <xs:attribute name="a" type="xs:string" />
+                <xs:attribute name="b" type="xs:string" inheritable="true"/>
+                <xs:attribute name="c" type="xs:string" inheritable="false"/>
+            </xs:attributeGroup>"""))
+
+        self.assertFalse(xs.attribute_groups'attrs''a'.inheritable)
+        self.assertTrue(xs.attribute_groups'attrs''b'.inheritable)
+        self.assertFalse(xs.attribute_groups'attrs''c'.inheritable)
+
 
 if __name__ == '__main__':
     import platform

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/validators/test_complex_types.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/validators/test_complex_types.py Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/validators/test_exceptions.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/validators/test_exceptions.py Changed

@@ -11,7 +11,11 @@
 import unittest
 import os
 import io
-import lxml.etree
+
+try:
+    import lxml.etree as lxml_etree
+except ImportError:
+    lxml_etree = None
 
 from xmlschema import XMLSchema, XMLResource
 from xmlschema.etree import ElementTree
@@ -54,18 +58,23 @@
         self.assertEqual(error.msg, 'unknown error')
 
         error = XMLSchemaValidatorError(xs, 'unknown error', elem=xs.root)
-        lines = str(error).split('\n')
+        output = str(error)
+        lines = output.split('\n')
+
+        self.assertGreater(len(lines), 10, msg=output)
+        self.assertEqual(lines0, 'unknown error:', msg=output)
+        self.assertEqual(lines2, 'Schema:', msg=output)
+        self.assertRegex(lines4.strip(), '^<(xs:)?schema ', msg=output)
+        self.assertRegex(lines-2.strip(), '</(xs:|xsd:)?schema>$', msg=output)
 
-        self.assertEqual(lines0, 'unknown error:')
-        self.assertEqual(lines2, 'Schema:')
-        self.assertTrue(lines4.strip().startswith('<xs:schema '))
-        self.assertEqual(lines-2.strip(), '</xs:schema>')
+    @unittest.skipIf(lxml_etree is None, 'lxml is not installed ...')
+    def test_exception_repr_lxml(self):
 
         schema = XMLSchema("""
             <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
                 <xs:element name="root" type="xs:integer"/>
             </xs:schema>""")
-        root = lxml.etree.XML('<root a="10"/>')
+        root = lxml_etree.XML('<root a="10"/>')
 
         with self.assertRaises(XMLSchemaValidationError) as ctx:
             schema.validate(root)
@@ -114,19 +123,21 @@
         self.assertEqual(ctx.exception.source, resource)
         self.assertEqual(ctx.exception.path, '/root')
 
-    def test_properties(self):
+    @unittest.skipIf(lxml_etree is None, 'lxml is not installed ...')
+    def test_sourceline_property(self):
         schema = XMLSchema("""
             <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
                 <xs:element name="root" type="xs:integer"/>
             </xs:schema>""")
 
-        root = lxml.etree.XML('<root a="10"/>')
+        root = lxml_etree.XML('<root a="10"/>')
         with self.assertRaises(XMLSchemaValidationError) as ctx:
             schema.validate(root)
 
         self.assertEqual(ctx.exception.sourceline, 1)
         self.assertEqual(ctx.exception.root, root)
 
+    def test_other_properties(self):
         xsd_file = os.path.join(CASES_DIR, 'examples/vehicles/vehicles.xsd')
         xs = XMLSchema(xsd_file)
 
@@ -211,7 +222,7 @@
             schema.validate('<a><b1/></a>')
 
         lines = str(ctx.exception).split('\n')
-        self.assertTrue(lines2.endswith("Tag b2 expected."))
+        self.assertTrue(lines2.endswith("Tag 'b2' expected."))
 
 
 if __name__ == '__main__':

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/validators/test_facets.py Added

@@ -0,0 +1,1308 @@
+#!/usr/bin/env python
+#
+# Copyright (c), 2016-2020, SISSA (International School for Advanced Studies).
+# All rights reserved.
+# This file is distributed under the terms of the MIT License.
+# See the file 'LICENSE' in the root directory of the present
+# distribution, or http://opensource.org/licenses/MIT.
+#
+# @author Davide Brunato <brunato@sissa.it>
+#
+import unittest
+import decimal
+import pathlib
+from xml.etree import ElementTree
+from textwrap import dedent
+
+from xmlschema import XMLSchema10, XMLSchema11, XMLSchemaValidationError, \
+    XMLSchemaParseError
+from xmlschema.names import XSD_NAMESPACE, XSD_LENGTH, XSD_MIN_LENGTH, XSD_MAX_LENGTH, \
+    XSD_WHITE_SPACE, XSD_MIN_INCLUSIVE, XSD_MIN_EXCLUSIVE, XSD_MAX_INCLUSIVE, \
+    XSD_MAX_EXCLUSIVE, XSD_TOTAL_DIGITS, XSD_FRACTION_DIGITS, XSD_ENUMERATION, \
+    XSD_PATTERN, XSD_ASSERTION
+
+
+class TestXsdFacets(unittest.TestCase):
+
+    schema_class = XMLSchema10
+
+    @classmethod
+    def setUpClass(cls):
+        cls.st_xsd_file = pathlib.Path(__file__).absolute().parent.parent.joinpath(
+            'test_cases/features/decoder/simple-types.xsd'
+        )
+        cls.st_schema = cls.schema_class(cls.st_xsd_file.as_uri())
+
+    def test_white_space_facet(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="string1">
+                    <xs:restriction base="xs:string">
+                        <xs:whiteSpace value="preserve"/>
+                    </xs:restriction>
+                </xs:simpleType>
+                <xs:simpleType name="string2">
+                    <xs:restriction base="xs:string">
+                        <xs:whiteSpace value="replace"/>
+                    </xs:restriction>
+                </xs:simpleType>
+                <xs:simpleType name="string3">
+                    <xs:restriction base="xs:string">
+                        <xs:whiteSpace value="collapse"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""))
+
+        xsd_type = schema.types'string1'
+        self.assertEqual(xsd_type.white_space, 'preserve')
+        white_space_facet = xsd_type.get_facet(XSD_WHITE_SPACE)
+        self.assertIsNone(white_space_facet(' \t alpha\n  beta '))
+
+        xsd_type = schema.types'string2'
+        self.assertEqual(xsd_type.white_space, 'replace')
+        white_space_facet = xsd_type.get_facet(XSD_WHITE_SPACE)
+        self.assertIsNone(white_space_facet('  alpha  beta '))
+
+        with self.assertRaises(XMLSchemaValidationError) as ec:
+            white_space_facet(' \t alpha\n  beta ')
+        self.assertIn('Reason: value contains tabs or newlines', str(ec.exception))
+
+        xsd_type = schema.types'string3'
+        self.assertEqual(xsd_type.white_space, 'collapse')
+        white_space_facet = xsd_type.get_facet(XSD_WHITE_SPACE)
+        self.assertIsNone(white_space_facet('alpha beta'))
+
+        with self.assertRaises(XMLSchemaValidationError) as ec:
+            white_space_facet('  alpha  beta ')
+        self.assertIn('Reason: value contains non collapsed white spaces', str(ec.exception))
+
+        with self.assertRaises(XMLSchemaParseError) as ec:
+            self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                    <xs:simpleType name="string1">
+                        <xs:restriction base="xs:string">
+                            <xs:whiteSpace value="invalid"/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                </xs:schema>"""))
+
+        self.assertIn(
+            "value must be one of 'preserve', 'replace', 'collapse'", str(ec.exception)
+        )
+
+    def test_white_space_restriction(self):
+        valid_derivations = 
+            ('preserve', 'preserve'), ('preserve', 'replace'), ('preserve', 'collapse'),
+            ('replace', 'replace'), ('replace', 'collapse'), ('collapse', 'collapse'),
+        
+        for base_value, value in valid_derivations:
+            schema = self.schema_class(dedent(f"""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                    <xs:simpleType name="string1">
+                        <xs:restriction base="xs:string">
+                            <xs:whiteSpace value="{base_value}"/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                    <xs:simpleType name="string2">
+                        <xs:restriction base="string1">
+                            <xs:whiteSpace value="{value}"/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                </xs:schema>"""))
+
+            self.assertEqual(schema.types'string1'.white_space, base_value)
+            self.assertEqual(schema.types'string2'.white_space, value)
+
+        invalid_derivations = 
+            ('replace', 'preserve'), ('collapse', 'preserve'), ('collapse', 'replace')
+        
+        for base_value, value in invalid_derivations:
+            with self.assertRaises(XMLSchemaParseError):
+                self.schema_class(dedent(f"""\
+                    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                        <xs:simpleType name="string1">
+                            <xs:restriction base="xs:string">
+                                <xs:whiteSpace value="{base_value}"/>
+                            </xs:restriction>
+                        </xs:simpleType>
+                        <xs:simpleType name="string2">
+                            <xs:restriction base="string1">
+                                <xs:whiteSpace value="{value}"/>
+                            </xs:restriction>
+                        </xs:simpleType>
+                    </xs:schema>"""))
+
+    def test_length_facet(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="username">
+                    <xs:restriction base="xs:NCName">
+                        <xs:length value="8"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""))
+
+        length_facet = schema.types'username'.get_facet(XSD_LENGTH)
+        self.assertIsNone(length_facet('a' * 8))
+
+        for value in '', 'a' * 7, 'a' * 9:
+            with self.assertRaises(XMLSchemaValidationError) as ec:
+                length_facet(value)
+            self.assertIn('Reason: length has to be 8', str(ec.exception))
+
+    def test_length_facet_restriction(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="username">
+                    <xs:restriction base="xs:NCName">
+                        <xs:length value="8"/>
+                    </xs:restriction>
+                </xs:simpleType>
+                <xs:simpleType name="username2">
+                    <xs:restriction base="username">
+                        <xs:length value="8"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""))
+
+        length_facet = schema.types'username'.get_facet(XSD_LENGTH)
+        self.assertIsNone(length_facet('a' * 8))
+        length_facet2 = schema.types'username2'.get_facet(XSD_LENGTH)
+        self.assertIsNone(length_facet2('a' * 8))
+        self.assertIsNot(length_facet, length_facet2)
+
+        # Not applied on xs:QName: https://www.w3.org/Bugs/Public/show_bug.cgi?id=4009
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="qname1">
+                    <xs:restriction base="xs:QName">
+                        <xs:length value="8"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""))
+
+        length_facet = schema.types'qname1'.get_facet(XSD_LENGTH)
+        self.assertIsNone(length_facet('a' * 8))
+        self.assertIsNone(length_facet('a' * 10))
+
+        with self.assertRaises(XMLSchemaParseError) as ec:
+            self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                    <xs:simpleType name="username">
+                        <xs:restriction base="xs:NCName">
+                            <xs:length value="8"/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                    <xs:simpleType name="username2">
+                        <xs:restriction base="username">
+                            <xs:length value="12"/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                </xs:schema>"""))
+
+        self.assertIn("base facet has a different length (8)", str(ec.exception))
+
+    def test_min_length_facet(self):
+        xsd_type = self.st_schema.types'none_empty_string'
+        min_length_facet = xsd_type.get_facet(XSD_MIN_LENGTH)
+        self.assertIsNone(min_length_facet(' '))
+        self.assertIsNone(min_length_facet(' ' * 75))
+
+        with self.assertRaises(XMLSchemaValidationError) as ec:
+            min_length_facet('')
+        self.assertIn('value length cannot be lesser than 1', str(ec.exception))
+
+        # Not applied on xs:QName: https://www.w3.org/Bugs/Public/show_bug.cgi?id=4009
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="qname1">
+                    <xs:restriction base="xs:QName">
+                        <xs:minLength value="8"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""))
+
+        min_length_facet = schema.types'qname1'.get_facet(XSD_MIN_LENGTH)
+        self.assertIsNone(min_length_facet('abc'))
+
+    def test_min_length_facet_restriction(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="string20">
+                    <xs:restriction base="xs:string">
+                        <xs:minLength value="20"/>
+                    </xs:restriction>
+                </xs:simpleType>
+                <xs:simpleType name="string30">
+                    <xs:restriction base="string20">
+                        <xs:minLength value="30"/>
+                    </xs:restriction>
+                </xs:simpleType>                
+            </xs:schema>"""))
+
+        self.assertEqual(schema.types'string20'.get_facet(XSD_MIN_LENGTH).value, 20)
+        self.assertEqual(schema.types'string30'.get_facet(XSD_MIN_LENGTH).value, 30)
+
+        with self.assertRaises(XMLSchemaParseError):
+            self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                    <xs:simpleType name="string40">
+                        <xs:restriction base="xs:string">
+                            <xs:minLength value="40"/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                    <xs:simpleType name="string30">
+                        <xs:restriction base="string40">
+                            <xs:minLength value="30"/>
+                        </xs:restriction>
+                    </xs:simpleType>                
+                </xs:schema>"""))
+
+    def test_max_length_facet(self):
+        xsd_type = self.st_schema.types'string_75'
+        max_length_facet = xsd_type.get_facet(XSD_MAX_LENGTH)
+        self.assertIsNone(max_length_facet(''))
+        self.assertIsNone(max_length_facet(' '))
+        self.assertIsNone(max_length_facet(' ' * 75))
+
+        with self.assertRaises(XMLSchemaValidationError) as ec:
+            max_length_facet(' ' * 76)
+        self.assertIn('value length cannot be greater than 75', str(ec.exception))
+
+        with self.assertRaises(XMLSchemaValidationError) as ec:
+            max_length_facet(None)
+        self.assertIn("invalid type <class 'NoneType'> provided", str(ec.exception))
+
+        # Not applied on xs:QName: https://www.w3.org/Bugs/Public/show_bug.cgi?id=4009
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="qname1">
+                    <xs:restriction base="xs:QName">
+                        <xs:maxLength value="8"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""))
+
+        max_length_facet = schema.types'qname1'.get_facet(XSD_MAX_LENGTH)
+        self.assertIsNone(max_length_facet('a' * 10))
+
+    def test_max_length_facet_restriction(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="string30">
+                    <xs:restriction base="xs:string">
+                        <xs:maxLength value="30"/>
+                    </xs:restriction>
+                </xs:simpleType>
+                <xs:simpleType name="string20">
+                    <xs:restriction base="string30">
+                        <xs:maxLength value="20"/>
+                    </xs:restriction>
+                </xs:simpleType>                
+            </xs:schema>"""))
+
+        self.assertEqual(schema.types'string30'.get_facet(XSD_MAX_LENGTH).value, 30)
+        self.assertEqual(schema.types'string20'.get_facet(XSD_MAX_LENGTH).value, 20)
+
+        with self.assertRaises(XMLSchemaParseError):
+            self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                    <xs:simpleType name="string30">
+                        <xs:restriction base="xs:string">
+                            <xs:maxLength value="30"/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                    <xs:simpleType name="string40">
+                        <xs:restriction base="string30">
+                            <xs:maxLength value="40"/>
+                        </xs:restriction>
+                    </xs:simpleType>                
+                </xs:schema>"""))
+
+    def test_min_inclusive_facet(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="min_type">
+                    <xs:restriction base="xs:integer">
+                        <xs:minInclusive value="0"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""))
+
+        facet = schema.types'min_type'.get_facet(XSD_MIN_INCLUSIVE)
+        self.assertIsNone(facet(0))
+        self.assertIsNone(facet(100))
+
+        with self.assertRaises(XMLSchemaValidationError) as ec:
+            facet(-1)
+        self.assertIn('value has to be greater or equal than 0', str(ec.exception))
+
+        with self.assertRaises(XMLSchemaValidationError):
+            facet('')
+
+        with self.assertRaises(XMLSchemaParseError):
+            self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                    <xs:simpleType name="min_type">
+                        <xs:restriction base="xs:integer">
+                            <xs:minInclusive value=""/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                </xs:schema>"""))
+
+    def test_min_inclusive_facet_restriction(self):
+        for base_facet in 'minInclusive', 'maxInclusive':
+            schema = self.schema_class(dedent(f"""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                    <xs:simpleType name="type1">
+                        <xs:restriction base="xs:integer">
+                            <xs:{base_facet} value="0"/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                    <xs:simpleType name="type2">
+                        <xs:restriction base="type1">
+                            <xs:minInclusive value="0"/>
+                        </xs:restriction>
+                    </xs:simpleType>                    
+                </xs:schema>"""))
+
+            facet = schema.types'type1'.get_facet('{%s}%s' % (XSD_NAMESPACE, base_facet))
+            self.assertIsNone(facet(0))
+            facet2 = schema.types'type2'.get_facet(XSD_MIN_INCLUSIVE)
+            self.assertIsNone(facet2(0))
+            self.assertIsNot(facet, facet2)
+
+        for base_facet in 'minInclusive', 'minExclusive':
+            with self.assertRaises(XMLSchemaParseError):
+                self.schema_class(dedent(f"""\
+                    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                        <xs:simpleType name="type1">
+                            <xs:restriction base="xs:integer">
+                                <xs:{base_facet} value="1"/>
+                            </xs:restriction>
+                        </xs:simpleType>
+                        <xs:simpleType name="type2">
+                            <xs:restriction base="type1">
+                                <xs:minInclusive value="0"/>
+                            </xs:restriction>
+                        </xs:simpleType>                    
+                    </xs:schema>"""))
+
+        for base_facet in 'maxInclusive', 'maxExclusive':
+            with self.assertRaises(XMLSchemaParseError):
+                self.schema_class(dedent(f"""\
+                    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                        <xs:simpleType name="type1">
+                            <xs:restriction base="xs:integer">
+                                <xs:{base_facet} value="-1"/>
+                            </xs:restriction>
+                        </xs:simpleType>
+                        <xs:simpleType name="type2">
+                            <xs:restriction base="type1">
+                                <xs:minInclusive value="0"/>
+                            </xs:restriction>
+                        </xs:simpleType>                    
+                    </xs:schema>"""))
+
+        for base_facet in 'minExclusive', 'maxExclusive':
+            with self.assertRaises(XMLSchemaParseError):
+                self.schema_class(dedent(f"""\
+                    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                        <xs:simpleType name="type1">
+                            <xs:restriction base="xs:integer">
+                                <xs:{base_facet} value="0"/>
+                            </xs:restriction>
+                        </xs:simpleType>
+                        <xs:simpleType name="type2">
+                            <xs:restriction base="type1">
+                                <xs:minInclusive value="0"/>
+                            </xs:restriction>
+                        </xs:simpleType>                    
+                    </xs:schema>"""))
+
+    def test_min_exclusive_facet(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="min_type">
+                    <xs:restriction base="xs:integer">
+                        <xs:minExclusive value="0"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""))
+
+        facet = schema.types'min_type'.get_facet(XSD_MIN_EXCLUSIVE)
+        self.assertIsNone(facet(1))
+
+        with self.assertRaises(XMLSchemaValidationError) as ec:
+            facet(0)
+        self.assertIn('value has to be greater than 0', str(ec.exception))
+
+        with self.assertRaises(XMLSchemaValidationError):
+            facet('')
+
+        with self.assertRaises(XMLSchemaParseError):
+            self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                    <xs:simpleType name="min_type">
+                        <xs:restriction base="xs:integer">
+                            <xs:minExclusive value=""/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                </xs:schema>"""))
+
+    def test_min_exclusive_facet_restriction(self):
+        for base_facet in 'minInclusive', 'minExclusive':
+            schema = self.schema_class(dedent(f"""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                    <xs:simpleType name="type1">
+                        <xs:restriction base="xs:integer">
+                            <xs:{base_facet} value="0"/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                    <xs:simpleType name="type2">
+                        <xs:restriction base="type1">
+                            <xs:minExclusive value="0"/>
+                        </xs:restriction>
+                    </xs:simpleType>                    
+                </xs:schema>"""))
+
+            facet = schema.types'type1'.get_facet('{%s}%s' % (XSD_NAMESPACE, base_facet))
+            self.assertIsNone(facet(1))
+            facet2 = schema.types'type2'.get_facet(XSD_MIN_EXCLUSIVE)
+            self.assertIsNone(facet2(1))
+            self.assertIsNot(facet, facet2)
+
+        for base_facet in 'maxInclusive', 'maxExclusive':
+            with self.assertRaises(XMLSchemaParseError):
+                self.schema_class(dedent(f"""\
+                    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                        <xs:simpleType name="type1">
+                            <xs:restriction base="xs:integer">
+                                <xs:{base_facet} value="0"/>
+                            </xs:restriction>
+                        </xs:simpleType>
+                        <xs:simpleType name="type2">
+                            <xs:restriction base="type1">
+                                <xs:minExclusive value="0"/>
+                            </xs:restriction>
+                        </xs:simpleType>                    
+                    </xs:schema>"""))
+
+        for base_facet in 'minInclusive', 'minExclusive':
+            with self.assertRaises(XMLSchemaParseError):
+                self.schema_class(dedent(f"""\
+                    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                        <xs:simpleType name="type1">
+                            <xs:restriction base="xs:integer">
+                                <xs:{base_facet} value="1"/>
+                            </xs:restriction>
+                        </xs:simpleType>
+                        <xs:simpleType name="type2">
+                            <xs:restriction base="type1">
+                                <xs:minExclusive value="0"/>
+                            </xs:restriction>
+                        </xs:simpleType>                    
+                    </xs:schema>"""))
+
+        for base_facet in 'maxInclusive', 'maxExclusive':
+            with self.assertRaises(XMLSchemaParseError):
+                self.schema_class(dedent(f"""\
+                    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                        <xs:simpleType name="type1">
+                            <xs:restriction base="xs:integer">
+                                <xs:{base_facet} value="-1"/>
+                            </xs:restriction>
+                        </xs:simpleType>
+                        <xs:simpleType name="type2">
+                            <xs:restriction base="type1">
+                                <xs:minExclusive value="0"/>
+                            </xs:restriction>
+                        </xs:simpleType>                    
+                    </xs:schema>"""))
+
+    def test_max_inclusive_facet(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="max_type">
+                    <xs:restriction base="xs:integer">
+                        <xs:maxInclusive value="0"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""))
+
+        facet = schema.types'max_type'.get_facet(XSD_MAX_INCLUSIVE)
+        self.assertIsNone(facet(-1))
+        self.assertIsNone(facet(0))
+
+        with self.assertRaises(XMLSchemaValidationError) as ec:
+            facet(1)
+        self.assertIn('value has to be lesser or equal than 0', str(ec.exception))
+
+        with self.assertRaises(XMLSchemaValidationError):
+            facet('')
+
+        with self.assertRaises(XMLSchemaParseError):
+            self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                    <xs:simpleType name="min_type">
+                        <xs:restriction base="xs:integer">
+                            <xs:maxInclusive value=""/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                </xs:schema>"""))
+
+    def test_max_inclusive_facet_restriction(self):
+        for base_facet in 'minInclusive', 'maxInclusive':
+            schema = self.schema_class(dedent(f"""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                    <xs:simpleType name="type1">
+                        <xs:restriction base="xs:integer">
+                            <xs:{base_facet} value="0"/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                    <xs:simpleType name="type2">
+                        <xs:restriction base="type1">
+                            <xs:maxInclusive value="0"/>
+                        </xs:restriction>
+                    </xs:simpleType>                    
+                </xs:schema>"""))
+
+            facet = schema.types'type1'.get_facet('{%s}%s' % (XSD_NAMESPACE, base_facet))
+            self.assertIsNone(facet(0))
+            facet2 = schema.types'type2'.get_facet(XSD_MAX_INCLUSIVE)
+            self.assertIsNone(facet2(0))
+            self.assertIsNot(facet, facet2)
+
+        for base_facet in 'maxInclusive', 'maxExclusive':
+            with self.assertRaises(XMLSchemaParseError):
+                self.schema_class(dedent(f"""\
+                    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                        <xs:simpleType name="type1">
+                            <xs:restriction base="xs:integer">
+                                <xs:{base_facet} value="-1"/>
+                            </xs:restriction>
+                        </xs:simpleType>
+                        <xs:simpleType name="type2">
+                            <xs:restriction base="type1">
+                                <xs:maxInclusive value="0"/>
+                            </xs:restriction>
+                        </xs:simpleType>                    
+                    </xs:schema>"""))
+
+        for base_facet in 'minInclusive', 'minExclusive':
+            with self.assertRaises(XMLSchemaParseError):
+                self.schema_class(dedent(f"""\
+                    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                        <xs:simpleType name="type1">
+                            <xs:restriction base="xs:integer">
+                                <xs:{base_facet} value="1"/>
+                            </xs:restriction>
+                        </xs:simpleType>
+                        <xs:simpleType name="type2">
+                            <xs:restriction base="type1">
+                                <xs:maxInclusive value="0"/>
+                            </xs:restriction>
+                        </xs:simpleType>                    
+                    </xs:schema>"""))
+
+        for base_facet in 'minExclusive', 'maxExclusive':
+            with self.assertRaises(XMLSchemaParseError):
+                self.schema_class(dedent(f"""\
+                    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                        <xs:simpleType name="type1">
+                            <xs:restriction base="xs:integer">
+                                <xs:{base_facet} value="0"/>
+                            </xs:restriction>
+                        </xs:simpleType>
+                        <xs:simpleType name="type2">
+                            <xs:restriction base="type1">
+                                <xs:maxInclusive value="0"/>
+                            </xs:restriction>
+                        </xs:simpleType>                    
+                    </xs:schema>"""))
+
+    def test_max_exclusive_facet(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="max_type">
+                    <xs:restriction base="xs:integer">
+                        <xs:maxExclusive value="0"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""))
+
+        facet = schema.types'max_type'.get_facet(XSD_MAX_EXCLUSIVE)
+        self.assertIsNone(facet(-1))
+
+        with self.assertRaises(XMLSchemaValidationError) as ec:
+            facet(0)
+        self.assertIn('value has to be lesser than 0', str(ec.exception))
+
+        with self.assertRaises(XMLSchemaValidationError):
+            facet('')
+
+        with self.assertRaises(XMLSchemaParseError):
+            self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                    <xs:simpleType name="min_type">
+                        <xs:restriction base="xs:integer">
+                            <xs:maxExclusive value=""/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                </xs:schema>"""))
+
+    def test_max_exclusive_facet_restriction(self):
+        for base_facet in 'maxInclusive', 'maxExclusive':
+            schema = self.schema_class(dedent(f"""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                    <xs:simpleType name="type1">
+                        <xs:restriction base="xs:integer">
+                            <xs:{base_facet} value="0"/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                    <xs:simpleType name="type2">
+                        <xs:restriction base="type1">
+                            <xs:maxExclusive value="0"/>
+                        </xs:restriction>
+                    </xs:simpleType>                    
+                </xs:schema>"""))
+
+            facet = schema.types'type1'.get_facet('{%s}%s' % (XSD_NAMESPACE, base_facet))
+            self.assertIsNone(facet(-1))
+            facet2 = schema.types'type2'.get_facet(XSD_MAX_EXCLUSIVE)
+            self.assertIsNone(facet2(-1))
+            self.assertIsNot(facet, facet2)
+
+        for base_facet in 'minInclusive', 'minExclusive':
+            with self.assertRaises(XMLSchemaParseError):
+                self.schema_class(dedent(f"""\
+                    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                        <xs:simpleType name="type1">
+                            <xs:restriction base="xs:integer">
+                                <xs:{base_facet} value="0"/>
+                            </xs:restriction>
+                        </xs:simpleType>
+                        <xs:simpleType name="type2">
+                            <xs:restriction base="type1">
+                                <xs:maxExclusive value="0"/>
+                            </xs:restriction>
+                        </xs:simpleType>                    
+                    </xs:schema>"""))
+
+        for base_facet in 'maxInclusive', 'maxExclusive':
+            with self.assertRaises(XMLSchemaParseError):
+                self.schema_class(dedent(f"""\
+                    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                        <xs:simpleType name="type1">
+                            <xs:restriction base="xs:integer">
+                                <xs:{base_facet} value="-1"/>
+                            </xs:restriction>
+                        </xs:simpleType>
+                        <xs:simpleType name="type2">
+                            <xs:restriction base="type1">
+                                <xs:maxExclusive value="0"/>
+                            </xs:restriction>
+                        </xs:simpleType>                    
+                    </xs:schema>"""))
+
+        for base_facet in 'minInclusive', 'minExclusive':
+            with self.assertRaises(XMLSchemaParseError):
+                self.schema_class(dedent(f"""\
+                    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                        <xs:simpleType name="type1">
+                            <xs:restriction base="xs:integer">
+                                <xs:{base_facet} value="1"/>
+                            </xs:restriction>
+                        </xs:simpleType>
+                        <xs:simpleType name="type2">
+                            <xs:restriction base="type1">
+                                <xs:maxExclusive value="0"/>
+                            </xs:restriction>
+                        </xs:simpleType>                    
+                    </xs:schema>"""))
+
+    def test_total_digits_facet(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="restricted_integer">
+                    <xs:restriction base="xs:integer">
+                        <xs:totalDigits value="4"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""))
+
+        facet = schema.types'restricted_integer'.get_facet(XSD_TOTAL_DIGITS)
+        self.assertIsNone(facet(9999))
+
+        with self.assertRaises(XMLSchemaValidationError) as ec:
+            facet(99999)
+        self.assertIn('the number of digits has to be lesser or equal than 4', str(ec.exception))
+
+        with self.assertRaises(XMLSchemaValidationError):
+            facet(None)
+
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="restricted_integer">
+                    <xs:restriction base="xs:integer">
+                        <xs:totalDigits value="a"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""), validation='lax')
+
+        self.assertIn("invalid literal", str(schema.all_errors0))
+        facet = schema.types'restricted_integer'.get_facet(XSD_TOTAL_DIGITS)
+        self.assertEqual(facet.value, 9999)
+
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="restricted_integer">
+                    <xs:restriction base="xs:integer">
+                        <xs:totalDigits value="0"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""), validation='lax')
+
+        self.assertIn("value must be positive", str(schema.all_errors0))
+        facet = schema.types'restricted_integer'.get_facet(XSD_TOTAL_DIGITS)
+        self.assertEqual(facet.value, 9999)
+
+    def test_fraction_digits_facet(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="restricted_decimal">
+                    <xs:restriction base="xs:decimal">
+                        <xs:fractionDigits value="2"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""))
+
+        facet = schema.types'restricted_decimal'.get_facet(XSD_FRACTION_DIGITS)
+        self.assertIsNone(facet(decimal.Decimal('99.99')))
+
+        with self.assertRaises(XMLSchemaValidationError) as ec:
+            facet(decimal.Decimal('99.999'))
+        self.assertIn('fraction digits has to be lesser or equal than 2', str(ec.exception))
+
+        with self.assertRaises(XMLSchemaValidationError):
+            facet(None)
+
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="restricted_decimal">
+                    <xs:restriction base="xs:decimal">
+                        <xs:fractionDigits value="a"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""), validation='lax')
+
+        self.assertIn("invalid literal", str(schema.all_errors0))
+        facet = schema.types'restricted_decimal'.get_facet(XSD_FRACTION_DIGITS)
+        self.assertEqual(facet.value, 9999)
+
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="restricted_decimal">
+                    <xs:restriction base="xs:decimal">
+                        <xs:fractionDigits value="-1"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""), validation='lax')
+
+        self.assertIn("value must be non negative", str(schema.all_errors0))
+        facet = schema.types'restricted_decimal'.get_facet(XSD_FRACTION_DIGITS)
+        self.assertEqual(facet.value, 9999)
+
+        with self.assertRaises(XMLSchemaParseError) as ec:
+            self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                    <xs:simpleType name="restricted_integer">
+                        <xs:restriction base="xs:integer">
+                            <xs:fractionDigits value="2"/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                </xs:schema>"""))
+
+        self.assertIn("value has to be 0 for types derived from xs:integer", str(ec.exception))
+
+        with self.assertRaises(XMLSchemaParseError) as ec:
+            self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                    <xs:simpleType name="restricted_double">
+                        <xs:restriction base="xs:double">
+                            <xs:fractionDigits value="2"/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                </xs:schema>"""))
+
+        self.assertIn("can be applied only to types derived from xs:decimal", str(ec.exception))
+
+    def test_digits_facets_restriction(self):
+        for facet in 'totalDigits', 'fractionDigits':
+            schema = self.schema_class(dedent(f"""\
+                    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                        <xs:simpleType name="decimal1">
+                            <xs:restriction base="xs:decimal">
+                                <xs:{facet} value="4"/>
+                            </xs:restriction>
+                        </xs:simpleType>
+                        <xs:simpleType name="decimal2">
+                            <xs:restriction base="decimal1">
+                                <xs:{facet} value="1"/>
+                            </xs:restriction>
+                        </xs:simpleType>
+                    </xs:schema>"""))
+
+            self.assertTrue(schema.types'decimal1'.is_valid(decimal.Decimal('.01')))
+            self.assertFalse(schema.types'decimal2'.is_valid(decimal.Decimal('.01')))
+
+            with self.assertRaises(XMLSchemaParseError) as ec:
+                self.schema_class(dedent(f"""\
+                    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                        <xs:simpleType name="decimal1">
+                            <xs:restriction base="xs:decimal">
+                                <xs:{facet} value="2"/>
+                            </xs:restriction>
+                        </xs:simpleType>
+                        <xs:simpleType name="decimal2">
+                            <xs:restriction base="decimal1">
+                                <xs:{facet} value="3"/>
+                            </xs:restriction>
+                        </xs:simpleType>
+                    </xs:schema>"""))
+
+            self.assertIn("invalid restriction: base value is lower", str(ec.exception))
+
+    def test_enumeration_facet(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="enum1">
+                    <xs:restriction base="xs:string">
+                        <xs:enumeration value="one"/>
+                        <xs:enumeration value="two"/>
+                        <xs:enumeration value="three"/>
+                    </xs:restriction>
+                </xs:simpleType>
+                <xs:simpleType name="enum2">
+                    <xs:restriction base="enum1">
+                        <xs:enumeration value="one"/>
+                        <xs:enumeration value="two"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""))
+
+        self.assertTrue(schema.types'enum1'.is_valid('one'))
+        self.assertTrue(schema.types'enum1'.is_valid('two'))
+        self.assertTrue(schema.types'enum1'.is_valid('three'))
+        self.assertFalse(schema.types'enum1'.is_valid('four'))
+
+        self.assertTrue(schema.types'enum2'.is_valid('one'))
+        self.assertTrue(schema.types'enum2'.is_valid('two'))
+        self.assertFalse(schema.types'enum2'.is_valid('three'))
+        self.assertFalse(schema.types'enum2'.is_valid('four'))
+
+        facet = schema.types'enum2'.get_facet(XSD_ENUMERATION)
+        elem = ElementTree.Element(XSD_ENUMERATION, value='three')
+        facet.append(elem)
+        self.assertTrue(schema.types'enum2'.is_valid('three'))
+        facet-1 = elem
+        self.assertTrue(schema.types'enum2'.is_valid('three'))
+        del facet-1
+        self.assertFalse(schema.types'enum2'.is_valid('three'))
+
+        with self.assertRaises(XMLSchemaParseError) as ec:
+            self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                    <xs:simpleType name="enum1">
+                        <xs:restriction base="xs:string">
+                            <xs:enumeration/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                </xs:schema>"""))
+
+        self.assertIn("missing required attribute 'value'", str(ec.exception))
+
+        with self.assertRaises(XMLSchemaParseError) as ec:
+            self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                    <xs:simpleType name="enum1">
+                        <xs:restriction base="xs:NOTATION">
+                            <xs:enumeration value="unknown:notation1"/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                </xs:schema>"""))
+
+        self.assertIn("prefix 'unknown' not found in namespace map", str(ec.exception))
+
+        with self.assertRaises(XMLSchemaParseError) as ec:
+            self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                    <xs:simpleType name="enum1">
+                        <xs:restriction base="xs:NOTATION">
+                            <xs:enumeration value="notation1"/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                </xs:schema>"""))
+
+        self.assertIn("'notation1' must match a notation declaration", str(ec.exception))
+
+    def test_enumeration_facet_representation(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="enum1">
+                    <xs:restriction base="xs:string">
+                        <xs:enumeration value="one"/>
+                        <xs:enumeration value="two"/>
+                        <xs:enumeration value="three"/>
+                        <xs:enumeration value="four"/>
+                        <xs:enumeration value="five"/>
+                        <xs:enumeration value="six"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""))
+
+        facet = schema.types'enum1'.get_facet(XSD_ENUMERATION)
+        self.assertEqual(
+            repr(facet), "XsdEnumerationFacets('one', 'two', 'three', 'four', 'five', ...)"
+        )
+        facet.pop()
+        self.assertEqual(
+            repr(facet), "XsdEnumerationFacets('one', 'two', 'three', 'four', 'five')"
+        )
+
+    def test_enumeration_facet_with_float_type(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="enum1">
+                    <xs:restriction base="xs:double">
+                        <xs:enumeration value="1.0"/>
+                        <xs:enumeration value="2.0"/>
+                        <xs:enumeration value="INF"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""))
+
+        facet = schema.types'enum1'.get_facet(XSD_ENUMERATION)
+        self.assertIsNone(facet(1.0))
+        self.assertIsNone(facet(2.0))
+        self.assertIsNone(facet(float('inf')))
+        self.assertRaises(XMLSchemaValidationError, facet, '3.0')
+        self.assertRaises(XMLSchemaValidationError, facet, 3.0)
+        self.assertRaises(XMLSchemaValidationError, facet, float('-inf'))
+        self.assertRaises(XMLSchemaValidationError, facet, float('nan'))
+
+        facet.append(ElementTree.Element(XSD_ENUMERATION, value='-INF'))
+        self.assertIsNone(facet(float('-inf')))
+
+        facet.append(ElementTree.Element(XSD_ENUMERATION, value='NaN'))
+        self.assertIsNone(facet(float('nan')))
+
+    def test_enumeration_facet_derivation(self):
+        with self.assertRaises(XMLSchemaParseError) as ec:
+            self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                    <xs:simpleType name="enum1">
+                        <xs:restriction base="xs:string">
+                            <xs:enumeration value="one"/>
+                            <xs:enumeration value="two"/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                    <xs:simpleType name="enum2">
+                        <xs:restriction base="enum1">
+                            <xs:enumeration value="one"/>
+                            <xs:enumeration value="two"/>
+                            <xs:enumeration value="three"/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                </xs:schema>"""))
+
+        self.assertIn("failed validating 'three'", str(ec.exception))
+
+    def test_pattern_facet(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="pattern1">
+                    <xs:restriction base="xs:string">
+                        <xs:pattern value="\\w+"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""))
+
+        facet = schema.types'pattern1'.get_facet(XSD_PATTERN)
+        self.assertIsNone(facet('abc'))
+        self.assertRaises(XMLSchemaValidationError, facet, '')
+        self.assertRaises(XMLSchemaValidationError, facet, 'a;')
+
+        self.assertRaises(XMLSchemaValidationError, facet, 10)
+        self.assertRaises(XMLSchemaValidationError, facet, None)
+
+        self.assertIs(schema.types'pattern1'.patterns, facet)
+        self.assertIs(facet0, schema.root000)
+        self.assertEqual(facet.patterns0.pattern, r'^(?:\w+)$(?!\n\Z)')  # translated pattern
+
+        # Test MutableSequence API
+        facet.append(ElementTree.Element(XSD_PATTERN, value=r'\s+'))
+        self.assertEqual(len(facet), 2)
+        self.assertEqual(facet.patterns1.pattern, r'^(?:\s+)$(?!\n\Z)')
+        facet1 = (ElementTree.Element(XSD_PATTERN, value=r'\S+'))
+        self.assertEqual(facet.patterns1.pattern, r'^(?:\S+)$(?!\n\Z)')
+        del facet1
+        self.assertEqual(len(facet), 1)
+
+        schema = self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                    <xs:simpleType name="pattern1">
+                        <xs:restriction base="xs:string">
+                            <xs:pattern/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                    <xs:simpleType name="pattern2">
+                        <xs:restriction base="xs:string">
+                            <xs:pattern value=""/>
+                        </xs:restriction>
+                    </xs:simpleType>                    
+                </xs:schema>"""), validation='lax')
+
+        self.assertEqual(len(schema.all_errors), 2)
+        self.assertIn("missing required attribute 'value'", str(schema.all_errors0))
+        self.assertIn("unexpected meta character '' at position 0", str(schema.all_errors1))
+
+    def test_get_annotation__issue_255(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="enum1">
+                    <xs:restriction base="xs:string">
+                        <xs:enumeration value="one">
+                            <xs:annotation>
+                                <xs:documentation>1st facet</xs:documentation>
+                            </xs:annotation>
+                        </xs:enumeration>
+                        <xs:enumeration value="two"/>
+                        <xs:enumeration value="three">
+                            <xs:annotation>
+                                <xs:documentation>3rd facet</xs:documentation>
+                            </xs:annotation>
+                        </xs:enumeration>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""))
+
+        facet = schema.types'enum1'.get_facet(XSD_ENUMERATION)
+        self.assertEqual(facet.annotation.documentation0.text, '1st facet')
+        self.assertEqual(facet.get_annotation(0).documentation0.text, '1st facet')
+        self.assertIsNone(facet.get_annotation(1))
+        self.assertEqual(facet.get_annotation(2).documentation0.text, '3rd facet')
+
+        with self.assertRaises(IndexError):
+            facet.get_annotation(3)
+
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="pattern1">
+                    <xs:restriction base="xs:string">
+                        <xs:pattern value="\\w+"/>
+                        <xs:pattern value=".+">
+                            <xs:annotation>
+                                <xs:documentation>2nd facet</xs:documentation>
+                            </xs:annotation>
+                        </xs:pattern>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""))
+
+        facet = schema.types'pattern1'.get_facet(XSD_PATTERN)
+        self.assertIsNone(facet.get_annotation(0))
+        self.assertEqual(facet.get_annotation(1).documentation0.text, '2nd facet')
+
+        with self.assertRaises(IndexError):
+            facet.get_annotation(2)
+
+    def test_fixed_value(self):
+        with self.assertRaises(XMLSchemaParseError) as ec:
+            self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                    <xs:simpleType name="string30">
+                        <xs:restriction base="xs:string">
+                            <xs:maxLength value="30" fixed="true"/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                    <xs:simpleType name="string20">
+                        <xs:restriction base="string30">
+                            <xs:maxLength value="20"/>
+                        </xs:restriction>
+                    </xs:simpleType>                
+                </xs:schema>"""))
+
+        self.assertIn("'maxLength' facet value is fixed to 30", str(ec.exception))
+
+
+class TestXsd11Identities(TestXsdFacets):
+
+    schema_class = XMLSchema11
+
+    def test_explicit_timezone_facet(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="date1">
+                    <xs:restriction base="xs:date">
+                        <xs:explicitTimezone value="optional"/>
+                    </xs:restriction>
+                </xs:simpleType>
+                <xs:simpleType name="date2">
+                    <xs:restriction base="xs:date">
+                        <xs:explicitTimezone value="required"/>
+                    </xs:restriction>
+                </xs:simpleType>
+                <xs:simpleType name="date3">
+                    <xs:restriction base="xs:date">
+                        <xs:explicitTimezone value="prohibited"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""))
+
+        self.assertTrue(schema.types'date1'.is_valid('2020-03-01'))
+        self.assertTrue(schema.types'date2'.is_valid('2020-03-01Z'))
+        self.assertFalse(schema.types'date2'.is_valid('2020-03-01'))
+        self.assertTrue(schema.types'date3'.is_valid('2020-03-01'))
+        self.assertFalse(schema.types'date3'.is_valid('2020-03-01Z'))
+
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="date1">
+                    <xs:restriction base="xs:date">
+                        <xs:explicitTimezone value="none"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""), validation='lax')
+
+        self.assertIn("value must be one of 'optional',", str(schema.all_errors0))
+
+    def test_explicit_timezone_facet_restriction(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="date1">
+                    <xs:restriction base="xs:date">
+                        <xs:explicitTimezone value="optional"/>
+                    </xs:restriction>
+                </xs:simpleType>
+                <xs:simpleType name="date2">
+                    <xs:restriction base="date1">
+                        <xs:explicitTimezone value="required"/>
+                    </xs:restriction>
+                </xs:simpleType>
+                <xs:simpleType name="date3">
+                    <xs:restriction base="date1">
+                        <xs:explicitTimezone value="prohibited"/>
+                    </xs:restriction>
+                </xs:simpleType>
+                <xs:simpleType name="date4">
+                    <xs:restriction base="date2">
+                        <xs:explicitTimezone value="required"/>
+                    </xs:restriction>
+                </xs:simpleType>
+                <xs:simpleType name="date5">
+                    <xs:restriction base="date3">
+                        <xs:explicitTimezone value="prohibited"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""))
+
+        self.assertTrue(schema.types'date1'.is_valid('2020-03-01'))
+        self.assertTrue(schema.types'date2'.is_valid('2020-03-01Z'))
+        self.assertFalse(schema.types'date2'.is_valid('2020-03-01'))
+        self.assertTrue(schema.types'date3'.is_valid('2020-03-01'))
+        self.assertFalse(schema.types'date3'.is_valid('2020-03-01Z'))
+
+        derivations = ('required', 'prohibited'), ('required', 'optional'),
+                       ('prohibited', 'required'), ('prohibited', 'optional')
+
+        for base_facet, facet in derivations:
+            with self.assertRaises(XMLSchemaParseError):
+                self.schema_class(dedent(f"""\
+                    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                        <xs:simpleType name="date1">
+                            <xs:restriction base="xs:date">
+                                <xs:explicitTimezone value="{base_facet}"/>
+                            </xs:restriction>
+                        </xs:simpleType>
+                        <xs:simpleType name="date2">
+                            <xs:restriction base="date1">
+                                <xs:explicitTimezone value="{facet}"/>
+                            </xs:restriction>
+                        </xs:simpleType>
+                    </xs:schema>"""))
+
+    def test_assertion_facet(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="string1">
+                    <xs:restriction base="xs:string">
+                        <xs:assertion test="true()"/>
+                    </xs:restriction>
+                </xs:simpleType>
+                <xs:simpleType name="string2">
+                    <xs:restriction base="xs:string">
+                        <xs:assertion test="last()" 
+                                      xpathDefaultNamespace="http://xpath.test/ns"/>
+                    </xs:restriction>
+                </xs:simpleType>
+                <xs:simpleType name="string3">
+                    <xs:restriction base="xs:string">
+                        <xs:assertion test="position()"/>
+                    </xs:restriction>
+                </xs:simpleType>
+                
+                <xs:simpleType name="integer_list">
+                    <xs:list itemType="xs:integer"/>
+                </xs:simpleType>
+                <xs:simpleType name="integer_vector">
+                   <xs:restriction base="integer_list">
+                       <xs:assertion test="count($value) eq 3" />
+                   </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""))
+
+        facet = schema.types'string1'.get_facet(XSD_ASSERTION)
+        self.assertIsNone(facet(''))
+        self.assertEqual(facet.xpath_default_namespace, '')
+
+        facet = schema.types'string2'.get_facet(XSD_ASSERTION)
+        self.assertEqual(facet.xpath_default_namespace, 'http://xpath.test/ns')
+        with self.assertRaises(XMLSchemaValidationError) as ec:
+            facet('')
+        self.assertIn("err:XPDY0002 context item size is undefined", str(ec.exception))
+
+        with self.assertRaises(XMLSchemaValidationError) as ec:
+            schema.types'string3'.get_facet(XSD_ASSERTION)('')
+        self.assertIn("err:XPDY0002 context item position is undefined", str(ec.exception))
+
+        facet = schema.types'integer_vector'.get_facet(XSD_ASSERTION)
+        self.assertIsNone(facet(1, 2, 3))
+        self.assertEqual(facet.parser.variable_types, {'value': 'xs:anySimpleType'})
+
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:simpleType name="string1">
+                    <xs:restriction base="xs:string">
+                        <xs:assertion />
+                    </xs:restriction>
+                </xs:simpleType>
+                <xs:simpleType name="string2">
+                    <xs:restriction base="xs:string">
+                        <xs:assertion test="???"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:schema>"""), validation='lax')
+
+        self.assertEqual(len(schema.all_errors), 2)
+        self.assertIn("missing attribute 'test'", str(schema.all_errors0))
+        self.assertIn("err:XPST0003 unexpected '?' symbol", str(schema.all_errors1))
+
+
+if __name__ == '__main__':
+    import platform
+    header_template = "Test xmlschema's XSD facets with Python {} on {}"
+    header = header_template.format(platform.python_version(), platform.platform())
+    print('{0}\n{1}\n{0}'.format("*" * len(header), header))
+
+    unittest.main()

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/validators/test_global_maps.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/validators/test_global_maps.py Changed

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/validators/test_groups.py Added

@@ -0,0 +1,347 @@
+#!/usr/bin/env python
+#
+# Copyright (c), 2016-2020, SISSA (International School for Advanced Studies).
+# All rights reserved.
+# This file is distributed under the terms of the MIT License.
+# See the file 'LICENSE' in the root directory of the present
+# distribution, or http://opensource.org/licenses/MIT.
+#
+# @author Davide Brunato <brunato@sissa.it>
+#
+import unittest
+from typing import Any, Union, List, Optional
+
+from xmlschema import XMLSchemaModelError, XMLSchemaModelDepthError
+from xmlschema.exceptions import XMLSchemaValueError
+from xmlschema.validators.particles import ParticleMixin
+from xmlschema.validators.groups import XsdGroup
+
+
+class ModelGroup(XsdGroup):
+    """A subclass for testing XSD models, that disables element parsing and schema bindings."""
+
+    def __init__(self, model: str, min_occurs: int = 1, max_occurs: Optionalint = 1) -> None:
+        ParticleMixin.__init__(self, min_occurs, max_occurs)
+        if model not in {'sequence', 'choice', 'all'}:
+            raise XMLSchemaValueError("invalid model {!r} for a group".format(model))
+        self._group: ListUnionParticleMixin, 'ModelGroup' = 
+        self.model: str = model
+
+    def __repr__(self) -> str:
+        return '%s(model=%r, occurs=%r)' % (self.__class__.__name__, self.model, self.occurs)
+
+    append: Any
+
+
+class TestXsdGroups(unittest.TestCase):
+
+    def test_model_group_init(self):
+        group = ModelGroup('sequence')
+        self.assertEqual(group.model, 'sequence')
+
+        with self.assertRaises(ValueError):
+            ModelGroup('mixed')
+
+    def test_model_group_repr(self):
+        group = ModelGroup('choice')
+        self.assertEqual(repr(group), "ModelGroup(model='choice', occurs=(1, 1))")
+
+    def test_model_group_container(self):
+        # group: ListGroupItemType
+        group = ModelGroup('choice')
+
+        group.append(('a',))
+        self.assertListEqual(group:, ('a',))
+
+        group0 = ('a', 'b')
+        self.assertListEqual(group:, ('a', 'b'))
+
+        group.append(('c',))
+        self.assertListEqual(group:, ('a', 'b'), ('c',))
+
+        del group0
+        self.assertListEqual(group:, ('c',))
+
+    def test_is_empty(self):
+        group = ModelGroup('all')
+        self.assertTrue(group.is_empty())
+        group.append(('A',))
+        self.assertFalse(group.is_empty())
+
+    def test_is_pointless(self):
+        root_group = ModelGroup('choice')
+        group = ModelGroup('sequence')
+        root_group.append(group)
+
+        self.assertTrue(group.is_pointless(parent=root_group))
+        group.append(('A',))
+        self.assertTrue(group.is_pointless(parent=root_group))
+        group.append(('B',))
+        self.assertFalse(group.is_pointless(parent=root_group))
+
+        root_group = ModelGroup('sequence')
+        group = ModelGroup('choice')
+        root_group.append(group)
+
+        self.assertTrue(group.is_pointless(parent=root_group))
+        group.append(('A',))
+        self.assertTrue(group.is_pointless(parent=root_group))
+        group.append(('B',))
+        self.assertFalse(group.is_pointless(parent=root_group))
+
+        root_group = ModelGroup('choice')
+        group = ModelGroup('choice')
+        root_group.append(group)
+
+        self.assertTrue(group.is_pointless(parent=root_group))
+        group.append(('A',))
+        self.assertTrue(group.is_pointless(parent=root_group))
+        group.append(('B',))
+        self.assertTrue(group.is_pointless(parent=root_group))
+
+    def test_effective_min_occurs(self):
+        group = ModelGroup('sequence')
+        self.assertEqual(group.effective_min_occurs, 0)
+        group.append(ParticleMixin())
+        self.assertEqual(group.effective_min_occurs, 1)
+        group.append(ParticleMixin())
+        group0.min_occurs = 0
+        self.assertEqual(group.effective_min_occurs, 1)
+        group.model = 'choice'
+        self.assertEqual(group.effective_min_occurs, 0)
+        group1.min_occurs = 0
+        group.model = 'sequence'
+        self.assertEqual(group.effective_min_occurs, 0)
+        group.model = 'choice'
+        group0.min_occurs = group1.min_occurs = 1
+        self.assertEqual(group.effective_min_occurs, 1)
+
+    def test_effective_max_occurs(self):
+        group = ModelGroup('sequence')
+        self.assertEqual(group.effective_max_occurs, 0)
+        group.append(ParticleMixin())
+        self.assertEqual(group.effective_max_occurs, 1)
+        group.append(ParticleMixin(max_occurs=2))
+        self.assertEqual(group.effective_max_occurs, 1)
+        group0.min_occurs = group0.max_occurs = 0
+        self.assertEqual(group.effective_max_occurs, 2)
+        group1.min_occurs = group1.max_occurs = 0
+        self.assertEqual(group.effective_max_occurs, 0)
+
+        group.append(ParticleMixin())
+        self.assertEqual(group.effective_max_occurs, 1)
+        group2.min_occurs = 0
+        self.assertEqual(group.effective_max_occurs, 1)
+        group0.max_occurs = None
+        self.assertIsNone(group.effective_max_occurs)
+        group2.min_occurs = 1
+
+        group = ModelGroup('choice')
+        group.append(ParticleMixin())
+        self.assertEqual(group.effective_max_occurs, 1)
+        group.append(ParticleMixin())
+        group0.min_occurs = group0.max_occurs = 0
+        self.assertEqual(group.effective_max_occurs, 1)
+        group0.max_occurs = None
+        self.assertIsNone(group.effective_max_occurs)
+
+        group = ModelGroup('sequence')
+        group.append(ParticleMixin())
+        self.assertEqual(group.effective_max_occurs, 1)
+        group0.max_occurs = None
+        self.assertIsNone(group.effective_max_occurs)
+        group0.max_occurs = 1
+        self.assertEqual(group.effective_max_occurs, 1)
+        group.max_occurs = None
+        self.assertIsNone(group.effective_max_occurs)
+
+    def test_has_occurs_restriction(self):
+        group = ModelGroup('sequence')
+        other = ModelGroup('sequence')
+        other.append(ParticleMixin())
+        self.assertTrue(group.has_occurs_restriction(other))
+        group.append(ParticleMixin())
+        self.assertTrue(group.has_occurs_restriction(other))
+
+        for model in 'sequence', 'all', 'choice':
+            group = ModelGroup(model)
+            group.append(ParticleMixin())
+            self.assertTrue(group.has_occurs_restriction(other=ParticleMixin()))
+            self.assertFalse(group.has_occurs_restriction(other=ParticleMixin(2, 2)))
+            self.assertTrue(group.has_occurs_restriction(other=ParticleMixin(1, None)))
+            group.max_occurs = None
+            self.assertFalse(group.has_occurs_restriction(other=ParticleMixin()))
+            self.assertTrue(group.has_occurs_restriction(other=ParticleMixin(1, None)))
+
+    def test_iter_model(self):
+        # Model group with pointless inner groups
+        root_group = group = ModelGroup('sequence')
+        for k in range(3):
+            for _ in range(k + 1):
+                group.append(ParticleMixin())
+            group.append(ModelGroup('sequence'))
+            group = group-1
+
+        particles = e for e in root_group.iter_model()
+        self.assertEqual(len(particles), 6)
+        for e in particles:
+            self.assertIsInstance(e, ParticleMixin)
+            self.assertNotIsInstance(e, ModelGroup)
+
+        # Model group with no-pointless inner groups
+        root_group = group = ModelGroup('sequence')
+        for k in range(3):
+            for _ in range(k + 1):
+                group.append(ParticleMixin())
+            group.append(ModelGroup('sequence', max_occurs=None))
+            group = group-1
+
+        particles = e for e in root_group.iter_model()
+        self.assertEqual(len(particles), 2)
+        self.assertIsInstance(particles0, ParticleMixin)
+        self.assertNotIsInstance(particles0, ModelGroup)
+        self.assertIsInstance(particles1, ModelGroup)
+
+        # Model group with an excessive depth
+        root_group = group = ModelGroup('sequence')
+        for k in range(16):
+            group.append(ParticleMixin())
+            group.append(ModelGroup('sequence'))
+            group = group1
+
+        with self.assertRaises(XMLSchemaModelDepthError):
+            for _ in root_group.iter_model():
+                pass
+
+    def test_iter_elements(self):
+        # Model group with pointless inner groups
+        root_group = group = ModelGroup('sequence')
+        for k in range(3):
+            for _ in range(k + 1):
+                group.append(ParticleMixin())
+            group.append(ModelGroup('sequence'))
+            group = group-1
+
+        particles = e for e in root_group.iter_elements()
+        self.assertEqual(len(particles), 6)
+        for e in particles:
+            self.assertIsInstance(e, ParticleMixin)
+            self.assertNotIsInstance(e, ModelGroup)
+
+        # Model group with no-pointless inner groups
+        root_group = group = ModelGroup('sequence')
+        for k in range(3):
+            for _ in range(k + 1):
+                group.append(ParticleMixin())
+            group.append(ModelGroup('sequence', max_occurs=None))
+            group = group-1
+
+        particles = e for e in root_group.iter_elements()
+        self.assertEqual(len(particles), 6)
+        for e in particles:
+            self.assertIsInstance(e, ParticleMixin)
+            self.assertNotIsInstance(e, ModelGroup)
+
+        root_group.min_occurs = root_group.max_occurs = 0
+        self.assertListEqual(list(root_group.iter_elements()), )
+
+        # Model group with an excessive depth
+        root_group = group = ModelGroup('sequence')
+        for k in range(16):
+            group.append(ParticleMixin())
+            group.append(ModelGroup('sequence'))
+            group = group1
+
+        with self.assertRaises(XMLSchemaModelDepthError):
+            for _ in root_group.iter_elements():
+                pass
+
+    def test_get_subgroups(self):
+        # Model group with pointless inner groups
+        root_group = group = ModelGroup('sequence')
+        subgroups = 
+        for k in range(4):
+            for _ in range(k + 1):
+                group.append(ParticleMixin())
+            group.append(ModelGroup('sequence'))
+            subgroups.append(group)
+            group = group-1
+
+        self.assertListEqual(root_group.get_subgroups(group), subgroups)
+        self.assertListEqual(root_group.get_subgroups(subgroups-10), subgroups)
+        self.assertListEqual(root_group.get_subgroups(subgroups-20), subgroups:-1)
+        self.assertListEqual(root_group.get_subgroups(subgroups-30), subgroups:-2)
+        self.assertListEqual(root_group.get_subgroups(subgroups-40), subgroups:-3)
+
+        with self.assertRaises(XMLSchemaModelError):
+            root_group.get_subgroups(ParticleMixin())
+
+        # Model group with an excessive depth
+        root_group = group = ModelGroup('sequence')
+        for k in range(18):
+            group.append(ParticleMixin())
+            group.append(ModelGroup('sequence'))
+            group = group1
+
+        with self.assertRaises(XMLSchemaModelDepthError):
+            root_group.get_subgroups(group)
+
+    def test_overall_min_occurs(self):
+        root_group = group = ModelGroup('sequence')
+        subgroups = 
+        for k in range(4):
+            group.append(ParticleMixin())
+            group.append(ModelGroup('sequence', max_occurs=10))
+            subgroups.append(group)
+            group = group-1
+
+        self.assertEqual(root_group.overall_min_occurs(group), 1)
+        root_group1.min_occurs = 0
+        self.assertEqual(root_group.overall_min_occurs(group), 0)
+        root_group11.min_occurs = 2
+        self.assertEqual(root_group.overall_min_occurs(group), 0)
+        root_group1.min_occurs = 1
+        self.assertEqual(root_group.overall_min_occurs(group), 2)
+        root_group1.min_occurs = 3
+        self.assertEqual(root_group.overall_min_occurs(group), 6)
+
+        root_group = group = ModelGroup('choice')
+        subgroups = 
+        for k in range(4):
+            group.append(ParticleMixin())
+            group.append(ModelGroup('choice', max_occurs=10))
+            subgroups.append(group)
+            group = group-1
+
+        self.assertEqual(root_group.overall_min_occurs(group), 0)
+
+    def test_overall_max_occurs(self):
+        root_group = group = ModelGroup('sequence', min_occurs=0)
+        subgroups = 
+        for k in range(4):
+            group.append(ParticleMixin())
+            group.append(ModelGroup('sequence', min_occurs=0))
+            subgroups.append(group)
+            group = group-1
+
+        self.assertEqual(root_group.overall_max_occurs(group), 1)
+        root_group1.max_occurs = 0
+        self.assertEqual(root_group.overall_max_occurs(group), 0)
+        root_group11.max_occurs = 2
+        self.assertEqual(root_group.overall_max_occurs(group), 0)
+        root_group1.max_occurs = 1
+        self.assertEqual(root_group.overall_max_occurs(group), 2)
+        root_group1.max_occurs = 3
+        self.assertEqual(root_group.overall_max_occurs(group), 6)
+        root_group1.max_occurs = None
+        self.assertIsNone(root_group.overall_max_occurs(group))
+
+
+if __name__ == '__main__':
+    import platform
+
+    header_template = "Test xmlschema's XSD groups with Python {} on {}"
+    header = header_template.format(platform.python_version(), platform.platform())
+    print('{0}\n{1}\n{0}'.format("*" * len(header), header))
+
+    unittest.main()

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/validators/test_identities.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/validators/test_identities.py Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/validators/test_models.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/validators/test_models.py Changed

@@ -12,14 +12,34 @@
 import unittest
 import os.path
 from textwrap import dedent
+from typing import Any, Union, List, Optional
 
 from xmlschema import XMLSchema10, XMLSchema11
-from xmlschema.validators import XsdElement, ModelVisitor, XMLSchemaValidationError
-from xmlschema.validators.particles import ParticleMixin, ModelGroup
-from xmlschema.validators.models import distinguishable_paths
+from xmlschema.exceptions import XMLSchemaValueError
+from xmlschema.validators.exceptions import XMLSchemaValidationError
+from xmlschema.validators.particles import ParticleMixin
+from xmlschema.validators.models import distinguishable_paths, ModelVisitor
+from xmlschema.validators.groups import XsdGroup
+from xmlschema.validators.elements import XsdElement
 from xmlschema.testing import XsdValidatorTestCase
 
 
+class ModelGroup(XsdGroup):
+    """A subclass for testing XSD models, that disables element parsing and schema bindings."""
+
+    def __init__(self, model: str, min_occurs: int = 1, max_occurs: Optionalint = 1) -> None:
+        ParticleMixin.__init__(self, min_occurs, max_occurs)
+        if model not in {'sequence', 'choice', 'all'}:
+            raise XMLSchemaValueError("invalid model {!r} for a group".format(model))
+        self._group: ListUnionParticleMixin, 'ModelGroup' = 
+        self.model: str = model
+
+    def __repr__(self) -> str:
+        return '%s(model=%r, occurs=%r)' % (self.__class__.__name__, self.model, self.occurs)
+
+    append: Any
+
+
 class TestModelValidation(XsdValidatorTestCase):
 
     TEST_CASES_DIR = os.path.join(os.path.dirname(__file__), '../test_cases')

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/validators/test_particles.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/validators/test_particles.py Changed

@@ -11,10 +11,9 @@
 import os
 import unittest
 
-from xmlschema import XMLSchema10, XMLSchemaParseError, \
-    XMLSchemaModelError, XMLSchemaModelDepthError
+from xmlschema import XMLSchema10, XMLSchemaParseError
 from xmlschema.etree import ElementTree
-from xmlschema.validators.particles import ParticleMixin, ModelGroup
+from xmlschema.validators.particles import ParticleMixin
 
 CASES_DIR = os.path.join(os.path.dirname(__file__), '../test_cases')
 
@@ -27,8 +26,8 @@
         cls.schema = XMLSchema10(xsd_file)
 
     def test_occurs_property(self):
-        self.assertListEqual(self.schema.elements'cars'.occurs, 1, 1)
-        self.assertListEqual(self.schema.elements'cars'.type.content0.occurs, 0, None)
+        self.assertEqual(self.schema.elements'cars'.occurs, (1, 1))
+        self.assertEqual(self.schema.elements'cars'.type.content0.occurs, (0, None))
 
     def test_effective_min_occurs_property(self):
         self.assertEqual(self.schema.elements'cars'.effective_min_occurs, 1)
@@ -121,6 +120,11 @@
         self.assertTrue(xsd_group9.has_occurs_restriction(xsd_group1))
         self.assertTrue(xsd_group9.has_occurs_restriction(xsd_group2))
 
+    def test_default_parse_error(self):
+        with self.assertRaises(ValueError) as ctx:
+            ParticleMixin().parse_error('unexpected error')
+        self.assertEqual(str(ctx.exception), 'unexpected error')
+
     def test_parse_particle(self):
         schema = XMLSchema10("""<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
                      <xs:element name="root"/>
@@ -166,313 +170,10 @@
                       str(ctx.exception))
 
 
-class TestModelGroup(unittest.TestCase):
-
-    def test_model_group_init(self):
-        group = ModelGroup('sequence')
-        self.assertEqual(group.model, 'sequence')
-
-        with self.assertRaises(ValueError):
-            ModelGroup('mixed')
-
-    def test_model_group_repr(self):
-        group = ModelGroup('choice')
-        self.assertEqual(repr(group), "ModelGroup(model='choice', occurs=1, 1)")
-
-    def test_model_group_container(self):
-        group = ModelGroup('choice')
-
-        group.append(('a',))
-        self.assertListEqual(group:, ('a',))
-
-        group0 = ('a', 'b')
-        self.assertListEqual(group:, ('a', 'b'))
-
-        group.append(('c',))
-        self.assertListEqual(group:, ('a', 'b'), ('c',))
-
-        del group0
-        self.assertListEqual(group:, ('c',))
-
-    def test_is_empty(self):
-        group = ModelGroup('all')
-        self.assertTrue(group.is_empty())
-        group.append(('A',))
-        self.assertFalse(group.is_empty())
-
-    def test_is_pointless(self):
-        root_group = ModelGroup('choice')
-        group = ModelGroup('sequence')
-        root_group.append(group)
-
-        self.assertTrue(group.is_pointless(parent=root_group))
-        group.append(('A',))
-        self.assertTrue(group.is_pointless(parent=root_group))
-        group.append(('B',))
-        self.assertFalse(group.is_pointless(parent=root_group))
-
-        root_group = ModelGroup('sequence')
-        group = ModelGroup('choice')
-        root_group.append(group)
-
-        self.assertTrue(group.is_pointless(parent=root_group))
-        group.append(('A',))
-        self.assertTrue(group.is_pointless(parent=root_group))
-        group.append(('B',))
-        self.assertFalse(group.is_pointless(parent=root_group))
-
-        root_group = ModelGroup('choice')
-        group = ModelGroup('choice')
-        root_group.append(group)
-
-        self.assertTrue(group.is_pointless(parent=root_group))
-        group.append(('A',))
-        self.assertTrue(group.is_pointless(parent=root_group))
-        group.append(('B',))
-        self.assertTrue(group.is_pointless(parent=root_group))
-
-    def test_effective_min_occurs(self):
-        group = ModelGroup('sequence')
-        self.assertEqual(group.effective_min_occurs, 0)
-        group.append(ParticleMixin())
-        self.assertEqual(group.effective_min_occurs, 1)
-        group.append(ParticleMixin())
-        group0.min_occurs = 0
-        self.assertEqual(group.effective_min_occurs, 1)
-        group.model = 'choice'
-        self.assertEqual(group.effective_min_occurs, 0)
-        group1.min_occurs = 0
-        group.model = 'sequence'
-        self.assertEqual(group.effective_min_occurs, 0)
-        group.model = 'choice'
-        group0.min_occurs = group1.min_occurs = 1
-        self.assertEqual(group.effective_min_occurs, 1)
-
-    def test_effective_max_occurs(self):
-        group = ModelGroup('sequence')
-        self.assertEqual(group.effective_max_occurs, 0)
-        group.append(ParticleMixin())
-        self.assertEqual(group.effective_max_occurs, 1)
-        group.append(ParticleMixin(max_occurs=2))
-        self.assertEqual(group.effective_max_occurs, 1)
-        group0.min_occurs = group0.max_occurs = 0
-        self.assertEqual(group.effective_max_occurs, 2)
-        group1.min_occurs = group1.max_occurs = 0
-        self.assertEqual(group.effective_max_occurs, 0)
-
-        group.append(ParticleMixin())
-        self.assertEqual(group.effective_max_occurs, 1)
-        group2.min_occurs = 0
-        self.assertEqual(group.effective_max_occurs, 1)
-        group0.max_occurs = None
-        self.assertIsNone(group.effective_max_occurs)
-        group2.min_occurs = 1
-
-        group = ModelGroup('choice')
-        group.append(ParticleMixin())
-        self.assertEqual(group.effective_max_occurs, 1)
-        group.append(ParticleMixin())
-        group0.min_occurs = group0.max_occurs = 0
-        self.assertEqual(group.effective_max_occurs, 1)
-        group0.max_occurs = None
-        self.assertIsNone(group.effective_max_occurs)
-
-        group = ModelGroup('sequence')
-        group.append(ParticleMixin())
-        self.assertEqual(group.effective_max_occurs, 1)
-        group0.max_occurs = None
-        self.assertIsNone(group.effective_max_occurs)
-        group0.max_occurs = 1
-        self.assertEqual(group.effective_max_occurs, 1)
-        group.max_occurs = None
-        self.assertIsNone(group.effective_max_occurs)
-
-    def test_has_occurs_restriction(self):
-        group = ModelGroup('sequence')
-        other = ModelGroup('sequence')
-        other.append(ParticleMixin())
-        self.assertTrue(group.has_occurs_restriction(other))
-        group.append(ParticleMixin())
-        self.assertTrue(group.has_occurs_restriction(other))
-
-        for model in 'sequence', 'all', 'choice':
-            group = ModelGroup(model)
-            group.append(ParticleMixin())
-            self.assertTrue(group.has_occurs_restriction(other=ParticleMixin()))
-            self.assertFalse(group.has_occurs_restriction(other=ParticleMixin(2, 2)))
-            self.assertTrue(group.has_occurs_restriction(other=ParticleMixin(1, None)))
-            group.max_occurs = None
-            self.assertFalse(group.has_occurs_restriction(other=ParticleMixin()))
-            self.assertTrue(group.has_occurs_restriction(other=ParticleMixin(1, None)))
-
-    def test_iter_model(self):
-        # Model group with pointless inner groups
-        root_group = group = ModelGroup('sequence')
-        for k in range(3):
-            for _ in range(k + 1):
-                group.append(ParticleMixin())
-            group.append(ModelGroup('sequence'))
-            group = group-1
-
-        particles = e for e in root_group.iter_model()
-        self.assertEqual(len(particles), 6)
-        for e in particles:
-            self.assertIsInstance(e, ParticleMixin)
-            self.assertNotIsInstance(e, ModelGroup)
-
-        # Model group with no-pointless inner groups
-        root_group = group = ModelGroup('sequence')
-        for k in range(3):
-            for _ in range(k + 1):
-                group.append(ParticleMixin())
-            group.append(ModelGroup('sequence', max_occurs=None))
-            group = group-1
-
-        particles = e for e in root_group.iter_model()
-        self.assertEqual(len(particles), 2)
-        self.assertIsInstance(particles0, ParticleMixin)
-        self.assertNotIsInstance(particles0, ModelGroup)
-        self.assertIsInstance(particles1, ModelGroup)
-
-        # Model group with an excessive depth
-        root_group = group = ModelGroup('sequence')
-        for k in range(16):
-            group.append(ParticleMixin())
-            group.append(ModelGroup('sequence'))
-            group = group1
-
-        with self.assertRaises(XMLSchemaModelDepthError):
-            for _ in root_group.iter_model():
-                pass
-
-    def test_iter_elements(self):
-        # Model group with pointless inner groups
-        root_group = group = ModelGroup('sequence')
-        for k in range(3):
-            for _ in range(k + 1):
-                group.append(ParticleMixin())
-            group.append(ModelGroup('sequence'))
-            group = group-1
-
-        particles = e for e in root_group.iter_elements()
-        self.assertEqual(len(particles), 6)
-        for e in particles:
-            self.assertIsInstance(e, ParticleMixin)
-            self.assertNotIsInstance(e, ModelGroup)
-
-        # Model group with no-pointless inner groups
-        root_group = group = ModelGroup('sequence')
-        for k in range(3):
-            for _ in range(k + 1):
-                group.append(ParticleMixin())
-            group.append(ModelGroup('sequence', max_occurs=None))
-            group = group-1
-
-        particles = e for e in root_group.iter_elements()
-        self.assertEqual(len(particles), 6)
-        for e in particles:
-            self.assertIsInstance(e, ParticleMixin)
-            self.assertNotIsInstance(e, ModelGroup)
-
-        root_group.min_occurs = root_group.max_occurs = 0
-        self.assertListEqual(list(root_group.iter_elements()), )
-
-        # Model group with an excessive depth
-        root_group = group = ModelGroup('sequence')
-        for k in range(16):
-            group.append(ParticleMixin())
-            group.append(ModelGroup('sequence'))
-            group = group1
-
-        with self.assertRaises(XMLSchemaModelDepthError):
-            for _ in root_group.iter_elements():
-                pass
-
-    def test_get_subgroups(self):
-        # Model group with pointless inner groups
-        root_group = group = ModelGroup('sequence')
-        subgroups = 
-        for k in range(4):
-            for _ in range(k + 1):
-                group.append(ParticleMixin())
-            group.append(ModelGroup('sequence'))
-            subgroups.append(group)
-            group = group-1
-
-        self.assertListEqual(root_group.get_subgroups(group), subgroups)
-        self.assertListEqual(root_group.get_subgroups(subgroups-10), subgroups)
-        self.assertListEqual(root_group.get_subgroups(subgroups-20), subgroups:-1)
-        self.assertListEqual(root_group.get_subgroups(subgroups-30), subgroups:-2)
-        self.assertListEqual(root_group.get_subgroups(subgroups-40), subgroups:-3)
-
-        with self.assertRaises(XMLSchemaModelError):
-            root_group.get_subgroups(ParticleMixin())
-
-        # Model group with an excessive depth
-        root_group = group = ModelGroup('sequence')
-        for k in range(18):
-            group.append(ParticleMixin())
-            group.append(ModelGroup('sequence'))
-            group = group1
-
-        with self.assertRaises(XMLSchemaModelDepthError):
-            root_group.get_subgroups(group)
-
-    def test_overall_min_occurs(self):
-        root_group = group = ModelGroup('sequence')
-        subgroups = 
-        for k in range(4):
-            group.append(ParticleMixin())
-            group.append(ModelGroup('sequence', max_occurs=10))
-            subgroups.append(group)
-            group = group-1
-
-        self.assertEqual(root_group.overall_min_occurs(group), 1)
-        root_group1.min_occurs = 0
-        self.assertEqual(root_group.overall_min_occurs(group), 0)
-        root_group11.min_occurs = 2
-        self.assertEqual(root_group.overall_min_occurs(group), 0)
-        root_group1.min_occurs = 1
-        self.assertEqual(root_group.overall_min_occurs(group), 2)
-        root_group1.min_occurs = 3
-        self.assertEqual(root_group.overall_min_occurs(group), 6)
-
-        root_group = group = ModelGroup('choice')
-        subgroups = 
-        for k in range(4):
-            group.append(ParticleMixin())
-            group.append(ModelGroup('choice', max_occurs=10))
-            subgroups.append(group)
-            group = group-1
-
-        self.assertEqual(root_group.overall_min_occurs(group), 0)
-
-    def test_overall_max_occurs(self):
-        root_group = group = ModelGroup('sequence', min_occurs=0)
-        subgroups = 
-        for k in range(4):
-            group.append(ParticleMixin())
-            group.append(ModelGroup('sequence', min_occurs=0))
-            subgroups.append(group)
-            group = group-1
-
-        self.assertEqual(root_group.overall_max_occurs(group), 1)
-        root_group1.max_occurs = 0
-        self.assertEqual(root_group.overall_max_occurs(group), 0)
-        root_group11.max_occurs = 2
-        self.assertEqual(root_group.overall_max_occurs(group), 0)
-        root_group1.max_occurs = 1
-        self.assertEqual(root_group.overall_max_occurs(group), 2)
-        root_group1.max_occurs = 3
-        self.assertEqual(root_group.overall_max_occurs(group), 6)
-        root_group1.max_occurs = None
-        self.assertIsNone(root_group.overall_max_occurs(group))
-
-
 if __name__ == '__main__':
     import platform
 
-    header_template = "Test xmlschema's XSD paricles with Python {} on {}"
+    header_template = "Test xmlschema's XSD particles with Python {} on {}"
     header = header_template.format(platform.python_version(), platform.platform())
     print('{0}\n{1}\n{0}'.format("*" * len(header), header))

_service:tar_scm:xmlschema-1.9.2.tar.gz/tests/validators/test_schemas.py Added

@@ -0,0 +1,955 @@
+#!/usr/bin/env python
+#
+# Copyright (c), 2016-2020, SISSA (International School for Advanced Studies).
+# All rights reserved.
+# This file is distributed under the terms of the MIT License.
+# See the file 'LICENSE' in the root directory of the present
+# distribution, or http://opensource.org/licenses/MIT.
+#
+# @author Davide Brunato <brunato@sissa.it>
+#
+import unittest
+import logging
+import tempfile
+import warnings
+import pathlib
+import pickle
+import platform
+import glob
+import os
+import re
+from textwrap import dedent
+
+from xmlschema import XMLSchemaParseError, XMLSchemaIncludeWarning, XMLSchemaImportWarning
+from xmlschema.names import XML_NAMESPACE, LOCATION_HINTS, SCHEMAS_DIR, XSD_ELEMENT, XSI_TYPE
+from xmlschema.etree import etree_element
+from xmlschema.validators import XMLSchemaBase, XMLSchema10, XMLSchema11, \
+    XsdGlobals, Xsd11Attribute
+from xmlschema.testing import SKIP_REMOTE_TESTS, XsdValidatorTestCase
+from xmlschema.validators.schemas import logger
+
+
+class CustomXMLSchema(XMLSchema10):
+    pass
+
+
+class TestXMLSchema10(XsdValidatorTestCase):
+    TEST_CASES_DIR = os.path.join(os.path.dirname(__file__), '../test_cases')
+    maxDiff = None
+
+    class CustomXMLSchema(XMLSchema10):
+        pass
+
+    def test_schema_validation(self):
+        schema = self.schema_class(self.vh_xsd_file)
+        self.assertEqual(schema.validation, 'strict')
+
+        schema = self.schema_class(self.vh_xsd_file, validation='lax')
+        self.assertEqual(schema.validation, 'lax')
+
+        schema = self.schema_class(self.vh_xsd_file, validation='skip')
+        self.assertEqual(schema.validation, 'skip')
+
+        with self.assertRaises(ValueError):
+            self.schema_class(self.vh_xsd_file, validation='none')
+
+    def test_schema_string_repr(self):
+        schema = self.schema_class(self.vh_xsd_file)
+        tmpl = "%s(name='vehicles.xsd', namespace='http://example.com/vehicles')"
+        self.assertEqual(str(schema), tmpl % self.schema_class.__name__)
+
+    def test_schema_copy(self):
+        schema = self.vh_schema.copy()
+        self.assertNotEqual(id(self.vh_schema), id(schema))
+        self.assertNotEqual(id(self.vh_schema.namespaces), id(schema.namespaces))
+        self.assertNotEqual(id(self.vh_schema.maps), id(schema.maps))
+
+    def test_schema_location_hints(self):
+        with warnings.catch_warnings(record=True):
+            warnings.simplefilter("always")
+            schema = self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                    xsi:schemaLocation="http://xmlschema.test/ns schema.xsd">
+                  <xs:element name="root" />
+                </xs:schema>"""))
+
+        self.assertEqual(schema.schema_location, ("http://xmlschema.test/ns", "schema.xsd"))
+        self.assertIsNone(schema.no_namespace_schema_location)
+
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                xsi:noNamespaceSchemaLocation="schema.xsd">
+              <xs:element name="root" />
+            </xs:schema>"""))
+
+        self.assertEqual(schema.schema_location, )
+        self.assertEqual(schema.no_namespace_schema_location, 'schema.xsd')
+
+    def test_target_prefix(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                targetNamespace="http://xmlschema.test/ns">
+              <xs:element name="root" />
+            </xs:schema>"""))
+
+        self.assertEqual(schema.target_prefix, '')
+
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                xmlns:tns="http://xmlschema.test/ns"
+                targetNamespace="http://xmlschema.test/ns">
+              <xs:element name="root" />
+            </xs:schema>"""))
+
+        self.assertEqual(schema.target_prefix, 'tns')
+
+    def test_builtin_types(self):
+        self.assertIn('string', self.schema_class.builtin_types())
+
+        with self.assertRaises(RuntimeError):
+            self.schema_class.meta_schema.builtin_types()
+
+    def test_resolve_qname(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">    
+              <xs:element name="root" />
+            </xs:schema>"""))
+
+        self.assertEqual(schema.resolve_qname('xs:element'), XSD_ELEMENT)
+        self.assertEqual(schema.resolve_qname('xsi:type'), XSI_TYPE)
+
+        self.assertEqual(schema.resolve_qname(XSI_TYPE), XSI_TYPE)
+        self.assertEqual(schema.resolve_qname('element'), 'element')
+        self.assertRaises(ValueError, schema.resolve_qname, '')
+        self.assertRaises(ValueError, schema.resolve_qname, 'xsi:a type ')
+        self.assertRaises(ValueError, schema.resolve_qname, 'xml::lang')
+
+    def test_global_group_definitions(self):
+        schema = self.check_schema("""
+            <xs:group name="wrong_child">
+              <xs:element name="foo"/>
+            </xs:group>""", validation='lax')
+        self.assertEqual(len(schema.errors), 1)
+
+        self.check_schema('<xs:group name="empty" />', XMLSchemaParseError)
+        self.check_schema('<xs:group name="empty"><xs:annotation/></xs:group>', XMLSchemaParseError)
+
+    def test_wrong_includes_and_imports(self):
+
+        with warnings.catch_warnings(record=True) as context:
+            warnings.simplefilter("always")
+            self.check_schema("""
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="ns">
+                <xs:include schemaLocation="example.xsd" />
+                <xs:import schemaLocation="example.xsd" />
+                <xs:redefine schemaLocation="example.xsd"/>
+                <xs:import namespace="http://missing.example.test/" />
+                <xs:import/>
+            </xs:schema>
+            """)
+            self.assertEqual(len(context), 3, "Wrong number of include/import warnings")
+            self.assertEqual(context0.category, XMLSchemaIncludeWarning)
+            self.assertEqual(context1.category, XMLSchemaIncludeWarning)
+            self.assertEqual(context2.category, XMLSchemaImportWarning)
+            self.assertTrue(str(context0.message).startswith("Include"))
+            self.assertTrue(str(context1.message).startswith("Redefine"))
+            self.assertTrue(str(context2.message).startswith("Import of namespace"))
+
+    def test_wrong_references(self):
+        # Wrong namespace for element type's reference
+        self.check_schema("""
+        <xs:element name="dimension" type="xs:dimensionType"/>
+        <xs:simpleType name="dimensionType">
+          <xs:restriction base="xs:short"/>
+        </xs:simpleType>
+        """, XMLSchemaParseError)
+
+    def test_annotations(self):
+        schema = self.check_schema("""
+            <xs:element name='foo'>
+                <xs:annotation />
+            </xs:element>""")
+        xsd_element = schema.elements'foo'
+        self.assertIsNone(xsd_element._annotation)  # lazy annotation
+        self.assertIsNotNone(xsd_element.annotation)
+        self.assertIs(xsd_element.annotation, xsd_element._annotation)
+
+        self.check_schema("""
+        <xs:simpleType name='Magic'>
+            <xs:annotation />
+            <xs:annotation />
+            <xs:restriction base='xs:string'>
+                <xs:enumeration value='A'/>
+            </xs:restriction>
+        </xs:simpleType>""", XMLSchemaParseError)
+
+        schema = self.check_schema("""
+        <xs:simpleType name='Magic'>
+            <xs:annotation>
+                <xs:documentation> stuff </xs:documentation>
+            </xs:annotation>
+            <xs:restriction base='xs:string'>
+                <xs:enumeration value='A'/>
+            </xs:restriction>
+        </xs:simpleType>""")
+
+        xsd_type = schema.types"Magic"
+        self.assertIsNotNone(xsd_type._annotation)  # xs:simpleType annotations are not lazy parsed
+        self.assertEqual(str(xsd_type.annotation), ' stuff ')
+
+    def test_annotation_string(self):
+        schema = self.check_schema("""
+            <xs:element name='A'>
+                <xs:annotation>
+                    <xs:documentation>A element info</xs:documentation>
+                </xs:annotation>
+            </xs:element>
+            <xs:element name='B'>
+                <xs:annotation>
+                    <xs:documentation>B element extended info, line1</xs:documentation>
+                    <xs:documentation>B element extended info, line2</xs:documentation>
+                </xs:annotation>
+            </xs:element>""")
+
+        xsd_element = schema.elements'A'
+        self.assertEqual(str(xsd_element.annotation), 'A element info')
+        self.assertEqual(repr(xsd_element.annotation), "XsdAnnotation('A element info')")
+
+        xsd_element = schema.elements'B'
+        self.assertEqual(str(xsd_element.annotation),
+                         'B element extended info, line1\nB element extended info, line2')
+        self.assertEqual(repr(xsd_element.annotation),
+                         "XsdAnnotation('B element extended info, line1\\nB element')")
+
+    def test_schema_annotations(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:element name="root"/>
+            </xs:schema>"""))
+
+        self.assertIsNone(schema._annotations)
+        annotations = schema.annotations
+        self.assertListEqual(annotations, )
+        self.assertIs(annotations, schema.annotations)
+
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:annotation>
+                    <xs:documentation>First annotation</xs:documentation>
+                </xs:annotation>
+                <xs:annotation>
+                    <xs:documentation>Second annotation</xs:documentation>
+                </xs:annotation>
+                <xs:element name="root"/>
+                <xs:annotation>
+                    <xs:documentation>Third annotation</xs:documentation>
+                </xs:annotation>
+            </xs:schema>"""))
+
+        self.assertIsNone(schema._annotations)
+        annotations = schema.annotations
+        self.assertEqual(len(annotations), 3)
+        self.assertEqual(repr(annotations0), "XsdAnnotation('First annotation')")
+        self.assertEqual(repr(annotations1), "XsdAnnotation('Second annotation')")
+        self.assertEqual(repr(annotations2), "XsdAnnotation('Third annotation')")
+        self.assertIs(annotations, schema.annotations)
+
+    def test_base_schemas(self):
+        xsd_file = os.path.join(SCHEMAS_DIR, 'XML/xml_minimal.xsd')
+        schema = self.schema_class(xsd_file)
+        self.assertEqual(schema.target_namespace, XML_NAMESPACE)
+
+    def test_root_elements(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"/>"""))
+        self.assertEqual(schema.root_elements, )
+
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+              <xs:element name="root" />
+            </xs:schema>"""))
+        self.assertEqual(schema.root_elements, schema.elements'root')
+
+        # Test issue #107 fix
+        schema = self.schema_class(dedent("""\
+            <?xml version="1.0" encoding="utf-8"?>
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:element name="root1" type="root"/>
+                <xs:element name="root2" type="root"/>
+                <xs:complexType name="root">
+                    <xs:sequence>
+                        <xs:element name="elementWithNoType"/>
+                    </xs:sequence>
+                </xs:complexType>
+            </xs:schema>"""))
+
+        self.assertEqual(set(schema.root_elements),
+                         {schema.elements'root1', schema.elements'root2'})
+
+    def test_simple_types(self):
+        self.assertListEqual(self.vh_schema.simple_types, )
+        self.assertGreater(len(self.st_schema.simple_types), 20)
+
+    def test_complex_types(self):
+        self.assertListEqual(self.vh_schema.complex_types,
+                             self.vh_schema.types'vehicleType')
+
+    def test_is_restriction_method(self):
+        # Test issue #111 fix
+        schema = self.schema_class(source=self.casepath('issues/issue_111/issue_111.xsd'))
+        extended_header_def = schema.types'extendedHeaderDef'
+        self.assertTrue(extended_header_def.is_derived(schema.types'blockDef'))
+
+    @unittest.skipIf(SKIP_REMOTE_TESTS, "Remote networks are not accessible.")
+    def test_remote_schemas_loading(self):
+        col_schema = self.schema_class("https://raw.githubusercontent.com/brunato/xmlschema/master/"
+                                       "tests/test_cases/examples/collection/collection.xsd",
+                                       timeout=300)
+        self.assertTrue(isinstance(col_schema, self.schema_class))
+        vh_schema = self.schema_class("https://raw.githubusercontent.com/brunato/xmlschema/master/"
+                                      "tests/test_cases/examples/vehicles/vehicles.xsd",
+                                      timeout=300)
+        self.assertTrue(isinstance(vh_schema, self.schema_class))
+
+    def test_schema_defuse(self):
+        vh_schema = self.schema_class(self.vh_xsd_file, defuse='always')
+        self.assertIsInstance(vh_schema.root, etree_element)
+        for schema in vh_schema.maps.iter_schemas():
+            self.assertIsInstance(schema.root, etree_element)
+
+    def test_logging(self):
+        self.schema_class(self.vh_xsd_file, loglevel=logging.ERROR)
+        self.assertEqual(logger.level, logging.WARNING)
+
+        with self.assertLogs('xmlschema', level='INFO') as ctx:
+            self.schema_class(self.vh_xsd_file, loglevel=logging.INFO)
+
+        self.assertEqual(logger.level, logging.WARNING)
+        self.assertEqual(len(ctx.output), 7)
+        self.assertIn("INFO:xmlschema:Include schema from 'types.xsd'", ctx.output)
+        self.assertIn("INFO:xmlschema:Resource 'types.xsd' is already loaded", ctx.output)
+
+        with self.assertLogs('xmlschema', level='DEBUG') as ctx:
+            self.schema_class(self.vh_xsd_file, loglevel=logging.DEBUG)
+
+        self.assertEqual(logger.level, logging.WARNING)
+        self.assertEqual(len(ctx.output), 19)
+        self.assertIn("INFO:xmlschema:Include schema from 'cars.xsd'", ctx.output)
+        self.assertIn("INFO:xmlschema:Resource 'cars.xsd' is already loaded", ctx.output)
+        self.assertIn("DEBUG:xmlschema:Schema targetNamespace is "
+                      "'http://example.com/vehicles'", ctx.output)
+        self.assertIn("INFO:xmlschema:Resource 'cars.xsd' is already loaded", ctx.output)
+
+        # With string argument
+        with self.assertRaises(ValueError) as ctx:
+            self.schema_class(self.vh_xsd_file, loglevel='all')
+        self.assertEqual(str(ctx.exception), "'all' is not a valid loglevel")
+
+        with self.assertLogs('xmlschema', level='INFO') as ctx:
+            self.schema_class(self.vh_xsd_file, loglevel='INFO')
+        self.assertEqual(len(ctx.output), 7)
+
+        with self.assertLogs('xmlschema', level='INFO') as ctx:
+            self.schema_class(self.vh_xsd_file, loglevel='  Info ')
+        self.assertEqual(len(ctx.output), 7)
+
+    def test_target_namespace(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+                    targetNamespace="http://xmlschema.test/ns">
+                <xs:element name="root"/>
+            </xs:schema>"""))
+        self.assertEqual(schema.target_namespace, 'http://xmlschema.test/ns')
+
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:element name="root"/>
+            </xs:schema>"""))
+        self.assertEqual(schema.target_namespace, '')
+
+        with self.assertRaises(XMLSchemaParseError) as ctx:
+            self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+                        targetNamespace="">
+                    <xs:element name="root"/>
+                </xs:schema>"""))
+
+        self.assertEqual(ctx.exception.message,
+                         "the attribute 'targetNamespace' cannot be an empty string")
+
+    def test_block_default(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+                    blockDefault="extension restriction ">
+                <xs:element name="root"/>
+            </xs:schema>"""))
+        self.assertEqual(schema.block_default, 'extension restriction ')
+
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+                    blockDefault="#all">
+                <xs:element name="root"/>
+            </xs:schema>"""))
+        self.assertEqual(set(schema.block_default.split()),
+                         {'substitution', 'extension', 'restriction'})
+
+        with self.assertRaises(XMLSchemaParseError) as ctx:
+            self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+                        blockDefault="all">>
+                    <xs:element name="root"/>
+                </xs:schema>"""))
+
+        self.assertEqual(ctx.exception.message,
+                         "wrong value 'all' for attribute 'blockDefault'")
+
+        with self.assertRaises(XMLSchemaParseError) as ctx:
+            self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+                        blockDefault="#all restriction">>
+                    <xs:element name="root"/>
+                </xs:schema>"""))
+
+        self.assertEqual(ctx.exception.message,
+                         "wrong value '#all restriction' for attribute 'blockDefault'")
+
+    def test_final_default(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+                    finalDefault="extension restriction ">
+                <xs:element name="root"/>
+            </xs:schema>"""))
+        self.assertEqual(schema.final_default, 'extension restriction ')
+
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+                    finalDefault="#all">
+                <xs:element name="root"/>
+            </xs:schema>"""))
+        self.assertEqual(set(schema.final_default.split()),
+                         {'list', 'union', 'extension', 'restriction'})
+
+        with self.assertRaises(XMLSchemaParseError) as ctx:
+            self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+                        finalDefault="all">>
+                    <xs:element name="root"/>
+                </xs:schema>"""))
+
+        self.assertEqual(ctx.exception.message,
+                         "wrong value 'all' for attribute 'finalDefault'")
+
+    def test_use_fallback(self):
+        source = dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:element name="root"/>
+            </xs:schema>""")
+
+        schema = self.schema_class(source)
+        self.assertEqual(schema.fallback_locations, LOCATION_HINTS)
+        schema = self.schema_class(source, use_fallback=False)
+        self.assertEqual(schema.fallback_locations, {})
+
+    def test_global_maps(self):
+        source = dedent("""\
+                    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                        <xs:element name="root"/>
+                    </xs:schema>""")
+        col_schema = self.schema_class(self.col_xsd_file)
+
+        with self.assertRaises(TypeError) as ctx:
+            self.schema_class(self.col_schema, global_maps=col_schema)
+        self.assertIn("'global_maps' argument must be", str(ctx.exception))
+
+        schema = self.schema_class(source, global_maps=col_schema.maps)
+        self.assertIs(col_schema.maps, schema.maps)
+
+    def test_version_control(self):
+        schema = self.schema_class(dedent("""
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:element name="root">
+                    <xs:complexType>
+                        <xs:attribute name="a" use="required"/>
+                        <xs:assert test="@a > 300" vc:minVersion="1.1" 
+                            xmlns:vc="http://www.w3.org/2007/XMLSchema-versioning"/>
+                    </xs:complexType>
+                </xs:element>
+            </xs:schema>"""))
+        self.assertEqual(len(schema.root00), 1 if schema.XSD_VERSION == '1.0' else 2)
+
+        schema = self.schema_class(dedent("""
+            <xs:schema vc:minVersion="1.1" elementFormDefault="qualified" 
+                    xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+                    xmlns:vc="http://www.w3.org/2007/XMLSchema-versioning">
+                <xs:element name="root"/>
+            </xs:schema>"""))
+        self.assertEqual(len(schema.root), 0 if schema.XSD_VERSION == '1.0' else 1)
+
+    def test_xsd_version_compatibility_property(self):
+        self.assertEqual(self.vh_schema.xsd_version, self.vh_schema.XSD_VERSION)
+
+    def test_explicit_locations(self):
+        source = dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:element name="root"/>
+            </xs:schema>""")
+
+        locations = {'http://example.com/vehicles': self.vh_xsd_file}
+        schema = self.schema_class(source, locations=locations)
+        self.assertEqual(len(schema.maps.namespaces'http://example.com/vehicles'), 4)
+
+    def test_use_meta_property(self):
+        self.assertTrue(self.vh_schema.use_meta)
+        self.assertTrue(self.col_schema.use_meta)
+
+        meta_schema = self.schema_class.meta_schema
+
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:element name="foo"/>
+            </xs:schema>"""), use_meta=False)
+        self.assertIsNot(meta_schema, schema.meta_schema)
+        self.assertFalse(schema.use_meta)
+
+    def test_other_schema_root_attributes(self):
+        self.assertIsNone(self.vh_schema.id)
+        self.assertIsNone(self.vh_schema.version)
+
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" id="foo" version="2.0">
+                <xs:element name="foo"/>
+            </xs:schema>"""))
+        self.assertEqual(schema.id, 'foo')
+        self.assertEqual(schema.version, '2.0')
+
+    def test_change_maps_attribute(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:element name="root"/>
+            </xs:schema>"""))
+
+        with self.assertRaises(ValueError) as ctx:
+            schema.meta_schema.maps = XsdGlobals(schema, schema.validation)
+        self.assertEqual(str(ctx.exception),
+                         "cannot change the global maps instance of a meta-schema")
+
+        self.assertTrue(schema.built)
+        maps, schema.maps = schema.maps, XsdGlobals(schema, schema.validation)
+        self.assertIsNot(maps, schema.maps)
+        self.assertFalse(schema.built)
+        schema.maps = maps
+        self.assertTrue(schema.built)
+
+    def test_listed_and_reversed_elements(self):
+        schema = self.schema_class(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:element name="elem1"/>
+                <xs:element name="elem2"/>
+                <xs:element name="elem3"/>
+            </xs:schema>"""))
+
+        elements = list(schema)
+        self.assertListEqual(elements, schema.elements'elem1',
+                                        schema.elements'elem2',
+                                        schema.elements'elem3')
+        elements.reverse()
+        self.assertListEqual(elements, list(reversed(schema)))
+
+    def test_multi_schema_initialization(self):
+        source1 = dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:element name="elem1"/>
+            </xs:schema>""")
+
+        source2 = dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:element name="elem2"/>
+            </xs:schema>""")
+
+        source3 = dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:element name="elem3"/>
+            </xs:schema>""")
+
+        schema = self.schema_class(source1, source2, source3)
+        self.assertEqual(len(schema.elements), 3)
+        self.assertEqual(len(schema.maps.namespaces''), 3)
+        self.assertIs(schema.elements'elem1'.schema, schema)
+        self.assertIs(schema.elements'elem2'.schema, schema.maps.namespaces''1)
+        self.assertIs(schema.elements'elem3'.schema, schema.maps.namespaces''2)
+
+        with self.assertRaises(XMLSchemaParseError) as ec:
+            self.schema_class(source1, source2, source2)
+        self.assertIn("global element with name='elem2' is already defined", str(ec.exception))
+
+        source1 = dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+                    targetNamespace="http://xmlschema.test/ns">
+                <xs:element name="elem1"/>
+            </xs:schema>""")
+
+        schema = self.schema_class(source1, source2)
+        self.assertEqual(len(schema.elements), 2)
+        self.assertEqual(len(schema.maps.namespaces'http://xmlschema.test/ns'), 2)
+        self.assertIs(schema.elements'elem1'.schema, schema)
+        self.assertIs(schema.elements'elem2'.schema,
+                      schema.maps.namespaces'http://xmlschema.test/ns'1)
+
+    def test_add_schema(self):
+        source1 = dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+                    targetNamespace="http://xmlschema.test/ns">
+                <xs:element name="elem1"/>
+            </xs:schema>""")
+
+        source2 = dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                <xs:element name="elem2"/>
+            </xs:schema>""")
+
+        source3 = dedent("""\
+             <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+                     targetNamespace="http://xmlschema.test/ns1">
+                 <xs:element name="elem3"/>
+             </xs:schema>""")
+
+        schema = self.schema_class(source1)
+        schema.add_schema(source2, build=True)
+        self.assertEqual(len(schema.elements), 1)
+        self.assertEqual(len(schema.maps.namespaces'http://xmlschema.test/ns'), 1)
+        self.assertEqual(len(schema.maps.namespaces''), 1)
+
+        # Less checks on duplicate objects for schemas added after the build
+        schema.add_schema(source2, build=True)
+        self.assertEqual(len(schema.maps.namespaces''), 2)
+        self.assertTrue(schema.maps.built)
+
+        with self.assertRaises(XMLSchemaParseError) as ec:
+            schema.maps.clear()
+            schema.build()
+        self.assertIn("global element with name='elem2' is already defined", str(ec.exception))
+
+        schema = self.schema_class(source1)
+        schema.add_schema(source2, namespace='http://xmlschema.test/ns', build=True)
+        self.assertEqual(len(schema.maps.namespaces'http://xmlschema.test/ns'), 2)
+
+        # Need a rebuild to add elem2 from added schema ...
+        self.assertEqual(len(schema.elements), 1)
+        schema.maps.clear()
+        schema.build()
+        self.assertEqual(len(schema.elements), 2)
+
+        # ... so is better to build after sources additions
+        schema = self.schema_class(source1, build=False)
+        schema.add_schema(source2, namespace='http://xmlschema.test/ns')
+        schema.build()
+        self.assertEqual(len(schema.elements), 2)
+
+        # Adding other namespaces do not require rebuild
+        schema3 = schema.add_schema(source3, build=True)
+        self.assertEqual(len(schema.maps.namespaces'http://xmlschema.test/ns1'), 1)
+        self.assertEqual(len(schema3.elements), 1)
+
+    def test_export_errors__issue_187(self):
+        with self.assertRaises(ValueError) as ctx:
+            self.vh_schema.export(target=self.vh_dir)
+
+        self.assertIn("target directory", str(ctx.exception))
+        self.assertIn("is not empty", str(ctx.exception))
+
+        with self.assertRaises(ValueError) as ctx:
+            self.vh_schema.export(target=self.vh_xsd_file)
+
+        self.assertIn("target", str(ctx.exception))
+        self.assertIn("is not a directory", str(ctx.exception))
+
+        with self.assertRaises(ValueError) as ctx:
+            self.vh_schema.export(target=self.vh_xsd_file + '/target')
+
+        self.assertIn("target parent", str(ctx.exception))
+        self.assertIn("is not a directory", str(ctx.exception))
+
+        with tempfile.TemporaryDirectory() as dirname:
+            with self.assertRaises(ValueError) as ctx:
+                self.vh_schema.export(target=dirname + 'subdir/target')
+
+            self.assertIn("target parent directory", str(ctx.exception))
+            self.assertIn("does not exist", str(ctx.exception))
+
+    def test_export_same_directory__issue_187(self):
+        with tempfile.TemporaryDirectory() as dirname:
+            self.vh_schema.export(target=dirname)
+
+            for filename in os.listdir(dirname):
+                with pathlib.Path(dirname).joinpath(filename).open() as fp:
+                    exported_schema = fp.read()
+                with pathlib.Path(self.vh_dir).joinpath(filename).open() as fp:
+                    original_schema = fp.read()
+
+                if platform.system() == 'Windows':
+                    exported_schema = re.sub(r'\s+', '', exported_schema)
+                    original_schema = re.sub(r'\s+', '', original_schema)
+
+                self.assertEqual(exported_schema, original_schema)
+
+        self.assertFalse(os.path.isdir(dirname))
+
+    def test_export_another_directory__issue_187(self):
+        vh_schema_file = self.casepath('issues/issue_187/issue_187_1.xsd')
+        vh_schema = self.schema_class(vh_schema_file)
+
+        with tempfile.TemporaryDirectory() as dirname:
+            vh_schema.export(target=dirname)
+
+            path = pathlib.Path(dirname).joinpath('examples/vehicles/*.xsd')
+            for filename in glob.iglob(pathname=str(path)):
+                with pathlib.Path(dirname).joinpath(filename).open() as fp:
+                    exported_schema = fp.read()
+
+                basename = os.path.basename(filename)
+                with pathlib.Path(self.vh_dir).joinpath(basename).open() as fp:
+                    original_schema = fp.read()
+
+                if platform.system() == 'Windows':
+                    exported_schema = re.sub(r'\s+', '', exported_schema)
+                    original_schema = re.sub(r'\s+', '', original_schema)
+
+                self.assertEqual(exported_schema, original_schema)
+
+            with pathlib.Path(dirname).joinpath('issue_187_1.xsd').open() as fp:
+                exported_schema = fp.read()
+            with open(vh_schema_file) as fp:
+                original_schema = fp.read()
+
+            if platform.system() == 'Windows':
+                exported_schema = re.sub(r'\s+', '', exported_schema)
+                original_schema = re.sub(r'\s+', '', original_schema)
+
+            self.assertNotEqual(exported_schema, original_schema)
+            self.assertEqual(
+                exported_schema,
+                original_schema.replace('../..', dirname.replace('\\', '/'))
+            )
+
+        self.assertFalse(os.path.isdir(dirname))
+
+    @unittest.skipIf(SKIP_REMOTE_TESTS, "Remote networks are not accessible.")
+    def test_export_remote__issue_187(self):
+        vh_schema_file = self.casepath('issues/issue_187/issue_187_2.xsd')
+        vh_schema = self.schema_class(vh_schema_file)
+
+        with tempfile.TemporaryDirectory() as dirname:
+            vh_schema.export(target=dirname)
+
+            with pathlib.Path(dirname).joinpath('issue_187_2.xsd').open() as fp:
+                exported_schema = fp.read()
+            with open(vh_schema_file) as fp:
+                original_schema = fp.read()
+
+            if platform.system() == 'Windows':
+                exported_schema = re.sub(r'\s+', '', exported_schema)
+                original_schema = re.sub(r'\s+', '', original_schema)
+
+            self.assertEqual(exported_schema, original_schema)
+
+        self.assertFalse(os.path.isdir(dirname))
+
+        with tempfile.TemporaryDirectory() as dirname:
+            vh_schema.export(target=dirname, save_remote=True)
+            path = pathlib.Path(dirname).joinpath('brunato/xmlschema/master/tests/test_cases/'
+                                                  'examples/vehicles/*.xsd')
+
+            for filename in glob.iglob(pathname=str(path)):
+                with pathlib.Path(dirname).joinpath(filename).open() as fp:
+                    exported_schema = fp.read()
+
+                basename = os.path.basename(filename)
+                with pathlib.Path(self.vh_dir).joinpath(basename).open() as fp:
+                    original_schema = fp.read()
+                self.assertEqual(exported_schema, original_schema)
+
+            with pathlib.Path(dirname).joinpath('issue_187_2.xsd').open() as fp:
+                exported_schema = fp.read()
+            with open(vh_schema_file) as fp:
+                original_schema = fp.read()
+
+            if platform.system() == 'Windows':
+                exported_schema = re.sub(r'\s+', '', exported_schema)
+                original_schema = re.sub(r'\s+', '', original_schema)
+
+            self.assertNotEqual(exported_schema, original_schema)
+            self.assertEqual(
+                exported_schema,
+                original_schema.replace('https://raw.githubusercontent.com',
+                                        dirname.replace('\\', '/') + '/raw.githubusercontent.com')
+            )
+
+        self.assertFalse(os.path.isdir(dirname))
+
+    def test_pickling_subclassed_schema__issue_263(self):
+        cases_dir = pathlib.Path(__file__).parent.parent
+        schema_file = cases_dir.joinpath('test_cases/examples/vehicles/vehicles.xsd')
+        xml_file = cases_dir.joinpath('test_cases/examples/vehicles/vehicles.xml')
+
+        schema = self.CustomXMLSchema(str(schema_file))
+        self.assertTrue(schema.is_valid(str(xml_file)))
+
+        self.assertIs(self.schema_class.meta_schema, schema.meta_schema)
+        self.assertNotIn(schema.meta_schema.__class__.__name__, globals())
+
+        s = pickle.dumps(schema)
+        _schema = pickle.loads(s)
+        self.assertTrue(_schema.is_valid(str(xml_file)))
+
+        class CustomLocalXMLSchema(self.schema_class):
+            pass
+
+        schema = CustomLocalXMLSchema(str(schema_file))
+        self.assertTrue(schema.is_valid(str(xml_file)))
+
+        with self.assertRaises((pickle.PicklingError, AttributeError)) as ec:
+            pickle.dumps(schema)
+        self.assertIn("Can't pickle", str(ec.exception))
+
+    def test_old_subclassing_attribute(self):
+
+        with warnings.catch_warnings(record=True) as ctx:
+            warnings.simplefilter("always")
+
+            class OldXMLSchema10(XMLSchema10):
+                BUILDERS = {
+                    'attribute_class': Xsd11Attribute,
+                }
+
+            self.assertEqual(len(ctx), 1, "Expected one import warning")
+            self.assertIn("'BUILDERS' will be removed in v2.0", str(ctx0.message))
+
+        self.assertIs(OldXMLSchema10.xsd_attribute_class, Xsd11Attribute)
+
+        name = OldXMLSchema10.meta_schema.__class__.__name__
+        self.assertEqual(name, 'MetaXMLSchema10')
+        self.assertNotIn(name, globals())
+
+    def test_default_namespace_mapping__issue_266(self):
+        schema_file = self.casepath('issues/issue_266/issue_266b-1.xsd')
+        with self.assertRaises(XMLSchemaParseError) as ec:
+            self.schema_class(schema_file)
+
+        error_message = str(ec.exception)
+        self.assertIn("the QName 'testAttribute3' is mapped to no namespace", error_message)
+        self.assertIn("requires that there is an xs:import statement", error_message)
+
+
+class TestXMLSchema11(TestXMLSchema10):
+
+    schema_class = XMLSchema11
+
+    class CustomXMLSchema(XMLSchema11):
+        pass
+
+    def test_default_attributes(self):
+        schema = self.schema_class(dedent("""\
+                    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+                            defaultAttributes="attrs">
+                        <xs:element name="root"/>
+                        <xs:attributeGroup name="attrs">
+                            <xs:attribute name="a"/>
+                        </xs:attributeGroup>
+                    </xs:schema>"""))
+        self.assertIs(schema.default_attributes, schema.attribute_groups'attrs')
+
+        with self.assertRaises(XMLSchemaParseError) as ctx:
+            self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+                        defaultAttributes="attrs">
+                    <xs:element name="root"/>
+                </xs:schema>"""))
+        self.assertIn("'attrs' doesn't match an attribute group", ctx.exception.message)
+
+        with self.assertRaises(XMLSchemaParseError) as ctx:
+            self.schema_class(dedent("""\
+                <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+                        defaultAttributes="x:attrs">
+                    <xs:element name="root"/>
+                </xs:schema>"""))
+        self.assertEqual("prefix 'x' not found in namespace map", ctx.exception.message)
+
+
+class TestXMLSchemaMeta(unittest.TestCase):
+
+    def test_wrong_version(self):
+        with self.assertRaises(ValueError) as ctx:
+            class XMLSchema12(XMLSchemaBase):
+                XSD_VERSION = '1.2'
+                meta_schema = os.path.join(SCHEMAS_DIR, 'XSD_1.1/XMLSchema.xsd')
+
+            assert issubclass(XMLSchema12, XMLSchemaBase)
+
+        self.assertEqual(str(ctx.exception), "XSD_VERSION must be '1.0' or '1.1'")
+
+    def test_from_schema_class(self):
+        class XMLSchema11Bis(XMLSchema11):
+            pass
+
+        self.assertTrue(issubclass(XMLSchema11Bis, XMLSchemaBase))
+
+    def test_dummy_validator_class(self):
+
+        class DummySchema(XMLSchemaBase):
+            XSD_VERSION = '1.1'
+            meta_schema = os.path.join(SCHEMAS_DIR, 'XSD_1.1/XMLSchema.xsd')
+
+        self.assertTrue(issubclass(DummySchema, XMLSchemaBase))
+
+    def test_subclass_but_no_replace_meta_schema(self):
+
+        class CustomXMLSchema10(XMLSchema10):
+            pass
+
+        self.assertIsInstance(CustomXMLSchema10.meta_schema, XMLSchemaBase)
+        self.assertIs(CustomXMLSchema10.meta_schema, XMLSchema10.meta_schema)
+
+        name = CustomXMLSchema10.meta_schema.__class__.__name__
+        self.assertEqual(name, 'MetaXMLSchema10')
+        self.assertNotIn(name, globals())
+
+    def test_subclass_and_replace_meta_schema(self):
+
+        class CustomXMLSchema10(XMLSchema10):
+            meta_schema = os.path.join(SCHEMAS_DIR, 'XSD_1.0/XMLSchema.xsd')
+
+        self.assertIsInstance(CustomXMLSchema10.meta_schema, XMLSchemaBase)
+        self.assertIsNot(CustomXMLSchema10.meta_schema, XMLSchema10.meta_schema)
+
+        name = CustomXMLSchema10.meta_schema.__class__.__name__
+        self.assertEqual(name, 'MetaCustomXMLSchema10')
+        self.assertIn(name, globals())
+
+        bases = CustomXMLSchema10.meta_schema.__class__.__bases__
+        self.assertEqual(bases, (XMLSchema10.meta_schema.__class__,))
+
+    def test_subclass_and_create_base_meta_schema(self):
+
+        class CustomXMLSchema10(XMLSchemaBase):
+            meta_schema = os.path.join(SCHEMAS_DIR, 'XSD_1.0/XMLSchema.xsd')
+
+        self.assertIsInstance(CustomXMLSchema10.meta_schema, XMLSchemaBase)
+        self.assertIsNot(CustomXMLSchema10.meta_schema, XMLSchema10.meta_schema)
+
+        name = CustomXMLSchema10.meta_schema.__class__.__name__
+        self.assertEqual(name, 'MetaCustomXMLSchema10')
+        self.assertIn(name, globals())
+
+        bases = CustomXMLSchema10.meta_schema.__class__.__bases__
+        self.assertEqual(bases, (XMLSchemaBase,))
+
+
+if __name__ == '__main__':
+    header_template = "Test xmlschema's schema classes with Python {} on {}"
+    header = header_template.format(platform.python_version(), platform.platform())
+    print('{0}\n{1}\n{0}'.format("*" * len(header), header))
+
+    unittest.main()

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/validators/test_simple_types.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/validators/test_simple_types.py Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/tests/validators/test_xsdbase.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tests/validators/test_xsdbase.py Changed

@@ -12,11 +12,15 @@
 import os
 import platform
 import re
-import lxml.etree
 from textwrap import dedent
 
-from xmlschema.validators import XsdValidator, XsdComponent, XMLSchema10, \
-    XMLSchema11, XMLSchemaParseError, XMLSchemaValidationError, XsdGroup, XsdSimpleType
+try:
+    import lxml.etree as lxml_etree
+except ImportError:
+    lxml_etree = None
+
+from xmlschema.validators import XsdValidator, XsdComponent, XMLSchema10, XMLSchema11, \
+    XMLSchemaParseError, XMLSchemaValidationError, XsdAnnotation, XsdGroup, XsdSimpleType
 from xmlschema.names import XSD_NAMESPACE, XSD_ELEMENT, XSD_ANNOTATION, XSD_ANY_TYPE
 from xmlschema.etree import ElementTree
 from xmlschema.dataobjects import DataElement
@@ -159,6 +163,25 @@
         with self.assertRaises(ValueError):
             XsdComponent(elem=ElementTree.Element('A'), schema=self.schema)
 
+    def test_errors(self):
+        schema = XMLSchema10(dedent("""<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+            <xs:element name="root" type="xs:string">
+                <xs:simpleType>
+                    <xs:restriction base="xs:string"/>
+                </xs:simpleType>
+            </xs:element>
+        </xs:schema>"""), validation='lax')
+
+        xsd_element = schema.elements'root'
+        self.assertEqual(len(schema.all_errors), 1)
+        self.assertEqual(len(xsd_element.errors), 1)
+
+        xsd_element.elem.attrib.pop('type')
+        xsd_element.elem = xsd_element.elem
+
+        self.assertEqual(len(schema.all_errors), 0)
+        self.assertEqual(len(xsd_element.errors), 0)
+
     def test_is_override(self):
         self.assertFalse(self.schema.elements'cars'.is_override())
         self.assertFalse(self.schema.elements'cars'.type.content0.is_override())
@@ -421,7 +444,7 @@
         self.assertIn('name="car" type="vh:vehicleType"', cars_dump)
         self.assertIsInstance(ElementTree.XML(cars_dump), ElementTree.Element)
 
-    def test_annotation(self):
+    def test_annotations(self):
         schema = XMLSchema10("""<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
                      <xs:element name="root">
                          <xs:annotation/>
@@ -429,14 +452,24 @@
                  </xs:schema>""")
         self.assertTrue(schema.elements'root'.annotation.built)
 
-        root = lxml.etree.XML("""<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+        schema = XMLSchema10("""<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
                      <xs:element name="root">
-                        
-                        <xs:annotation/>
+                         <xs:simpleType>
+                             <xs:restriction base="xs:string"/>
+                         </xs:simpleType>
                      </xs:element>
                  </xs:schema>""")
-        schema = XMLSchema10(root)
-        self.assertTrue(schema.elements'root'.annotation.built)
+        self.assertIsNone(schema.elements'root'.annotation)
+
+        if lxml_etree is not None:
+            root = lxml_etree.XML("""<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+                         <xs:element name="root">
+                            
+                            <xs:annotation/>
+                         </xs:element>
+                     </xs:schema>""")
+            schema = XMLSchema10(root)
+            self.assertTrue(schema.elements'root'.annotation.built)
 
         schema = XMLSchema10("""<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
                      <xs:element name="root">
@@ -448,6 +481,7 @@
                  </xs:schema>""")
         self.assertEqual(len(schema.all_errors), 0)
 
+        # XSD annotation errors found with meta-schema validation
         schema = XMLSchema10("""<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
                      <xs:element name="root">
                          <xs:annotation>
@@ -459,83 +493,94 @@
                  </xs:schema>""", validation='lax')
         self.assertEqual(len(schema.all_errors), 3)
 
+        # Lazy XSD annotation build (errors not counted in schema.all_errors)
+        xsd_element = schema.elements'root'
+        self.assertNotIn('_annotation', xsd_element.__dict__)
+        annotation = xsd_element.annotation
+        self.assertIsInstance(annotation, XsdAnnotation)
+        self.assertIn('_annotation', xsd_element.__dict__)
+        self.assertEqual(len(schema.all_errors), 3)
+        self.assertEqual(len(annotation.errors), 2)
+        self.assertIsNone(annotation.annotation)
+
 
 class TestXsdType(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.schema = XMLSchema10("""<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
-
-                     <xs:simpleType name="emptyType">
-                         <xs:restriction base="xs:string">
-                             <xs:length value="0"/>
+        cls.schema = XMLSchema10(dedent("""\
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+            
+                 <xs:simpleType name="emptyType">
+                     <xs:restriction base="xs:string">
+                         <xs:length value="0"/>
+                     </xs:restriction>
+                 </xs:simpleType>
+
+                 <xs:complexType name="emptyType2">
+                     <xs:attribute name="foo" type="xs:string"/>
+                 </xs:complexType>        
+
+                 <xs:simpleType name="idType">
+                     <xs:restriction base="xs:ID"/>
+                 </xs:simpleType>
+
+                 <xs:simpleType name="decimalType">
+                     <xs:restriction base="xs:decimal"/>
+                 </xs:simpleType>
+
+                 <xs:simpleType name="dateTimeType">
+                     <xs:restriction base="xs:dateTime"/>
+                 </xs:simpleType>
+                 
+                 <xs:simpleType name="fooType">
+                     <xs:restriction base="xs:string"/>
+                 </xs:simpleType>
+
+                 <xs:simpleType name="fooListType">
+                     <xs:list itemType="xs:string"/>
+                 </xs:simpleType>
+
+                 <xs:simpleType name="fooUnionType">
+                     <xs:union memberTypes="xs:string xs:anyURI"/>
+                 </xs:simpleType>
+                 
+                 <xs:complexType name="barType">
+                     <xs:sequence>
+                         <xs:element name="node"/>
+                     </xs:sequence>
+                 </xs:complexType>        
+
+                 <xs:complexType name="barExtType">
+                     <xs:complexContent>
+                         <xs:extension base="barType">
+                             <xs:sequence>
+                                 <xs:element name="node"/>
+                             </xs:sequence>
+                         </xs:extension>
+                     </xs:complexContent>
+                 </xs:complexType>        
+
+                 <xs:complexType name="barResType">
+                     <xs:complexContent>
+                         <xs:restriction base="barType">
+                             <xs:sequence>
+                                 <xs:element name="node"/>
+                             </xs:sequence>
                          </xs:restriction>
-                     </xs:simpleType>
-
-                     <xs:complexType name="emptyType2">
-                         <xs:attribute name="foo" type="xs:string"/>
-                     </xs:complexType>        
+                     </xs:complexContent>
+                 </xs:complexType>        
 
-                     <xs:simpleType name="idType">
-                         <xs:restriction base="xs:ID"/>
-                     </xs:simpleType>
+                 <xs:complexType name="mixedType" mixed="true">
+                     <xs:sequence>
+                         <xs:element name="node" type="xs:string"/>
+                     </xs:sequence>
+                 </xs:complexType>        
 
-                     <xs:simpleType name="decimalType">
-                         <xs:restriction base="xs:decimal"/>
-                     </xs:simpleType>
-
-                     <xs:simpleType name="dateTimeType">
-                         <xs:restriction base="xs:dateTime"/>
-                     </xs:simpleType>
+                 <xs:element name="fooElem" type="fooType"/>
+                 <xs:element name="barElem" type="barType" block="extension"/>
                      
-                     <xs:simpleType name="fooType">
-                         <xs:restriction base="xs:string"/>
-                     </xs:simpleType>
-
-                     <xs:simpleType name="fooListType">
-                         <xs:list itemType="xs:string"/>
-                     </xs:simpleType>
-
-                     <xs:simpleType name="fooUnionType">
-                         <xs:union memberTypes="xs:string xs:anyURI"/>
-                     </xs:simpleType>
-                     
-                     <xs:complexType name="barType">
-                         <xs:sequence>
-                             <xs:element name="node"/>
-                         </xs:sequence>
-                     </xs:complexType>        
-
-                     <xs:complexType name="barExtType">
-                         <xs:complexContent>
-                             <xs:extension base="barType">
-                                 <xs:sequence>
-                                     <xs:element name="node"/>
-                                 </xs:sequence>
-                             </xs:extension>
-                         </xs:complexContent>
-                     </xs:complexType>        
-
-                     <xs:complexType name="barResType">
-                         <xs:complexContent>
-                             <xs:restriction base="barType">
-                                 <xs:sequence>
-                                     <xs:element name="node"/>
-                                 </xs:sequence>
-                             </xs:restriction>
-                         </xs:complexContent>
-                     </xs:complexType>        
-
-                     <xs:complexType name="mixedType" mixed="true">
-                         <xs:sequence>
-                             <xs:element name="node" type="xs:string"/>
-                         </xs:sequence>
-                     </xs:complexType>        
-
-                     <xs:element name="fooElem" type="fooType"/>
-                     <xs:element name="barElem" type="barType" block="extension"/>
-                     
-                 </xs:schema>""")
+            </xs:schema>"""))
 
     def test_content_type_label(self):
         self.assertEqual(self.schema.types'emptyType'.content_type_label, 'empty')
@@ -562,6 +607,11 @@
         self.assertIs(self.schema.types'barExtType'.root_type,
                       self.schema.maps.typesXSD_ANY_TYPE)
 
+        # xs:anyType used by the schema is equivalent but is not the same object of
+        # the meta schema because it can be used as base for schema's complex types
+        self.assertIs(self.schema.types'emptyType2'.root_type,
+                      self.schema.maps.typesXSD_ANY_TYPE)
+
     def test_is_atomic(self):
         self.assertFalse(self.schema.types'barType'.is_atomic())

_service:tar_scm:xmlschema-1.5.2.tar.gz/tox.ini -> _service:tar_scm:xmlschema-1.9.2.tar.gz/tox.ini Changed

@@ -4,21 +4,21 @@
 # and then run "tox" from this directory.
 
 tox
-envlist = py{36,37,38,39}, pypy3, ep21{2,3,4}, ep220, docs, flake8, coverage
+envlist = py{36,37,38,39,310}, pypy3, ep{240},
+    docs, flake8, mypy-py{36,37,38,39,310}, coverage, pytest
 skip_missing_interpreters = true
 toxworkdir = {homedir}/.tox/xmlschema
 
 testenv
 deps =
-    elementpath>=2.1.2, <3.0.0
+    elementpath>=2.4.0, <3.0.0
     lxml
-    py{37,38,39}: memory_profiler
-    codegen: jinja2
+    jinja2
+    py{38,39}: memory_profiler
     docs: Sphinx
     docs: sphinx_rtd_theme
     flake8: flake8
     coverage: coverage
-    coverage: jinja2
 commands =
     python -m unittest tests/test_etree_import.py -k before
     python -m unittest tests/test_etree_import.py -k after
@@ -36,24 +36,9 @@
 testenv:pypy3
 commands = python -m unittest
 
-testenv:ep212
+testenv:ep240
 deps =
-    elementpath==2.1.2
-    lxml
-
-testenv:ep213
-deps =
-    elementpath==2.1.3
-    lxml
-
-testenv:ep214
-deps =
-    elementpath==2.1.4
-    lxml
-
-testenv:ep220
-deps =
-    elementpath==2.2.0
+    elementpath==2.4.0
     lxml
 
 testenv:docs
@@ -67,7 +52,26 @@
 
 testenv:flake8
 commands =
-    flake8 --ignore=F811,W503 xmlschema
+    flake8 xmlschema
+
+testenv:mypy-py{36,37}
+deps =
+    mypy==0.930
+    elementpath==2.4.0
+    lxml-stubs
+    jinja2
+commands =
+    mypy --config-file {toxinidir}/mypy.ini xmlschema
+
+testenv:mypy-py{38,39,310}
+deps =
+    mypy==0.930
+    elementpath==2.4.0
+    lxml-stubs
+    jinja2
+commands =
+    mypy --config-file {toxinidir}/mypy.ini xmlschema
+    python tests/test_typing.py
 
 testenv:coverage
 commands =
@@ -78,6 +82,18 @@
     coverage run -a -m unittest
     coverage report -m
 
+testenv:pytest
+deps =
+    pytest
+    pytest-randomly
+    elementpath>=2.4.0, <3.0.0
+    lxml
+    jinja2
+    mypy==0.930
+    lxml-stubs
+commands =
+    pytest tests -ra
+
 testenv:build
 deps =
     setuptools

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema.egg-info/PKG-INFO -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema.egg-info/PKG-INFO Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema.egg-info/SOURCES.txt -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema.egg-info/SOURCES.txt Changed

@@ -34,6 +34,7 @@
 tests/test_package.py
 tests/test_resources.py
 tests/test_schemas.py
+tests/test_typing.py
 tests/test_validation.py
 tests/test_w3c_suite.py
 tests/test_wsdl.py
@@ -46,6 +47,7 @@
 tests/templates/filters/sort_types_filter_test.jinja
 tests/templates/filters/type_name_filter_test.jinja
 tests/templates/filters/type_qname_filter_test.jinja
+tests/templates/filters/unknown_filter_test.jinja
 tests/templates/filters/wrong-template.jinja
 tests/test_cases/testfiles
 tests/test_cases/examples/collection/collection-1_error.xml
@@ -84,6 +86,9 @@
 tests/test_cases/features/decoder/data.xml
 tests/test_cases/features/decoder/data2.xml
 tests/test_cases/features/decoder/data3.xml
+tests/test_cases/features/decoder/data4-mixed.xml
+tests/test_cases/features/decoder/long-sequence-1.xsd
+tests/test_cases/features/decoder/mixed-content.xsd
 tests/test_cases/features/decoder/simple-types.xsd
 tests/test_cases/features/derivations/complex-extensions.xsd
 tests/test_cases/features/derivations/complex-with-simple-content-restriction.xsd
@@ -208,6 +213,34 @@
 tests/test_cases/issues/issue_222/issue_222.xsd
 tests/test_cases/issues/issue_223/issue_223.xml
 tests/test_cases/issues/issue_223/issue_223.xsd
+tests/test_cases/issues/issue_237/dir1/issue_237.xsd
+tests/test_cases/issues/issue_237/dir1/stockquoteservice.wsdl
+tests/test_cases/issues/issue_237/dir2/issue_237a.xsd
+tests/test_cases/issues/issue_237/dir2/issue_237b.xsd
+tests/test_cases/issues/issue_237/dir2/stockquote.wsdl
+tests/test_cases/issues/issue_237/dir2/stockquote.xsd
+tests/test_cases/issues/issue_243/issue_243.xml
+tests/test_cases/issues/issue_243/issue_243.xsd
+tests/test_cases/issues/issue_245/issue_245-valid.xml
+tests/test_cases/issues/issue_245/issue_245.xml
+tests/test_cases/issues/issue_245/issue_245.xsd
+tests/test_cases/issues/issue_259/issue_259-1.xsd
+tests/test_cases/issues/issue_259/issue_259-2.xsd
+tests/test_cases/issues/issue_265/issue_265-1.xsd
+tests/test_cases/issues/issue_265/issue_265-2-invalid.xsd
+tests/test_cases/issues/issue_265/issue_265-2-override.xsd
+tests/test_cases/issues/issue_266/issue_266-1.xml
+tests/test_cases/issues/issue_266/issue_266-1.xsd
+tests/test_cases/issues/issue_266/issue_266-2.xml
+tests/test_cases/issues/issue_266/issue_266-2.xsd
+tests/test_cases/issues/issue_266/issue_266b-1.xsd
+tests/test_cases/issues/issue_266/issue_266b-2.xsd
+tests/test_cases/issues/issue_273/issue_273.xml
+tests/test_cases/issues/issue_273/issue_273.xsd
+tests/test_cases/issues/issue_276/dummy.xml
+tests/test_cases/issues/issue_276/schema.xsd
+tests/test_cases/mypy/schema_source.py
+tests/test_cases/mypy/simple_types.py
 tests/test_cases/resources/dummy file #2.txt
 tests/test_cases/resources/dummy file.txt
 tests/test_cases/resources/external_entity.xml
@@ -226,16 +259,19 @@
 tests/validators/test_complex_types.py
 tests/validators/test_elements.py
 tests/validators/test_exceptions.py
+tests/validators/test_facets.py
 tests/validators/test_global_maps.py
+tests/validators/test_groups.py
 tests/validators/test_identities.py
 tests/validators/test_models.py
 tests/validators/test_notations.py
 tests/validators/test_particles.py
-tests/validators/test_schema_class.py
+tests/validators/test_schemas.py
 tests/validators/test_simple_types.py
 tests/validators/test_wildcards.py
 tests/validators/test_xsdbase.py
 xmlschema/__init__.py
+xmlschema/aliases.py
 xmlschema/cli.py
 xmlschema/dataobjects.py
 xmlschema/documents.py
@@ -245,6 +281,7 @@
 xmlschema/limits.py
 xmlschema/names.py
 xmlschema/namespaces.py
+xmlschema/py.typed
 xmlschema/resources.py
 xmlschema/xpath.py
 xmlschema.egg-info/PKG-INFO
@@ -302,7 +339,7 @@
 xmlschema/validators/models.py
 xmlschema/validators/notations.py
 xmlschema/validators/particles.py
-xmlschema/validators/schema.py
+xmlschema/validators/schemas.py
 xmlschema/validators/simple_types.py
 xmlschema/validators/wildcards.py
 xmlschema/validators/xsdbase.py
\ No newline at end of file

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema.egg-info/requires.txt -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema.egg-info/requires.txt Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/__init__.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/__init__.py Changed

@@ -10,16 +10,16 @@
 #
 from . import limits
 from .exceptions import XMLSchemaException, XMLResourceError, XMLSchemaNamespaceError
-from .etree import etree_tostring
+from .etree import ElementData, etree_tostring
 from .resources import normalize_url, normalize_locations, fetch_resource, \
     fetch_namespaces, fetch_schema_locations, fetch_schema, XMLResource
 from .xpath import ElementPathMixin
-from .converters import ElementData, XMLSchemaConverter, \
+from .converters import XMLSchemaConverter, \
     UnorderedConverter, ParkerConverter, BadgerFishConverter, \
     AbderaConverter, JsonMLConverter, ColumnarConverter
 from .dataobjects import DataElement, DataElementConverter, DataBindingConverter
-from .documents import validate, is_valid, iter_errors, to_dict, to_json, \
-    from_json, XmlDocument
+from .documents import validate, is_valid, iter_errors, iter_decode, \
+    to_dict, to_json, from_json, XmlDocument
 
 from .validators import (
     XMLSchemaValidatorError, XMLSchemaParseError, XMLSchemaNotBuiltError,
@@ -30,7 +30,7 @@
     XsdComponent, XsdType, XsdElement, XsdAttribute
 )
 
-__version__ = '1.5.2'
+__version__ = '1.9.2'
 __author__ = "Davide Brunato"
 __contact__ = "brunato@sissa.it"
 __copyright__ = "Copyright 2016-2021, SISSA"
@@ -45,11 +45,12 @@
     'ElementPathMixin', 'ElementData', 'XMLSchemaConverter', 'UnorderedConverter',
     'ParkerConverter', 'BadgerFishConverter', 'AbderaConverter', 'JsonMLConverter',
     'ColumnarConverter', 'DataElement', 'DataElementConverter', 'DataBindingConverter',
-    'validate', 'is_valid', 'iter_errors', 'to_dict', 'to_json', 'from_json', 'XmlDocument',
-    'XMLSchemaValidatorError', 'XMLSchemaParseError', 'XMLSchemaNotBuiltError',
-    'XMLSchemaModelError', 'XMLSchemaModelDepthError', 'XMLSchemaValidationError',
-    'XMLSchemaDecodeError', 'XMLSchemaEncodeError', 'XMLSchemaChildrenValidationError',
-    'XMLSchemaIncludeWarning', 'XMLSchemaImportWarning', 'XMLSchemaTypeTableWarning',
+    'validate', 'is_valid', 'iter_errors', 'iter_decode', 'to_dict', 'to_json',
+    'from_json', 'XmlDocument', 'XMLSchemaValidatorError', 'XMLSchemaParseError',
+    'XMLSchemaNotBuiltError', 'XMLSchemaModelError', 'XMLSchemaModelDepthError',
+    'XMLSchemaValidationError', 'XMLSchemaDecodeError', 'XMLSchemaEncodeError',
+    'XMLSchemaChildrenValidationError', 'XMLSchemaIncludeWarning',
+    'XMLSchemaImportWarning', 'XMLSchemaTypeTableWarning',
     'XsdGlobals', 'XMLSchemaBase', 'XMLSchema', 'XMLSchema10', 'XMLSchema11',
     'XsdComponent', 'XsdType', 'XsdElement', 'XsdAttribute',

_service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/aliases.py Added

@@ -0,0 +1,111 @@
+#
+# Copyright (c), 2021, SISSA (International School for Advanced Studies).
+# All rights reserved.
+# This file is distributed under the terms of the MIT License.
+# See the file 'LICENSE' in the root directory of the present
+# distribution, or http://opensource.org/licenses/MIT.
+#
+# @author Davide Brunato <brunato@sissa.it>
+#
+"""
+Type aliases for static typing analysis. In a type checking context the aliases
+are defined from effective classes imported from package modules. In a runtime
+context the aliases cannot be set from the same bases, due to circular imports,
+so they are set with a common dummy subscriptable type to keep compatibility.
+"""
+from typing import TYPE_CHECKING, Optional, TypeVar
+
+__all__ = 'ElementType', 'ElementTreeType', 'XMLSourceType', 'NamespacesType',
+           'NormalizedLocationsType', 'LocationsType', 'NsmapType', 'ParentMapType',
+           'LazyType', 'SchemaType', 'BaseXsdType', 'SchemaElementType',
+           'SchemaAttributeType', 'SchemaGlobalType', 'GlobalMapType', 'ModelGroupType',
+           'ModelParticleType', 'XPathElementType', 'AtomicValueType', 'NumericValueType',
+           'DateTimeType', 'SchemaSourceType', 'ConverterType', 'ComponentClassType',
+           'ExtraValidatorType', 'DecodeType', 'IterDecodeType', 'JsonDecodeType',
+           'EncodeType', 'IterEncodeType', 'DecodedValueType', 'EncodedValueType'
+
+if TYPE_CHECKING:
+    from pathlib import Path
+    from decimal import Decimal
+    from typing import Callable, Dict, List, IO, Iterator, MutableMapping, Tuple, Type, Union
+
+    from elementpath.datatypes import NormalizedString, QName, Float10, Integer, \
+        Time, Base64Binary, HexBinary, AnyURI, Duration
+    from elementpath.datatypes.datetime import OrderedDateTime
+
+    from .etree import ElementTree
+    from .resources import XMLResource
+    from .converters import XMLSchemaConverter
+    from .validators import XMLSchemaValidationError, XsdComponent, XMLSchemaBase, \
+        XsdComplexType, XsdSimpleType, XsdElement, XsdAnyElement, XsdAttribute, \
+        XsdAnyAttribute, XsdAssert, XsdGroup, XsdAttributeGroup, XsdNotation
+
+    ##
+    # Type aliases for ElementTree
+    ElementType = ElementTree.Element
+    ElementTreeType = ElementTree.ElementTree
+    XMLSourceType = Unionstr, bytes, Path, IOstr, IObytes, ElementType, ElementTreeType
+    NamespacesType = MutableMappingstr, str
+
+    ##
+    # Type aliases for XML resources
+    NormalizedLocationsType = ListTuplestr, str
+    LocationsType = UnionTupleTuplestr, str, ..., Dictstr, str, NormalizedLocationsType
+    NsmapType = UnionListTuplestr, str, MutableMappingstr, str
+    ParentMapType = DictElementType, OptionalElementType
+    LazyType = Unionbool, int
+
+    ##
+    # Type aliases for XSD components
+    SchemaSourceType = Unionstr, bytes, Path, IOstr, IObytes, XMLResource,
+                             ElementTree.Element, ElementTree.ElementTree
+    SchemaType = XMLSchemaBase
+    BaseXsdType = UnionXsdSimpleType, XsdComplexType
+    SchemaElementType = UnionXsdElement, XsdAnyElement
+    SchemaAttributeType = UnionXsdAttribute, XsdAnyAttribute
+    SchemaGlobalType = UnionXsdNotation, BaseXsdType, XsdElement,
+                             XsdAttribute, XsdAttributeGroup, XsdGroup
+
+    ModelGroupType = XsdGroup
+    ModelParticleType = UnionXsdElement, XsdAnyElement, XsdGroup
+    ComponentClassType = UnionNone, TypeXsdComponent, TupleTypeXsdComponent, ...
+    XPathElementType = UnionXsdElement, XsdAnyElement, XsdAssert
+
+    C = TypeVar('C')
+    GlobalMapType = Dictstr, UnionC, TupleElementType, SchemaType
+
+    ##
+    # Type aliases for datatypes
+    AtomicValueType = Unionstr, int, float, Decimal, bool, Integer, Float10, NormalizedString,
+                            AnyURI, HexBinary, Base64Binary, QName, Duration, OrderedDateTime, Time
+    NumericValueType = Unionstr, bytes, int, float, Decimal
+    DateTimeType = UnionOrderedDateTime, Time
+
+    ##
+    # Type aliases for validation/decoding/encoding
+    ConverterType = UnionTypeXMLSchemaConverter, XMLSchemaConverter
+    ExtraValidatorType = CallableElementType, SchemaType,
+                                  OptionalIteratorXMLSchemaValidationError
+
+    D = TypeVar('D')
+    DecodeType = UnionOptionalD, TupleOptionalD, ListXMLSchemaValidationError
+    IterDecodeType = IteratorUnionD, XMLSchemaValidationError
+
+    E = TypeVar('E')
+    EncodeType = UnionE, TupleE, ListXMLSchemaValidationError
+    IterEncodeType = IteratorUnionE, XMLSchemaValidationError
+
+    JsonDecodeType = Unionstr, None, TupleXMLSchemaValidationError, ...,
+                           TupleUnionstr, None, TupleXMLSchemaValidationError, ...
+
+    DecodedValueType = UnionNone, AtomicValueType, ListAtomicValueType
+    EncodedValueType = UnionNone, str, Liststr
+
+else:
+    # In runtime use a dummy subscriptable type for compatibility
+    T = TypeVar('T')
+    DummyType = OptionalT
+
+    module_globals = globals()
+    for name in __all__:
+        module_globalsname = DummyType

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/cli.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/cli.py Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/converters/__init__.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/converters/__init__.py Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/converters/abdera.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/converters/abdera.py Changed

@@ -8,9 +8,15 @@
 # @author Davide Brunato <brunato@sissa.it>
 #
 from collections.abc import MutableMapping, MutableSequence
+from typing import TYPE_CHECKING, Any, Optional, List, Dict, Type, Union
 
 from ..exceptions import XMLSchemaValueError
-from .default import ElementData, XMLSchemaConverter
+from ..etree import ElementData
+from ..aliases import NamespacesType, BaseXsdType
+from .default import XMLSchemaConverter
+
+if TYPE_CHECKING:
+    from ..validators import XsdElement
 
 
 class AbderaConverter(XMLSchemaConverter):
@@ -24,17 +30,23 @@
     :param dict_class: Dictionary class to use for decoded data. Default is `dict`.
     :param list_class: List class to use for decoded data. Default is `list`.
     """
-    def __init__(self, namespaces=None, dict_class=None, list_class=None, **kwargs):
+    __slots__ = ()
+
+    def __init__(self, namespaces: OptionalNamespacesType = None,
+                 dict_class: OptionalTypeDictstr, Any = None,
+                 list_class: OptionalTypeListAny = None,
+                 **kwargs: Any) -> None:
         kwargs.update(attr_prefix='', text_key='', cdata_prefix=None)
         super(AbderaConverter, self).__init__(
             namespaces, dict_class, list_class, **kwargs
         )
 
     @property
-    def lossy(self):
+    def lossy(self) -> bool:
         return True  # Loss cdata parts
 
-    def element_decode(self, data, xsd_element, xsd_type=None, level=0):
+    def element_decode(self, data: ElementData, xsd_element: 'XsdElement',
+                       xsd_type: OptionalBaseXsdType = None, level: int = 0) -> Any:
         xsd_type = xsd_type or xsd_element.type
         if xsd_type.simple_type is not None:
             children = data.text if data.text is not None and data.text != '' else None
@@ -72,7 +84,7 @@
         else:
             return children if children is not None else self.list()
 
-    def element_encode(self, obj, xsd_element, level=0):
+    def element_encode(self, obj: Any, xsd_element: 'XsdElement', level: int = 0) -> ElementData:
         tag = xsd_element.qualified_name if level == 0 else xsd_element.name
 
         if not isinstance(obj, MutableMapping):
@@ -80,7 +92,9 @@
                 obj = None
             return ElementData(tag, obj, None, {})
         else:
-            attributes = {}
+            attributes: Dictstr, Any = {}
+            children: UnionListAny, MutableMappingstr, Any
+
             try:
                 attributes.update((self.unmap_qname(k, xsd_element.attributes), v)
                                   for k, v in obj'attributes'.items())
@@ -107,11 +121,16 @@
                         for item in value:
                             content.append((ns_name, item))
                     else:
+                        xsd_group = xsd_element.type.model_group
+                        if xsd_group is None:
+                            xsd_group = xsd_element.any_type.model_group
+                            assert xsd_group is not None
+
                         ns_name = self.unmap_qname(name)
-                        for xsd_child in xsd_element.type.content.iter_elements():
+                        for xsd_child in xsd_group.iter_elements():
                             matched_element = xsd_child.match(ns_name, resolve=True)
                             if matched_element is not None:
-                                if matched_element.type.is_list():
+                                if matched_element.type and matched_element.type.is_list():
                                     content.append((ns_name, value))
                                 else:
                                     content.extend((ns_name, item) for item in value)

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/converters/badgerfish.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/converters/badgerfish.py Changed

@@ -8,8 +8,14 @@
 # @author Davide Brunato <brunato@sissa.it>
 #
 from collections.abc import MutableMapping, MutableSequence
+from typing import TYPE_CHECKING, Any, Optional, List, Dict, Type, Union, Tuple
 
-from .default import ElementData, XMLSchemaConverter
+from ..etree import ElementData
+from ..aliases import NamespacesType, BaseXsdType
+from .default import XMLSchemaConverter
+
+if TYPE_CHECKING:
+    from ..validators import XsdElement
 
 
 class BadgerFishConverter(XMLSchemaConverter):
@@ -23,17 +29,23 @@
     :param dict_class: Dictionary class to use for decoded data. Default is `dict`.
     :param list_class: List class to use for decoded data. Default is `list`.
     """
-    def __init__(self, namespaces=None, dict_class=None, list_class=None, **kwargs):
+    __slots__ = ()
+
+    def __init__(self, namespaces: OptionalNamespacesType = None,
+                 dict_class: OptionalTypeDictstr, Any = None,
+                 list_class: OptionalTypeListAny = None,
+                 **kwargs: Any) -> None:
         kwargs.update(attr_prefix='@', text_key='$', cdata_prefix='$')
         super(BadgerFishConverter, self).__init__(
             namespaces, dict_class, list_class, **kwargs
         )
 
     @property
-    def lossy(self):
+    def lossy(self) -> bool:
         return False
 
-    def element_decode(self, data, xsd_element, xsd_type=None, level=0):
+    def element_decode(self, data: ElementData, xsd_element: 'XsdElement',
+                       xsd_type: OptionalBaseXsdType = None, level: int = 0) -> Any:
         xsd_type = xsd_type or xsd_element.type
         dict_class = self.dict
 
@@ -43,11 +55,12 @@
         if has_local_root:
             result_dict'@xmlns' = dict_class()
 
-        if xsd_type.simple_type is not None:
+        xsd_group = xsd_type.model_group
+        if xsd_group is None:
             if data.text is not None and data.text != '':
                 result_dict'$' = data.text
         else:
-            has_single_group = xsd_type.content.is_single()
+            has_single_group = xsd_group.is_single()
             for name, value, xsd_child in self.map_content(data.content):
                 try:
                     if '@xmlns' in value:
@@ -91,7 +104,7 @@
         else:
             return dict_class(('@xmlns', dict_class(self)), (tag, result_dict))
 
-    def element_encode(self, obj, xsd_element, level=0):
+    def element_encode(self, obj: Any, xsd_element: 'XsdElement', level: int = 0) -> ElementData:
         tag = xsd_element.qualified_name if level == 0 else xsd_element.name
 
         if not self.strip_namespaces:
@@ -109,7 +122,7 @@
                 element_data = obj
 
         text = None
-        content = 
+        content: ListTupleUnionstr, int, Any = 
         attributes = {}
 
         for name, value in element_data.items():
@@ -130,11 +143,16 @@
                 for item in value:
                     content.append((ns_name, item))
             else:
+                xsd_group = xsd_element.type.model_group
+                if xsd_group is None:
+                    xsd_group = xsd_element.any_type.model_group
+                    assert xsd_group is not None
+
                 ns_name = self.unmap_qname(name)
-                for xsd_child in xsd_element.type.content.iter_elements():
+                for xsd_child in xsd_group.iter_elements():
                     matched_element = xsd_child.match(ns_name, resolve=True)
                     if matched_element is not None:
-                        if matched_element.type.is_list():
+                        if matched_element.type and matched_element.type.is_list():
                             content.append((ns_name, value))
                         else:
                             content.extend((ns_name, item) for item in value)

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/converters/columnar.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/converters/columnar.py Changed

@@ -8,9 +8,15 @@
 # @author Davide Brunato <brunato@sissa.it>
 #
 from collections.abc import MutableMapping, MutableSequence
+from typing import TYPE_CHECKING, Any, Optional, List, Dict, Type, Tuple
 
 from ..exceptions import XMLSchemaTypeError, XMLSchemaValueError
-from .default import ElementData, XMLSchemaConverter
+from ..etree import ElementData
+from ..aliases import NamespacesType, BaseXsdType
+from .default import XMLSchemaConverter
+
+if TYPE_CHECKING:
+    from ..validators import XsdElement
 
 
 class ColumnarConverter(XMLSchemaConverter):
@@ -23,17 +29,22 @@
     :param attr_prefix: used as separator string for renaming the decoded attributes. \
     Can be the empty string (the default) or a single/double underscore.
     """
-    def __init__(self, namespaces=None, dict_class=None, list_class=None,
-                 attr_prefix='', **kwargs):
+    __slots__ = ()
+
+    def __init__(self, namespaces: OptionalNamespacesType = None,
+                 dict_class: OptionalTypeDictstr, Any = None,
+                 list_class: OptionalTypeListAny = None,
+                 attr_prefix: Optionalstr = '',
+                 **kwargs: Any) -> None:
         kwargs.update(text_key=None, cdata_prefix=None)
         super(ColumnarConverter, self).__init__(namespaces, dict_class, list_class,
                                                 attr_prefix=attr_prefix, **kwargs)
 
     @property
-    def lossy(self):
+    def lossy(self) -> bool:
         return True  # Loss cdata parts
 
-    def __setattr__(self, name, value):
+    def __setattr__(self, name: str, value: Any) -> None:
         if name != 'attr_prefix':
             super(ColumnarConverter, self).__setattr__(name, value)
         elif not isinstance(value, str):
@@ -45,10 +56,16 @@
         else:
             super(XMLSchemaConverter, self).__setattr__(name, value)
 
-    def element_decode(self, data, xsd_element, xsd_type=None, level=0):
+    def element_decode(self, data: ElementData, xsd_element: 'XsdElement',
+                       xsd_type: OptionalBaseXsdType = None, level: int = 0) -> Any:
+        result_dict: Any
+
         xsd_type = xsd_type or xsd_element.type
         if data.attributes:
-            pfx = xsd_element.local_name + self.attr_prefix
+            if self.attr_prefix:
+                pfx = xsd_element.local_name + self.attr_prefix
+            else:
+                pfx = xsd_element.local_name
             result_dict = self.dict((pfx + self.map_qname(k), v) for k, v in data.attributes)
         else:
             result_dict = self.dict()
@@ -66,13 +83,13 @@
                     name = name2 + len(xsd_child.namespace):
 
                 if xsd_child.is_single():
-                    if hasattr(xsd_child, 'type') and xsd_child.type.simple_type is not None:
+                    if xsd_child.type is not None and xsd_child.type.simple_type is not None:
                         for k in value:
                             result_dictk = valuek
                     else:
                         result_dictname = value
                 else:
-                    if hasattr(xsd_child, 'type') and xsd_child.type.simple_type is not None \
+                    if xsd_child.type is not None and xsd_child.type.simple_type is not None \
                             and not xsd_child.attributes:
                         if len(xsd_element.findall('*')) == 1:
                             try:
@@ -99,7 +116,7 @@
         else:
             return result_dict
 
-    def element_encode(self, obj, xsd_element, level=0):
+    def element_encode(self, obj: Any, xsd_element: 'XsdElement', level: int = 0) -> ElementData:
         if level != 0:
             tag = xsd_element.local_name
         else:
@@ -118,9 +135,9 @@
                 return ElementData(xsd_element.name, None, obj, {})
 
         text = None
-        content = 
+        content: ListTupleOptionalstr, MutableSequenceAny = 
         attributes = {}
-        pfx = tag + self.attr_prefix
+        pfx = tag + self.attr_prefix if self.attr_prefix else tag
 
         for name, value in obj.items():
             if name == tag:
@@ -135,11 +152,16 @@
                 ns_name = self.unmap_qname(name)
                 content.extend((ns_name, item) for item in value)
             else:
+                xsd_group = xsd_element.type.model_group
+                if xsd_group is None:
+                    xsd_group = xsd_element.any_type.model_group
+                    assert xsd_group is not None
+
                 ns_name = self.unmap_qname(name)
-                for xsd_child in xsd_element.type.content.iter_elements():
+                for xsd_child in xsd_group.iter_elements():
                     matched_element = xsd_child.match(ns_name, resolve=True)
                     if matched_element is not None:
-                        if matched_element.type.is_list():
+                        if matched_element.type and matched_element.type.is_list():
                             content.append((xsd_child.name, value))
                         else:
                             content.extend((xsd_child.name, item) for item in value)

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/converters/default.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/converters/default.py Changed

@@ -7,25 +7,18 @@
 #
 # @author Davide Brunato <brunato@sissa.it>
 #
-from collections import namedtuple
 from collections.abc import MutableMapping, MutableSequence
+from typing import TYPE_CHECKING, cast, Any, Dict, Iterator, Iterable, \
+    List, Optional, Type, Tuple, Union
 
 from ..exceptions import XMLSchemaTypeError
 from ..names import XSI_NAMESPACE
-from ..etree import etree_element
+from ..etree import etree_element, ElementData
+from ..aliases import NamespacesType, ElementType, BaseXsdType
 from ..namespaces import NamespaceMapper
 
-
-ElementData = namedtuple('ElementData', 'tag', 'text', 'content', 'attributes')
-"""
-Namedtuple for Element data interchange between decoders and converters.
-The field *tag* is a string containing the Element's tag, *text* can be `None`
-or a string representing the Element's text, *content* can be `None`, a list
-containing the Element's children or a dictionary containing element name to
-list of element contents for the Element's children (used for unordered input
-data), *attributes* can be `None` or a dictionary containing the Element's
-attributes.
-"""
+if TYPE_CHECKING:
+    from ..validators import XsdElement
 
 
 class XMLSchemaConverter(NamespaceMapper):
@@ -55,12 +48,13 @@
     :param strip_namespaces: if set to `True` removes namespace declarations from data and \
     namespace information from names, during decoding or encoding. Defaults to `False`.
     :param preserve_root: if set to `True` the root element is preserved, wrapped into a \
-    single-item dictionary. Applicable only to default converter and to :class:`ParkerConverter`.
+    single-item dictionary. Applicable only to default converter, to \
+    :class:`UnorderedConverter` and to :class:`ParkerConverter`.
     :param force_dict: if set to `True` complex elements with simple content are decoded \
-    with a dictionary also if there are no decoded attributes. Applicable to default converter \
-    only. Defaults to `False`.
+    with a dictionary also if there are no decoded attributes. Applicable only to default \
+    converter and to :class:`UnorderedConverter`. Defaults to `False`.
     :param force_list: if set to `True` child elements are decoded within a list in any case. \
-    Applicable to default converter only. Defaults to `False`.
+    Applicable only to default converter and to :class:`UnorderedConverter`. Defaults to `False`.
 
     :ivar dict: dictionary class to use for decoded data.
     :ivar list: list class to use for decoded data.
@@ -73,16 +67,29 @@
     :ivar force_dict: force dictionary for complex elements with simple content
     :ivar force_list: force list for child elements
     """
+    ns_prefix: str
+    dict: TypeDictstr, Any = dict
+    list: TypeListAny = list
 
-    dict = dict
-    list = list
+    etree_element_class: TypeElementType
     etree_element_class = etree_element
-    ns_prefix = None
 
-    def __init__(self, namespaces=None, dict_class=None, list_class=None,
-                 etree_element_class=None, text_key='$', attr_prefix='@',
-                 cdata_prefix=None, indent=4, strip_namespaces=False,
-                 preserve_root=False, force_dict=False, force_list=False, **kwargs):
+    __slots__ = ('text_key', 'ns_prefix', 'attr_prefix', 'cdata_prefix',
+                 'indent', 'preserve_root', 'force_dict', 'force_list')
+
+    def __init__(self, namespaces: OptionalNamespacesType = None,
+                 dict_class: OptionalTypeDictstr, Any = None,
+                 list_class: OptionalTypeListAny = None,
+                 etree_element_class: OptionalTypeElementType = None,
+                 text_key: Optionalstr = '$',
+                 attr_prefix: Optionalstr = '@',
+                 cdata_prefix: Optionalstr = None,
+                 indent: int = 4,
+                 strip_namespaces: bool = False,
+                 preserve_root: bool = False,
+                 force_dict: bool = False,
+                 force_list: bool = False,
+                 **kwargs: Any) -> None:
 
         super(XMLSchemaConverter, self).__init__(namespaces, strip_namespaces)
 
@@ -96,20 +103,19 @@
         self.text_key = text_key
         self.attr_prefix = attr_prefix
         self.cdata_prefix = cdata_prefix
+        self.ns_prefix = 'xmlns' if attr_prefix is None else f'{attr_prefix}xmlns'
+
         self.indent = indent
         self.preserve_root = preserve_root
         self.force_dict = force_dict
         self.force_list = force_list
 
-    def __setattr__(self, name, value):
+    def __setattr__(self, name: str, value: Any) -> None:
         if name in {'attr_prefix', 'text_key', 'cdata_prefix'}:
             if value is not None and not isinstance(value, str):
                 msg = '{} must be a str or None, not {}'
                 raise XMLSchemaTypeError(msg.format(name, type(value).__name__))
 
-            if name == 'attr_prefix':
-                self.ns_prefix = (value or '') + 'xmlns'
-
         elif name in {'strip_namespaces', 'preserve_root', 'force_dict', 'force_list'}:
             if not isinstance(value, bool):
                 msg = '{} must be a bool, not {}'
@@ -133,12 +139,12 @@
         super(XMLSchemaConverter, self).__setattr__(name, value)
 
     @property
-    def lossy(self):
+    def lossy(self) -> bool:
         """The converter ignores some kind of XML data during decoding/encoding."""
         return self.cdata_prefix is None or self.text_key is None or self.attr_prefix is None
 
     @property
-    def losslessly(self):
+    def losslessly(self) -> bool:
         """
         The XML data is decoded without loss of quality, neither on data nor on data model
         shape. Only losslessly converters can be always used to encode to an XML data that
@@ -146,7 +152,7 @@
         """
         return False
 
-    def copy(self, **kwargs):
+    def copy(self, **kwargs: Any) -> 'XMLSchemaConverter':
         return type(self)(
             namespaces=kwargs.get('namespaces', self._namespaces),
             dict_class=kwargs.get('dict_class', self.dict),
@@ -162,7 +168,8 @@
             force_list=kwargs.get('force_list', self.force_list),
         )
 
-    def map_attributes(self, attributes):
+    def map_attributes(self, attributes: IterableTuplestr, Any) \
+            -> IteratorTuplestr, Any:
         """
         Creates an iterator for converting decoded attributes to a data structure with
         appropriate prefixes. If the instance has a not-empty map of namespaces registers
@@ -181,7 +188,8 @@
             for name, value in attributes:
                 yield self.map_qname(name), value
 
-    def map_content(self, content):
+    def map_content(self, content: IterableTuplestr, Any, Any) \
+            -> IteratorTuplestr, Any, Any:
         """
         A generator function for converting decoded content to a data structure.
         If the instance has a not-empty map of namespaces registers the mapped URIs
@@ -203,7 +211,11 @@
                 if self.cdata_prefix is not None:
                     yield '%s%s' % (self.cdata_prefix, name), value, xsd_child
 
-    def etree_element(self, tag, text=None, children=None, attrib=None, level=0):
+    def etree_element(self, tag: str,
+                      text: Optionalstr = None,
+                      children: OptionalListElementType = None,
+                      attrib: OptionalDictstr, str = None,
+                      level: int = 0) -> ElementType:
         """
         Builds an ElementTree's Element using arguments and the element class and
         the indent spacing stored in the converter instance.
@@ -213,7 +225,7 @@
         :param children: the list of Element children/subelements.
         :param attrib: a dictionary with Element attributes.
         :param level: the level related to the encoding process (0 means the root).
-        :return: an instance of the Element class setted for the converter instance.
+        :return: an instance of the Element class is set for the converter instance.
         """
         if type(self.etree_element_class) is type(etree_element):
             if attrib is None:
@@ -221,9 +233,11 @@
             else:
                 elem = self.etree_element_class(tag, self.dict(attrib))
         else:
-            nsmap = {prefix if prefix else None: uri for prefix, uri in self._namespaces.items()}
-            elem = self.etree_element_class(tag, nsmap=nsmap)
-            elem.attrib.update(attrib)
+            # FIXME: need a more refined check
+            nsmap = {prefix if prefix else None: uri
+                     for prefix, uri in self._namespaces.items() if uri}
+            elem = self.etree_element_class(tag, nsmap=nsmap)  # type: ignorearg-type
+            elem.attrib.update(attrib)  # type: ignorearg-type
 
         if children:
             elem.extend(children)
@@ -235,14 +249,15 @@
 
         return elem
 
-    def element_decode(self, data, xsd_element, xsd_type=None, level=0):
+    def element_decode(self, data: ElementData, xsd_element: 'XsdElement',
+                       xsd_type: OptionalBaseXsdType = None, level: int = 0) -> Any:
         """
         Converts a decoded element data to a data structure.
 
         :param data: ElementData instance decoded from an Element node.
         :param xsd_element: the `XsdElement` associated to decoded the data.
-        :param xsd_type: optional `XsdType` for supporting dynamic type through \
-        xsi:type or xs:alternative.
+        :param xsd_type: optional XSD type for supporting dynamic type through \
+        *xsi:type* or xs:alternative.
         :param level: the level related to the decoding process (0 means the root).
         :return: a data structure containing the decoded data.
         """
@@ -256,10 +271,11 @@
                 if v in schema_namespaces or v == XSI_NAMESPACE
             )
 
-        if xsd_type.simple_type is not None:
+        xsd_group = xsd_type.model_group
+        if xsd_group is None:
             if data.attributes or self.force_dict and not xsd_type.is_simple():
                 result_dict.update(t for t in self.map_attributes(data.attributes))
-                if data.text is not None and data.text != '':
+                if data.text is not None and data.text != '' and self.text_key is not None:
                     result_dictself.text_key = data.text
                 return result_dict
             else:
@@ -268,7 +284,7 @@
             if data.attributes:
                 result_dict.update(t for t in self.map_attributes(data.attributes))
 
-            has_single_group = xsd_type.content.is_single()
+            has_single_group = xsd_group.is_single()
             if data.content:
                 for name, value, xsd_child in self.map_content(data.content):
                     try:
@@ -287,16 +303,21 @@
                         else:
                             result_dictname = self.list(result, value)
 
-            elif data.text is not None and data.text != '':
+            elif data.text is not None and data.text != '' and self.text_key is not None:
                 result_dictself.text_key = data.text
 
             if level == 0 and self.preserve_root:
                 return self.dict(
                     (self.map_qname(data.tag), result_dict if result_dict else None)
                 )
-            return result_dict if result_dict else None
 
-    def element_encode(self, obj, xsd_element, level=0):
+            if not result_dict:
+                return None
+            elif len(result_dict) == 1 and self.text_key in result_dict:
+                return result_dictself.text_key
+            return result_dict
+
+    def element_encode(self, obj: Any, xsd_element: 'XsdElement', level: int = 0) -> ElementData:
         """
         Extracts XML decoded data from a data structure for encoding into an ElementTree.
 
@@ -308,9 +329,12 @@
         if level != 0:
             tag = xsd_element.name
         else:
-            tag = xsd_element.qualified_name
+            if xsd_element.is_global():
+                tag = xsd_element.qualified_name
+            else:
+                tag = xsd_element.name
             if self.preserve_root and isinstance(obj, MutableMapping):
-                match_local_name = self.strip_namespaces or self.default_namespace
+                match_local_name = cast(bool, self.strip_namespaces or self.default_namespace)
                 match = xsd_element.get_matching_item(obj, self.ns_prefix, match_local_name)
                 if match is not None:
                     obj = match
@@ -318,13 +342,13 @@
         if not isinstance(obj, MutableMapping):
             if xsd_element.type.simple_type is not None:
                 return ElementData(tag, obj, None, {})
-            elif xsd_element.type.mixed and not isinstance(obj, MutableSequence):
-                return ElementData(tag, obj, None, {})
+            elif xsd_element.type.mixed and isinstance(obj, (str, bytes)):
+                return ElementData(tag, None, (1, obj), {})
             else:
                 return ElementData(tag, None, obj, {})
 
         text = None
-        content = 
+        content: ListTupleUnionint, str, Any = 
         attributes = {}
 
         for name, value in obj.items():
@@ -352,11 +376,17 @@
                 ns_name = self.unmap_qname(name)
                 content.extend((ns_name, item) for item in value)
             else:
+                xsd_group = xsd_element.type.model_group
+                if xsd_group is None:
+                    # fallback to xs:anyType encoder
+                    xsd_group = xsd_element.any_type.model_group
+                    assert xsd_group is not None
+
                 ns_name = self.unmap_qname(name)
-                for xsd_child in xsd_element.type.content.iter_elements():
+                for xsd_child in xsd_group.iter_elements():
                     matched_element = xsd_child.match(ns_name, resolve=True)
                     if matched_element is not None:
-                        if matched_element.type.is_list():
+                        if matched_element.type and matched_element.type.is_list():
                             content.append((ns_name, value))
                         else:
                             content.extend((ns_name, item) for item in value)
@@ -364,7 +394,7 @@
                 else:
                     if self.attr_prefix == '' and ns_name not in attributes:
                         for key, xsd_attribute in xsd_element.attributes.items():
-                            if xsd_attribute.is_matching(ns_name):
+                            if key and xsd_attribute.is_matching(ns_name):
                                 attributeskey = value
                                 break
                         else:

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/converters/jsonml.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/converters/jsonml.py Changed

@@ -8,9 +8,15 @@
 # @author Davide Brunato <brunato@sissa.it>
 #
 from collections.abc import MutableSequence
+from typing import TYPE_CHECKING, Any, Optional, List, Dict, Type
 
 from ..exceptions import XMLSchemaValueError
-from .default import ElementData, XMLSchemaConverter
+from ..etree import ElementData
+from ..aliases import NamespacesType, BaseXsdType
+from .default import XMLSchemaConverter
+
+if TYPE_CHECKING:
+    from ..validators import XsdElement
 
 
 class JsonMLConverter(XMLSchemaConverter):
@@ -24,21 +30,27 @@
     :param dict_class: Dictionary class to use for decoded data. Default is `dict`.
     :param list_class: List class to use for decoded data. Default is `list`.
     """
-    def __init__(self, namespaces=None, dict_class=None, list_class=None, **kwargs):
+    __slots__ = ()
+
+    def __init__(self, namespaces: OptionalNamespacesType = None,
+                 dict_class: OptionalTypeDictstr, Any = None,
+                 list_class: OptionalTypeListAny = None,
+                 **kwargs: Any) -> None:
         kwargs.update(attr_prefix='', text_key='', cdata_prefix='')
         super(JsonMLConverter, self).__init__(
             namespaces, dict_class, list_class, **kwargs
         )
 
     @property
-    def lossy(self):
+    def lossy(self) -> bool:
         return False
 
     @property
-    def losslessly(self):
+    def losslessly(self) -> bool:
         return True
 
-    def element_decode(self, data, xsd_element, xsd_type=None, level=0):
+    def element_decode(self, data: ElementData, xsd_element: 'XsdElement',
+                       xsd_type: OptionalBaseXsdType = None, level: int = 0) -> Any:
         xsd_type = xsd_type or xsd_element.type
         result_list = self.list()
         result_list.append(self.map_qname(data.tag))
@@ -61,8 +73,9 @@
 
         return result_list
 
-    def element_encode(self, obj, xsd_element, level=0):
-        attributes = {}
+    def element_encode(self, obj: Any, xsd_element: 'XsdElement', level: int = 0) -> ElementData:
+        attributes: Dictstr, Any = {}
+
         if not isinstance(obj, MutableSequence) or not obj:
             raise XMLSchemaValueError("Wrong data format, a not empty list required: %r." % obj)

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/converters/parker.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/converters/parker.py Changed

@@ -8,8 +8,14 @@
 # @author Davide Brunato <brunato@sissa.it>
 #
 from collections.abc import MutableMapping, MutableSequence
+from typing import TYPE_CHECKING, Any, Optional, List, Dict, Type
 
-from .default import ElementData, XMLSchemaConverter
+from ..etree import ElementData
+from ..aliases import NamespacesType, BaseXsdType
+from .default import XMLSchemaConverter
+
+if TYPE_CHECKING:
+    from ..validators import XsdElement
 
 
 class ParkerConverter(XMLSchemaConverter):
@@ -25,8 +31,12 @@
     :param preserve_root: If `True` the root element will be preserved. For default \
     the Parker convention remove the document root element, returning only the value.
     """
-    def __init__(self, namespaces=None, dict_class=None, list_class=None,
-                 preserve_root=False, **kwargs):
+    __slots__ = ()
+
+    def __init__(self, namespaces: OptionalNamespacesType = None,
+                 dict_class: OptionalTypeDictstr, Any = None,
+                 list_class: OptionalTypeListAny = None,
+                 preserve_root: bool = False, **kwargs: Any) -> None:
         kwargs.update(attr_prefix=None, text_key='', cdata_prefix=None)
         super(ParkerConverter, self).__init__(
             namespaces, dict_class, list_class,
@@ -34,10 +44,11 @@
         )
 
     @property
-    def lossy(self):
+    def lossy(self) -> bool:
         return True
 
-    def element_decode(self, data, xsd_element, xsd_type=None, level=0):
+    def element_decode(self, data: ElementData, xsd_element: 'XsdElement',
+                       xsd_type: OptionalBaseXsdType = None, level: int = 0) -> Any:
         xsd_type = xsd_type or xsd_element.type
         preserve_root = self.preserve_root
         if xsd_type.simple_type is not None:
@@ -75,7 +86,8 @@
             else:
                 return result_dict if result_dict else None
 
-    def element_encode(self, obj, xsd_element, level=0):
+    def element_encode(self, obj: Any, xsd_element: 'XsdElement', level: int = 0) -> ElementData:
+        name: str = xsd_element.name
         if not isinstance(obj, MutableMapping):
             if obj == '':
                 obj = None
@@ -88,13 +100,18 @@
                 return ElementData(xsd_element.name, None, None, {})
             elif self.preserve_root:
                 try:
-                    items = objself.map_qname(xsd_element.name)
+                    items = objself.map_qname(name)
                 except KeyError:
                     return ElementData(xsd_element.name, None, None, {})
             else:
                 items = obj
 
             try:
+                xsd_group = xsd_element.type.model_group
+                if xsd_group is None:
+                    xsd_group = xsd_element.any_type.model_group
+                    assert xsd_group is not None
+
                 content = 
                 for name, value in obj.items():
                     ns_name = self.unmap_qname(name)
@@ -104,10 +121,10 @@
                         for item in value:
                             content.append((ns_name, item))
                     else:
-                        for xsd_child in xsd_element.type.content.iter_elements():
+                        for xsd_child in xsd_group.iter_elements():
                             matched_element = xsd_child.match(ns_name, resolve=True)
                             if matched_element is not None:
-                                if matched_element.type.is_list():
+                                if matched_element.type and matched_element.type.is_list():
                                     content.append((ns_name, value))
                                 else:
                                     content.extend((ns_name, item) for item in value)

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/converters/unordered.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/converters/unordered.py Changed

@@ -8,8 +8,13 @@
 # @author Davide Brunato <brunato@sissa.it>
 #
 from collections.abc import MutableMapping, MutableSequence
+from typing import TYPE_CHECKING, cast, Any, Dict, Union
 
-from .default import ElementData, XMLSchemaConverter
+from ..etree import ElementData
+from .default import XMLSchemaConverter
+
+if TYPE_CHECKING:
+    from ..validators import XsdElement
 
 
 class UnorderedConverter(XMLSchemaConverter):
@@ -22,7 +27,9 @@
     As the order of the input dictionary is not preserved, character data
     between sibling elements are interleaved between tags.
     """
-    def element_encode(self, obj, xsd_element, level=0):
+    __slots__ = ()
+
+    def element_encode(self, obj: Any, xsd_element: 'XsdElement', level: int = 0) -> ElementData:
         """
         Extracts XML decoded data from a data structure for encoding into an ElementTree.
 
@@ -31,12 +38,12 @@
         :param level: the level related to the encoding process (0 means the root).
         :return: an ElementData instance.
         """
-        if level != 0:
+        if level:
             tag = xsd_element.name
         else:
             tag = xsd_element.qualified_name
             if self.preserve_root and isinstance(obj, MutableMapping):
-                match_local_name = self.strip_namespaces or self.default_namespace
+                match_local_name = cast(bool, self.strip_namespaces or self.default_namespace)
                 match = xsd_element.get_matching_item(obj, self.ns_prefix, match_local_name)
                 if match is not None:
                     obj = match
@@ -44,6 +51,8 @@
         if not isinstance(obj, MutableMapping):
             if xsd_element.type.simple_type is not None:
                 return ElementData(tag, obj, None, {})
+            elif xsd_element.type.mixed and isinstance(obj, (str, bytes)):
+                return ElementData(tag, None, (1, obj), {})
             else:
                 return ElementData(tag, None, obj, {})
 
@@ -57,7 +66,7 @@
         # in a list to retain that structure. Character data are not wrapped into
         # lists because they because they are divided from the rest of the content
         # into the unordered mode generator function of the ModelVisitor class.
-        content_lu = {}
+        content_lu: DictUnionint, str, Any = {}
 
         for name, value in obj.items():
             if name == self.text_key:
@@ -82,12 +91,17 @@
             elif isinstance(value0, (MutableMapping, MutableSequence)):
                 content_luself.unmap_qname(name) = value
             else:
+                xsd_group = xsd_element.type.model_group
+                if xsd_group is None:
+                    xsd_group = xsd_element.any_type.model_group
+                    assert xsd_group is not None
+
                 # `value` is a list but not a list of lists or list of dicts.
                 ns_name = self.unmap_qname(name)
-                for xsd_child in xsd_element.type.content.iter_elements():
+                for xsd_child in xsd_group.iter_elements():
                     matched_element = xsd_child.match(ns_name, resolve=True)
                     if matched_element is not None:
-                        if matched_element.type.is_list():
+                        if matched_element.type and matched_element.type.is_list():
                             content_luself.unmap_qname(name) = value
                         else:
                             content_luself.unmap_qname(name) = value

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/dataobjects.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/dataobjects.py Changed

@@ -7,18 +7,30 @@
 #
 # @author Davide Brunato <brunato@sissa.it>
 #
-from abc import ABCMeta
-from collections.abc import MutableSequence
+import sys
+if sys.version_info < (3, 7):
+    from typing import GenericMeta as ABCMeta
+else:
+    from abc import ABCMeta
+
+from itertools import count
+from typing import TYPE_CHECKING, cast, overload, Any, Dict, List, Iterator, \
+    Optional, Union, Tuple, Type, MutableMapping, MutableSequence
 from elementpath import XPathContext, XPath2Parser
 
 from .exceptions import XMLSchemaAttributeError, XMLSchemaTypeError, XMLSchemaValueError
-from .etree import etree_tostring
+from .etree import ElementData, etree_tostring
+from .aliases import ElementType, XMLSourceType, NamespacesType, BaseXsdType, DecodeType
 from .helpers import get_namespace, get_prefixed_qname, local_name, raw_xml_encode
-from .converters import ElementData, XMLSchemaConverter
+from .converters import XMLSchemaConverter
+from .resources import XMLResource
 from . import validators
 
+if TYPE_CHECKING:
+    from .validators import XMLSchemaValidationError, XsdElement
 
-class DataElement(MutableSequence):
+
+class DataElement(MutableSequence'DataElement'):
     """
     Data Element, an Element like object with decoded data and schema bindings.
 
@@ -30,13 +42,24 @@
     :param xsd_type: an optional XSD type association. Can be provided \
     also if the instance is not bound with an XSD element.
     """
-    value = None
-    tail = None
-    xsd_element = None
-    xsd_type = None
-    _encoder = None
+    _children: List'DataElement'
+    tag: str
+    attrib: Dictstr, Any
+    nsmap: Dictstr, str
+
+    value: OptionalAny = None
+    tail: Optionalstr = None
+    xsd_element: Optional'XsdElement' = None
+    xsd_type: OptionalBaseXsdType = None
+    _encoder: Optional'XsdElement' = None
+
+    def __init__(self, tag: str,
+                 value: OptionalAny = None,
+                 attrib: OptionalDictstr, Any = None,
+                 nsmap: OptionalMutableMappingstr, str = None,
+                 xsd_element: Optional'XsdElement' = None,
+                 xsd_type: OptionalBaseXsdType = None) -> None:
 
-    def __init__(self, tag, value=None, attrib=None, nsmap=None, xsd_element=None, xsd_type=None):
         super(DataElement, self).__init__()
         self._children = 
         self.tag = tag
@@ -45,9 +68,9 @@
 
         if value is not None:
             self.value = value
-        if attrib:
+        if attrib is not None:
             self.attrib.update(attrib)
-        if nsmap:
+        if nsmap is not None:
             self.nsmap.update(nsmap)
 
         if xsd_element is not None:
@@ -58,43 +81,49 @@
         elif self.xsd_element is not None:
             self._encoder = self.xsd_element
 
-    def __getitem__(self, i):
+    @overload
+    def __getitem__(self, i: int) -> 'DataElement': ...
+
+    @overload
+    def __getitem__(self, s: slice) -> MutableSequence'DataElement': ...
+
+    def __getitem__(self, i: Unionint, slice) \
+            -> Union'DataElement', MutableSequence'DataElement':
         return self._childreni
 
-    def __setitem__(self, i, child):
-        assert isinstance(child, DataElement)
+    def __setitem__(self, i: Unionint, slice, child: Any) -> None:
         self._childreni = child
 
-    def __delitem__(self, i):
+    def __delitem__(self, i: Unionint, slice) -> None:
         del self._childreni
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self._children)
 
-    def insert(self, i, child):
+    def insert(self, i: int, child: 'DataElement') -> None:
         assert isinstance(child, DataElement)
         self._children.insert(i, child)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return '%s(tag=%r)' % (self.__class__.__name__, self.tag)
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator'DataElement':
         yield from self._children
 
-    def __setattr__(self, key, value):
+    def __setattr__(self, key: str, value: Any) -> None:
         if key == 'xsd_element':
             if not isinstance(value, validators.XsdElement):
-                msg = "attribute 'xsd_element' must be an {!r} instance"
-                raise XMLSchemaTypeError(msg.format(validators.XsdElement))
-            elif self.xsd_element is not None and self.xsd_element is not value:
+                raise XMLSchemaTypeError("invalid type for attribute 'xsd_element'")
+            elif self.xsd_element is value:
+                pass
+            elif self.xsd_element is not None:
                 raise XMLSchemaValueError("the instance is already bound to another XSD element")
             elif self.xsd_type is not None and self.xsd_type is not value.type:
                 raise XMLSchemaValueError("the instance is already bound to another XSD type")
 
         elif key == 'xsd_type':
-            if not isinstance(value, validators.XsdType):
-                msg = "attribute 'xsd_type' must be an {!r} instance"
-                raise XMLSchemaTypeError(msg.format(validators.XsdType))
+            if not isinstance(value, (validators.XsdSimpleType, validators.XsdComplexType)):
+                raise XMLSchemaTypeError("invalid type for attribute 'xsd_type'")
             elif self.xsd_type is not None and self.xsd_type is not value:
                 raise XMLSchemaValueError("the instance is already bound to another XSD type")
             elif self.xsd_element is None or value is not self.xsd_element.type:
@@ -108,50 +137,53 @@
         super(DataElement, self).__setattr__(key, value)
 
     @property
-    def text(self):
+    def text(self) -> Optionalstr:
         """The string value of the data element."""
         return raw_xml_encode(self.value)
 
-    def get(self, key, default=None):
+    def get(self, key: str, default: Any = None) -> Any:
         """Gets a data element attribute."""
         return self.attrib.get(key, default)
 
-    def set(self, key, value):
+    def set(self, key: str, value: Any) -> None:
         """Sets a data element attribute."""
         self.attribkey = value
 
     @property
-    def xsd_version(self):
+    def xsd_version(self) -> str:
         return '1.0' if self.xsd_element is None else self.xsd_element.xsd_version
 
     @property
-    def namespace(self):
+    def namespace(self) -> str:
         """The element's namespace."""
         if self.xsd_element is None:
             return get_namespace(self.tag)
         return get_namespace(self.tag) or self.xsd_element.target_namespace
 
     @property
-    def name(self):
+    def name(self) -> str:
         """The element's name, that matches the tag."""
         return self.tag
 
     @property
-    def prefixed_name(self):
+    def prefixed_name(self) -> str:
         """The prefixed name, or the tag if no prefix is defined for its namespace."""
         return get_prefixed_qname(self.tag, self.nsmap)
 
     @property
-    def local_name(self):
+    def local_name(self) -> str:
         """The local part of the tag."""
         return local_name(self.tag)
 
-    def validate(self, use_defaults=True, namespaces=None, max_depth=None):
+    def validate(self, use_defaults: bool = True,
+                 namespaces: OptionalNamespacesType = None,
+                 max_depth: Optionalint = None) -> None:
         """
         Validates the XML data object.
 
         :param use_defaults: whether to use default values for filling missing data.
-        :param namespaces: is an optional mapping from namespace prefix to URI.
+        :param namespaces: is an optional mapping from namespace prefix to URI. \
+        For default uses the namespace map of the XML data object.
         :param max_depth: maximum depth for validation, for default there is no limit.
         :raises: :exc:`XMLSchemaValidationError` if XML data object is not valid.
         :raises: :exc:`XMLSchemaValueError` if the instance has no schema bindings.
@@ -159,7 +191,9 @@
         for error in self.iter_errors(use_defaults, namespaces, max_depth):
             raise error
 
-    def is_valid(self, use_defaults=True, namespaces=None, max_depth=None):
+    def is_valid(self, use_defaults: bool = True,
+                 namespaces: OptionalNamespacesType = None,
+                 max_depth: Optionalint = None) -> bool:
         """
         Like :meth:`validate` except it does not raise an exception on validation
         error but returns ``True`` if the XML data object is valid, ``False`` if
@@ -167,23 +201,23 @@
 
         :raises: :exc:`XMLSchemaValueError` if the instance has no schema bindings.
         """
-        return next(self.iter_errors(use_defaults, namespaces, max_depth), None) is None
+        error = next(self.iter_errors(use_defaults, namespaces, max_depth), None)
+        return error is None
 
-    def iter_errors(self, use_defaults=True, namespaces=None, max_depth=None):
+    def iter_errors(self, use_defaults: bool = True,
+                    namespaces: OptionalNamespacesType = None,
+                    max_depth: Optionalint = None) -> Iterator'XMLSchemaValidationError':
         """
         Generates a sequence of validation errors if the XML data object is invalid.
-
-        :param use_defaults: whether to use default values for filling missing data.
-        :param namespaces: is an optional mapping from namespace prefix to URI.
-        :param max_depth: maximum depth for validation, for default there is no limit.
-        :raises: :exc:`XMLSchemaValueError` if the instance has no schema bindings.
+        Accepts the same arguments of :meth:`validate`.
         """
         if self._encoder is None:
             raise XMLSchemaValueError("{!r} has no schema bindings".format(self))
 
-        kwargs = {'converter': DataElementConverter}
-        if not use_defaults:
-            kwargs'use_defaults' = False
+        kwargs: Dictstr, Any = {
+            'converter': DataElementConverter,
+            'use_defaults': use_defaults,
+        }
         if namespaces:
             kwargs'namespaces' = namespaces
         if isinstance(max_depth, int) and max_depth >= 0:
@@ -195,7 +229,8 @@
             else:
                 del result
 
-    def encode(self, validation='strict', **kwargs):
+    def encode(self, validation: str = 'strict', **kwargs: Any) \
+            -> UnionElementType, TupleElementType, List'XMLSchemaValidationError':
         """
         Encodes the data object to XML.
 
@@ -211,6 +246,7 @@
         if 'converter' not in kwargs:
             kwargs'converter' = DataElementConverter
 
+        encoder: Union'XsdElement', BaseXsdType
         if self._encoder is not None:
             encoder = self._encoder
         elif validation == 'skip':
@@ -222,12 +258,14 @@
 
     to_etree = encode
 
-    def tostring(self, indent='', max_lines=None, spaces_for_tab=4):
+    def tostring(self, indent: str = '', max_lines: Optionalint = None,
+                 spaces_for_tab: int = 4) -> Any:
         """Serializes the data element tree to an XML source string."""
-        root, _ = self.encode(validation='lax')
+        root, errors = self.encode(validation='lax')
         return etree_tostring(root, self.nsmap, indent, max_lines, spaces_for_tab)
 
-    def find(self, path, namespaces=None):
+    def find(self, path: str,
+             namespaces: OptionalNamespacesType = None) -> Optional'DataElement':
         """
         Finds the first data element matching the path.
 
@@ -236,10 +274,12 @@
         :return: the first matching data element or ``None`` if there is no match.
         """
         parser = XPath2Parser(namespaces, strict=False)
-        context = XPathContext(self)
-        return next(parser.parse(path).select_results(context), None)
+        context = XPathContext(cast(Any, self))
+        result = next(parser.parse(path).select_results(context), None)
+        return result if isinstance(result, DataElement) else None
 
-    def findall(self, path, namespaces=None):
+    def findall(self, path: str,
+                namespaces: OptionalNamespacesType = None) -> List'DataElement':
         """
         Finds all data elements matching the path.
 
@@ -249,10 +289,14 @@
         an empty list is returned if there is no match.
         """
         parser = XPath2Parser(namespaces, strict=False)
-        context = XPathContext(self)
-        return parser.parse(path).get_results(context)
-
-    def iterfind(self, path, namespaces=None):
+        context = XPathContext(cast(Any, self))
+        results = parser.parse(path).get_results(context)
+        if not isinstance(results, list):
+            return 
+        return e for e in results if isinstance(e, DataElement)
+
+    def iterfind(self, path: str,
+                 namespaces: OptionalNamespacesType = None) -> Iterator'DataElement':
         """
         Creates and iterator for all XSD subelements matching the path.
 
@@ -261,10 +305,11 @@
         :return: an iterable yielding all matching data elements in document order.
         """
         parser = XPath2Parser(namespaces, strict=False)
-        context = XPathContext(self)
-        return parser.parse(path).select_results(context)
+        context = XPathContext(cast(Any, self))
+        results = parser.parse(path).select_results(context)
+        yield from filter(lambda x: isinstance(x, DataElement), results)  # type: ignoremisc
 
-    def iter(self, tag=None):
+    def iter(self, tag: Optionalstr = None) -> Iterator'DataElement':
         """
         Creates an iterator for the data element and its subelements. If tag
         is not `None` or '*', only data elements whose matches tag are returned
@@ -277,7 +322,7 @@
         for child in self._children:
             yield from child.iter(tag)
 
-    def iterchildren(self, tag=None):
+    def iterchildren(self, tag: Optionalstr = None) -> Iterator'DataElement':
         """
         Creates an iterator for the child data elements. If *tag* is not `None` or '*',
         only data elements whose name matches tag are returned from the iterator.
@@ -292,7 +337,10 @@
 class DataBindingMeta(ABCMeta):
     """Metaclass for creating classes with bindings to XSD elements."""
 
-    def __new__(mcs, name, bases, attrs):
+    xsd_element: 'XsdElement'
+
+    def __new__(mcs, name: str, bases: TupleTypeAny, ...,
+                attrs: Dictstr, Any) -> 'DataBindingMeta':
         try:
             xsd_element = attrs'xsd_element'
         except KeyError:
@@ -305,12 +353,16 @@
         attrs'__module__' = None
         return super(DataBindingMeta, mcs).__new__(mcs, name, bases, attrs)
 
-    def __init__(cls, name, bases, attrs):
+    def __init__(cls, name: str, bases: TupleTypeAny, ..., attrs: Dictstr, Any) -> None:
         super(DataBindingMeta, cls).__init__(name, bases, attrs)
         cls.xsd_version = cls.xsd_element.xsd_version
         cls.namespace = cls.xsd_element.target_namespace
 
-    def fromsource(cls, source, **kwargs):
+    def fromsource(cls, source: UnionXMLSourceType, XMLResource,
+                   allow: str = 'all', defuse: str = 'remote',
+                   timeout: int = 300, **kwargs: Any) -> DecodeTypeAny:
+        if not isinstance(source, XMLResource):
+            source = XMLResource(source, allow=allow, defuse=defuse, timeout=timeout)
         if 'converter' not in kwargs:
             kwargs'converter' = DataBindingConverter
         return cls.xsd_element.schema.decode(source, **kwargs)
@@ -324,23 +376,33 @@
     :param data_element_class: MutableSequence subclass to use for decoded data. \
     Default is `DataElement`.
     """
-    data_element_class = DataElement
+    __slots__ = 'data_element_class',
 
-    def __init__(self, namespaces=None, data_element_class=None, **kwargs):
-        if data_element_class is not None:
+    def __init__(self, namespaces: OptionalNamespacesType = None,
+                 data_element_class: OptionalType'DataElement' = None,
+                 **kwargs: Any) -> None:
+        if data_element_class is None:
+            self.data_element_class = DataElement
+        else:
             self.data_element_class = data_element_class
         kwargs.update(attr_prefix='', text_key='', cdata_prefix='')
         super(DataElementConverter, self).__init__(namespaces, **kwargs)
 
     @property
-    def lossy(self):
+    def lossy(self) -> bool:
         return False
 
     @property
-    def losslessly(self):
+    def losslessly(self) -> bool:
         return True
 
-    def element_decode(self, data, xsd_element, xsd_type=None, level=0):
+    def copy(self, **kwargs: Any) -> 'DataElementConverter':
+        obj = cast(DataElementConverter, super().copy(**kwargs))
+        obj.data_element_class = kwargs.get('data_element_class', self.data_element_class)
+        return obj
+
+    def element_decode(self, data: ElementData, xsd_element: 'XsdElement',
+                       xsd_type: OptionalBaseXsdType = None, level: int = 0) -> 'DataElement':
         data_element = self.data_element_class(
             tag=data.tag,
             value=data.text,
@@ -351,14 +413,19 @@
         data_element.attrib.update((k, v) for k, v in self.map_attributes(data.attributes))
 
         if (xsd_type or xsd_element.type).model_group is not None:
-            data_element.extend(
-                value if value is not None else self.list(name)
-                for name, value, _ in self.map_content(data.content)
-            )
+            for name, value, _ in self.map_content(data.content):
+                if not name.isdigit():
+                    data_element.append(value)
+                else:
+                    try:
+                        data_element-1.tail = value
+                    except IndexError:
+                        data_element.value = value
 
         return data_element
 
-    def element_encode(self, data_element, xsd_element, level=0):
+    def element_encode(self, data_element: 'DataElement', xsd_element: 'XsdElement',
+                       level: int = 0) -> ElementData:
         self.namespaces.update(data_element.nsmap)
         if not xsd_element.is_matching(data_element.tag, self._namespaces.get('')):
             raise XMLSchemaValueError("Unmatched tag")
@@ -370,17 +437,17 @@
         if not data_len:
             return ElementData(data_element.tag, data_element.value, None, attributes)
 
-        elif data_len == 1 and \
-                (xsd_element.type.simple_type is not None or not
-                 xsd_element.type.content and xsd_element.type.mixed):
-            return ElementData(data_element.tag, data_element.value, , attributes)
-        else:
-            cdata_num = iter(range(1, data_len))
-            content = 
-                (self.unmap_qname(e.tag), e) if isinstance(e, self.data_element_class)
-                else (next(cdata_num), e) for e in data_element
-            
-            return ElementData(data_element.tag, None, content, attributes)
+        content: ListTupleUnionstr, int, Any = 
+        cdata_num = count(1)
+        if data_element.value is not None:
+            content.append((next(cdata_num), data_element.value))
+
+        for e in data_element:
+            content.append((e.tag, e))
+            if e.tail is not None:
+                content.append((next(cdata_num), e.tail))
+
+        return ElementData(data_element.tag, None, content, attributes)
 
 
 class DataBindingConverter(DataElementConverter):
@@ -390,7 +457,10 @@
     *data_element_class* is used for define the base for creating the missing
     XML binding classes.
     """
-    def element_decode(self, data, xsd_element, xsd_type=None, level=0):
+    __slots__ = ()
+
+    def element_decode(self, data: ElementData, xsd_element: 'XsdElement',
+                       xsd_type: OptionalBaseXsdType = None, level: int = 0) -> 'DataElement':
         cls = xsd_element.get_binding(self.data_element_class)
         data_element = cls(
             tag=data.tag,
@@ -401,9 +471,13 @@
         data_element.attrib.update((k, v) for k, v in self.map_attributes(data.attributes))
 
         if (xsd_type or xsd_element.type).model_group is not None:
-            data_element.extend(
-                value if value is not None else self.list(name)
-                for name, value, _ in self.map_content(data.content)
-            )
+            for name, value, _ in self.map_content(data.content):
+                if not name.isdigit():
+                    data_element.append(value)
+                else:
+                    try:
+                        data_element-1.tail = value
+                    except IndexError:
+                        data_element.value = value
 
         return data_element

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/documents.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/documents.py Changed

@@ -8,79 +8,104 @@
 # @author Davide Brunato <brunato@sissa.it>
 #
 import json
-from collections.abc import Iterator
+from io import IOBase, TextIOBase
+from typing import Any, Dict, List, Optional, Type, Union, Tuple, \
+    IO, BinaryIO, TextIO, Iterator
 
 from .exceptions import XMLSchemaTypeError, XMLSchemaValueError, XMLResourceError
 from .names import XSD_NAMESPACE, XSI_TYPE
 from .etree import ElementTree, etree_tostring
+from .aliases import ElementType, XMLSourceType, NamespacesType, LocationsType, \
+    LazyType, SchemaSourceType, ConverterType, DecodeType, EncodeType, \
+    JsonDecodeType
 from .helpers import is_etree_document
 from .resources import fetch_schema_locations, XMLResource
 from .validators import XMLSchema10, XMLSchemaBase, XMLSchemaValidationError
 
 
-def get_context(source, schema=None, cls=None, locations=None, base_url=None,
-                defuse='remote', timeout=300, lazy=False, dummy_schema=False):
+def get_context(xml_document: UnionXMLSourceType, XMLResource,
+                schema: OptionalUnionXMLSchemaBase, SchemaSourceType = None,
+                cls: OptionalTypeXMLSchemaBase = None,
+                locations: OptionalLocationsType = None,
+                base_url: Optionalstr = None,
+                defuse: str = 'remote',
+                timeout: int = 300,
+                lazy: LazyType = False,
+                dummy_schema: bool = False) -> TupleXMLResource, XMLSchemaBase:
     """
     Get the XML document validation/decode context.
 
     :return: an XMLResource instance and a schema instance.
     """
+    resource: XMLResource
+    kwargs: DictAny, Any
+
     if cls is None:
         cls = XMLSchema10
-    if not isinstance(source, XMLResource):
-        source = XMLResource(source, base_url, defuse=defuse, timeout=timeout, lazy=lazy)
-    if isinstance(schema, XMLSchemaBase) and source.namespace in schema.maps.namespaces:
-        return source, schema
-    if isinstance(source, XmlDocument) and source.schema is not None:
-        return source, source.schema
+    elif not issubclass(cls, XMLSchemaBase):
+        raise XMLSchemaTypeError(f"invalid schema class {cls}")
+
+    if isinstance(xml_document, XMLResource):
+        resource = xml_document
+    else:
+        resource = XMLResource(xml_document, base_url, defuse=defuse,
+                               timeout=timeout, lazy=lazy)
+
+    if isinstance(schema, XMLSchemaBase) and resource.namespace in schema.maps.namespaces:
+        return resource, schema
+    if isinstance(resource, XmlDocument) and isinstance(resource.schema, XMLSchemaBase):
+        return resource, resource.schema
 
     try:
-        schema_location, locations = fetch_schema_locations(source, locations, base_url=base_url)
+        schema_location, locations = fetch_schema_locations(resource, locations, base_url=base_url)
     except ValueError:
         if schema is None:
-            if XSI_TYPE in source.root.attrib:
-                schema = cls.meta_schema
+            if XSI_TYPE in resource.root.attrib and cls.meta_schema is not None:
+                return resource, cls.meta_schema
             elif dummy_schema:
-                return source, get_dummy_schema(source, cls)
+                return resource, get_dummy_schema(resource, cls)
             else:
                 msg = "no schema can be retrieved for the provided XML data"
                 raise XMLSchemaValueError(msg) from None
 
-        elif not isinstance(schema, XMLSchemaBase):
-            schema = cls(schema, validation='strict', locations=locations,
-                         base_url=base_url, defuse=defuse, timeout=timeout)
+        elif isinstance(schema, XMLSchemaBase):
+            return resource, schema
+        else:
+            return resource, cls(schema, locations=locations, base_url=base_url,
+                                 defuse=defuse, timeout=timeout)
     else:
-        schema = cls(schema or schema_location, validation='strict', locations=locations,
-                     defuse=defuse, timeout=timeout)
-
-    return source, schema
+        kwargs = dict(locations=locations, defuse=defuse, timeout=timeout)
+        if schema is None or isinstance(schema, XMLSchemaBase):
+            return resource, cls(schema_location, **kwargs)
+        else:
+            return resource, cls(schema, **kwargs)
 
 
-def get_dummy_schema(xml_resource, schema_class):
-    tag = xml_resource.root.tag
+def get_dummy_schema(resource: XMLResource, cls: TypeXMLSchemaBase) -> XMLSchemaBase:
+    tag = resource.root.tag
     if tag.startswith('{'):
         namespace, name = tag1:.split('}')
     else:
         namespace, name = '', tag
 
     if namespace:
-        return schema_class(
+        return cls(
             '<xs:schema xmlns:xs="{0}" targetNamespace="{1}">\n'
             '    <xs:element name="{2}"/>\n'
             '</xs:schema>'.format(XSD_NAMESPACE, namespace, name)
         )
     else:
-        return schema_class(
+        return cls(
             '<xs:schema xmlns:xs="{0}">\n'
             '    <xs:element name="{1}"/>\n'
             '</xs:schema>'.format(XSD_NAMESPACE, name)
         )
 
 
-def get_lazy_json_encoder(errors):
+def get_lazy_json_encoder(errors: ListXMLSchemaValidationError) -> Typejson.JSONEncoder:
 
     class JSONLazyEncoder(json.JSONEncoder):
-        def default(self, obj):
+        def default(self, obj: Any) -> Any:
             if isinstance(obj, Iterator):
                 while True:
                     result = next(obj, None)
@@ -93,9 +118,18 @@
     return JSONLazyEncoder
 
 
-def validate(xml_document, schema=None, cls=None, path=None, schema_path=None,
-             use_defaults=True, namespaces=None, locations=None, base_url=None,
-             defuse='remote', timeout=300, lazy=False):
+def validate(xml_document: UnionXMLSourceType, XMLResource,
+             schema: OptionalXMLSchemaBase = None,
+             cls: OptionalTypeXMLSchemaBase = None,
+             path: Optionalstr = None,
+             schema_path: Optionalstr = None,
+             use_defaults: bool = True,
+             namespaces: OptionalNamespacesType = None,
+             locations: OptionalLocationsType = None,
+             base_url: Optionalstr = None,
+             defuse: str = 'remote',
+             timeout: int = 300,
+             lazy: LazyType = False) -> None:
     """
     Validates an XML document against a schema instance. This function builds an
     :class:`XMLSchema` object for validating the XML document. Raises an
@@ -127,15 +161,24 @@
     :class:`XMLResource` instances.
     :param lazy: optional argument for construct the :class:`XMLResource` instance.
     """
-    source, schema = get_context(
+    source, _schema = get_context(
         xml_document, schema, cls, locations, base_url, defuse, timeout, lazy
     )
-    schema.validate(source, path, schema_path, use_defaults, namespaces)
-
-
-def is_valid(xml_document, schema=None, cls=None, path=None, schema_path=None,
-             use_defaults=True, namespaces=None, locations=None, base_url=None,
-             defuse='remote', timeout=300, lazy=False):
+    _schema.validate(source, path, schema_path, use_defaults, namespaces)
+
+
+def is_valid(xml_document: UnionXMLSourceType, XMLResource,
+             schema: OptionalXMLSchemaBase = None,
+             cls: OptionalTypeXMLSchemaBase = None,
+             path: Optionalstr = None,
+             schema_path: Optionalstr = None,
+             use_defaults: bool = True,
+             namespaces: OptionalNamespacesType = None,
+             locations: OptionalLocationsType = None,
+             base_url: Optionalstr = None,
+             defuse: str = 'remote',
+             timeout: int = 300,
+             lazy: LazyType = False) -> bool:
     """
     Like :meth:`validate` except that do not raises an exception but returns ``True`` if
     the XML document is valid, ``False`` if it's invalid.
@@ -146,9 +189,18 @@
     return schema.is_valid(source, path, schema_path, use_defaults, namespaces)
 
 
-def iter_errors(xml_document, schema=None, cls=None, path=None, schema_path=None,
-                use_defaults=True, namespaces=None, locations=None, base_url=None,
-                defuse='remote', timeout=300, lazy=False):
+def iter_errors(xml_document: UnionXMLSourceType, XMLResource,
+                schema: OptionalXMLSchemaBase = None,
+                cls: OptionalTypeXMLSchemaBase = None,
+                path: Optionalstr = None,
+                schema_path: Optionalstr = None,
+                use_defaults: bool = True,
+                namespaces: OptionalNamespacesType = None,
+                locations: OptionalLocationsType = None,
+                base_url: Optionalstr = None,
+                defuse: str = 'remote',
+                timeout: int = 300,
+                lazy: LazyType = False) -> IteratorXMLSchemaValidationError:
     """
     Creates an iterator for the errors generated by the validation of an XML document.
     Takes the same arguments of the function :meth:`validate`.
@@ -159,13 +211,22 @@
     return schema.iter_errors(source, path, schema_path, use_defaults, namespaces)
 
 
-def to_dict(xml_document, schema=None, cls=None, path=None, process_namespaces=True,
-            locations=None, base_url=None, defuse='remote', timeout=300, lazy=False, **kwargs):
+def iter_decode(xml_document: UnionXMLSourceType, XMLResource,
+                schema: OptionalXMLSchemaBase = None,
+                cls: OptionalTypeXMLSchemaBase = None,
+                path: Optionalstr = None,
+                validation: str = 'strict',
+                process_namespaces: bool = True,
+                locations: OptionalLocationsType = None,
+                base_url: Optionalstr = None,
+                defuse: str = 'remote',
+                timeout: int = 300,
+                lazy: LazyType = False,
+                **kwargs: Any) -> IteratorUnionAny, XMLSchemaValidationError:
     """
-    Decodes an XML document to a Python's nested dictionary. The decoding is based
-    on an XML Schema class instance. For default the document is validated during
-    the decoding phase. Raises an :exc:`XMLSchemaValidationError` if the XML document
-    is not validated against the schema.
+    Creates an iterator for decoding an XML source to a data structure. For default
+    the document is validated during the decoding phase and if it's invalid then one
+    or more :exc:`XMLSchemaValidationError` instances are yielded before the decoded data.
 
     :param xml_document: can be an :class:`XMLResource` instance, a file-like object a path \
     to a file or an URI of a resource or an Element instance or an ElementTree instance or \
@@ -177,6 +238,8 @@
     :class:`XMLSchema10`).
     :param path: is an optional XPath expression that matches the elements of the XML \
     data that have to be decoded. If not provided the XML root element is used.
+    :param validation: defines the XSD validation mode to use for decode, can be \
+    'strict', 'lax' or 'skip'.
     :param process_namespaces: indicates whether to use namespace information in \
     the decoding process.
     :param locations: additional schema location hints, in case a schema instance \
@@ -190,21 +253,57 @@
     :param lazy: optional argument for construct the :class:`XMLResource` instance.
     :param kwargs: other optional arguments of :meth:`XMLSchema.iter_decode` \
     as keyword arguments.
-    :return: an object containing the decoded data. If ``validation='lax'`` keyword argument \
-    is provided the validation errors are collected and returned coupled in a tuple with the \
-    decoded data.
-    :raises: :exc:`XMLSchemaValidationError` if the object is not decodable by \
-    the XSD component, or also if it's invalid when ``validation='strict'`` is provided.
+    :raises: :exc:`XMLSchemaValidationError` if the XML document is invalid and \
+    ``validation='strict'`` is provided.
     """
-    source, schema = get_context(
+    source, _schema = get_context(
         xml_document, schema, cls, locations, base_url, defuse, timeout, lazy
     )
-    return schema.decode(source, path=path, process_namespaces=process_namespaces, **kwargs)
-
+    yield from _schema.iter_decode(source, path=path, validation=validation,
+                                   process_namespaces=process_namespaces, **kwargs)
+
+
+def to_dict(xml_document: UnionXMLSourceType, XMLResource,
+            schema: OptionalXMLSchemaBase = None,
+            cls: OptionalTypeXMLSchemaBase = None,
+            path: Optionalstr = None,
+            validation: str = 'strict',
+            process_namespaces: bool = True,
+            locations: OptionalLocationsType = None,
+            base_url: Optionalstr = None,
+            defuse: str = 'remote',
+            timeout: int = 300,
+            lazy: LazyType = False, **kwargs: Any) -> DecodeTypeAny:
+    """
+    Decodes an XML document to a Python's nested dictionary. Takes the same arguments
+    of the function :meth:`iter_decode`, but *validation* mode defaults to 'strict'.
 
-def to_json(xml_document, fp=None, schema=None, cls=None, path=None, converter=None,
-            process_namespaces=True, locations=None, base_url=None, defuse='remote',
-            timeout=300, lazy=False, json_options=None, **kwargs):
+    :return: an object containing the decoded data. If ``validation='lax'`` is provided \
+    validation errors are collected and returned in a tuple with the decoded data.
+    :raises: :exc:`XMLSchemaValidationError` if the XML document is invalid and \
+    ``validation='strict'`` is provided.
+    """
+    source, _schema = get_context(
+        xml_document, schema, cls, locations, base_url, defuse, timeout, lazy
+    )
+    return _schema.decode(source, path=path, validation=validation,
+                          process_namespaces=process_namespaces, **kwargs)
+
+
+def to_json(xml_document: UnionXMLSourceType, XMLResource,
+            fp: OptionalIOstr = None,
+            schema: OptionalXMLSchemaBase = None,
+            cls: OptionalTypeXMLSchemaBase = None,
+            path: Optionalstr = None,
+            converter: OptionalConverterType = None,
+            process_namespaces: bool = True,
+            locations: OptionalLocationsType = None,
+            base_url: Optionalstr = None,
+            defuse: str = 'remote',
+            timeout: int = 300,
+            lazy: LazyType = False,
+            json_options: OptionalDictstr, Any = None,
+            **kwargs: Any) -> JsonDecodeType:
     """
     Serialize an XML document to JSON. For default the XML data is validated during
     the decoding phase. Raises an :exc:`XMLSchemaValidationError` if the XML document
@@ -243,7 +342,7 @@
     :raises: :exc:`XMLSchemaValidationError` if the object is not decodable by \
     the XSD component, or also if it's invalid when ``validation='strict'`` is provided.
     """
-    source, schema = get_context(
+    source, _schema = get_context(
         xml_document, schema, cls, locations, base_url, defuse, timeout, lazy
     )
     if json_options is None:
@@ -253,21 +352,20 @@
     kwargs'converter' = converter
     kwargs'process_namespaces' = process_namespaces
 
-    errors = 
+    errors: ListXMLSchemaValidationError = 
 
     if path is None and source.is_lazy() and 'cls' not in json_options:
         json_options'cls' = get_lazy_json_encoder(errors)
 
-    obj = schema.decode(source, path=path, **kwargs)
+    obj = _schema.decode(source, path=path, **kwargs)
     if isinstance(obj, tuple):
+        errors.extend(obj1)
         if fp is not None:
             json.dump(obj0, fp, **json_options)
-            obj1.extend(errors)
-            return tuple(obj1)
+            return tuple(errors)
         else:
             result = json.dumps(obj0, **json_options)
-            obj1.extend(errors)
-            return result, tuple(obj1)
+            return result, tuple(errors)
     elif fp is not None:
         json.dump(obj, fp, **json_options)
         return None if not errors else tuple(errors)
@@ -276,7 +374,12 @@
         return result if not errors else (result, tuple(errors))
 
 
-def from_json(source, schema, path=None, converter=None, json_options=None, **kwargs):
+def from_json(source: Unionstr, bytes, IOstr,
+              schema: XMLSchemaBase,
+              path: Optionalstr = None,
+              converter: OptionalConverterType = None,
+              json_options: OptionalDictstr, Any = None,
+              **kwargs: Any) -> EncodeTypeElementType:
     """
     Deserialize JSON data to an XML Element.
 
@@ -289,7 +392,8 @@
     :param converter: an :class:`XMLSchemaConverter` subclass or instance to use \
     for the encoding.
     :param json_options: a dictionary with options for the JSON deserializer.
-    :param kwargs: Keyword arguments containing options for converter and encoding.
+    :param kwargs: other optional arguments of :meth:`XMLSchema.iter_encode` and \
+    options for converter.
     :return: An element tree's Element instance. If ``validation='lax'`` keyword argument is \
     provided the validation errors are collected and returned coupled in a tuple with the \
     Element instance.
@@ -301,10 +405,10 @@
     elif json_options is None:
         json_options = {}
 
-    if hasattr(source, 'read'):
-        obj = json.load(source, **json_options)
-    else:
+    if isinstance(source, (str, bytes)):
         obj = json.loads(source, **json_options)
+    else:
+        obj = json.load(source, **json_options)
 
     return schema.encode(obj, path=path, converter=converter, **kwargs)
 
@@ -332,23 +436,34 @@
     :param timeout: the timeout for base :class:`xmlschema.XMLResource` initialization.
     :param lazy: the lazy mode for base :class:`xmlschema.XMLResource` initialization.
     """
-    schema = _fallback_schema = None
-    validation = 'skip'
-    namespaces = None
-    errors = ()
-
-    def __init__(self, source, schema=None, cls=None, validation='strict',
-                 namespaces=None, locations=None, base_url=None, allow='all',
-                 defuse='remote', timeout=300, lazy=False):
-
+    schema: OptionalXMLSchemaBase = None
+    _fallback_schema: OptionalXMLSchemaBase = None
+    validation: str = 'skip'
+    namespaces: OptionalNamespacesType = None
+    errors: UnionTuple(), ListXMLSchemaValidationError = ()
+
+    def __init__(self, source: XMLSourceType,
+                 schema: OptionalUnionXMLSchemaBase, SchemaSourceType = None,
+                 cls: OptionalTypeXMLSchemaBase = None,
+                 validation: str = 'strict',
+                 namespaces: OptionalNamespacesType = None,
+                 locations: OptionalLocationsType = None,
+                 base_url: Optionalstr = None,
+                 allow: str = 'all',
+                 defuse: str = 'remote',
+                 timeout: int = 300,
+                 lazy: LazyType = False) -> None:
+
+        if cls is None:
+            cls = XMLSchema10
         self.validation = validation
         self._namespaces = namespaces
         super(XmlDocument, self).__init__(source, base_url, allow, defuse, timeout, lazy)
 
         if isinstance(schema, XMLSchemaBase) and self.namespace in schema.maps.namespaces:
             self.schema = schema
-        elif schema is not None:
-            self.schema = (cls or XMLSchema10)(
+        elif schema is not None and not isinstance(schema, XMLSchemaBase):
+            self.schema = cls(
                 source=schema,
                 base_url=base_url,
                 allow=allow,
@@ -356,9 +471,6 @@
                 timeout=timeout,
             )
         else:
-            if cls is None:
-                cls = XMLSchema10
-
             try:
                 schema_location, locations = fetch_schema_locations(self, locations, base_url)
             except ValueError:
@@ -379,14 +491,16 @@
                     timeout=timeout,
                 )
 
-        if validation == 'strict':
+        if self.schema is None:
+            pass
+        elif validation == 'strict':
             self.schema.validate(self, namespaces=self.namespaces)
         elif validation == 'lax':
             self.errors = e for e in self.schema.iter_errors(self, namespaces=self.namespaces)
         elif validation != 'skip':
             raise XMLSchemaValueError("{!r}: not a validation mode".format(validation))
 
-    def parse(self, source, lazy=False):
+    def parse(self, source: XMLSourceType, lazy: LazyType = False) -> None:
         super(XmlDocument, self).parse(source, lazy)
         self.namespaces = self.get_namespaces(self._namespaces)
 
@@ -397,11 +511,11 @@
         elif self.validation == 'lax':
             self.errors = e for e in self.schema.iter_errors(self, namespaces=self.namespaces)
 
-    def getroot(self):
+    def getroot(self) -> ElementType:
         """Get the root element of the XML document."""
         return self._root
 
-    def get_etree_document(self):
+    def get_etree_document(self) -> Any:
         """
         The resource as ElementTree XML document. If the resource is lazy raises a resource error.
         """
@@ -411,24 +525,28 @@
             msg = "cannot create an ElementTree from a lazy resource"
             raise XMLResourceError(msg)
         elif hasattr(self._root, 'nsmap'):
-            return self._root.getroottree()
+            return self._root.getroottree()  # type: ignoreattr-defined
         else:
             return ElementTree.ElementTree(self._root)
 
-    def tostring(self, indent='', max_lines=None, spaces_for_tab=4,
-                 xml_declaration=False, encoding='unicode', method='xml'):
+    def tostring(self, indent: str = '', max_lines: Optionalint = None,
+                 spaces_for_tab: int = 4, xml_declaration: bool = False,
+                 encoding: str = 'unicode', method: str = 'xml') -> str:
         if self._lazy:
             raise XMLResourceError("cannot serialize a lazy XML document")
 
-        return etree_tostring(
+        _string = etree_tostring(
             elem=self._root,
             namespaces=self.namespaces,
             xml_declaration=xml_declaration,
             encoding=encoding,
             method=method
         )
+        if isinstance(_string, bytes):
+            return _string.decode('utf-8')
+        return _string
 
-    def decode(self, **kwargs):
+    def decode(self, **kwargs: Any) -> DecodeTypeAny:
         """
         Decode the XML document to a nested Python dictionary.
 
@@ -439,10 +557,16 @@
         if 'namespaces' not in kwargs:
             kwargs'namespaces' = self.namespaces
 
-        obj = (self.schema or self._fallback_schema).to_dict(self, **kwargs)
+        schema = self.schema or self._fallback_schema
+        if schema is None:
+            return None
+
+        obj = schema.to_dict(self, **kwargs)
         return obj0 if isinstance(obj, tuple) else obj
 
-    def to_json(self, fp=None, json_options=None, **kwargs):
+    def to_json(self, fp: OptionalIOstr = None,
+                json_options: OptionalDictstr, Any = None,
+                **kwargs: Any) -> JsonDecodeType:
         """
         Converts loaded XML data to a JSON string or file.
 
@@ -460,13 +584,18 @@
         if 'decimal_type' not in kwargs:
             kwargs'decimal_type' = float
 
-        errors = 
+        errors: ListXMLSchemaValidationError = 
 
         if path is None and self._lazy and 'cls' not in json_options:
             json_options'cls' = get_lazy_json_encoder(errors)
             kwargs'lazy_decode' = True
 
-        obj = (self.schema or self._fallback_schema).decode(self, path=path, **kwargs)
+        schema = self.schema or self._fallback_schema
+        if schema is not None:
+            obj = schema.decode(self, path=path, **kwargs)
+        else:
+            obj = None
+
         if isinstance(obj, tuple):
             if fp is not None:
                 json.dump(obj0, fp, **json_options)
@@ -484,13 +613,14 @@
             result = json.dumps(obj, **json_options)
             return result if not errors else (result, tuple(errors))
 
-    def write(self, file, encoding='us-ascii', xml_declaration=None,
-              default_namespace=None, method="xml"):
+    def write(self, file: Unionstr, TextIO, BinaryIO,
+              encoding: str = 'us-ascii', xml_declaration: bool = False,
+              default_namespace: Optionalstr = None, method: str = "xml") -> None:
         """Serialize an XML resource to a file. Cannot be used with lazy resources."""
         if self._lazy:
             raise XMLResourceError("cannot serialize a lazy XML document")
 
-        kwargs = {
+        kwargs: Dictstr, Any = {
             'xml_declaration': xml_declaration,
             'encoding': encoding,
             'method': method,
@@ -498,19 +628,39 @@
         if not default_namespace:
             kwargs'namespaces' = self.namespaces
         else:
-            namespaces = self.namespaces.copy()
+            namespaces: OptionalDictOptionalstr, str
+            if self.namespaces is None:
+                namespaces = {}
+            else:
+                namespaces = {k: v for k, v in self.namespaces.items()}
+
             if hasattr(self._root, 'nsmap'):
+                # noinspection PyTypeChecker
                 namespacesNone = default_namespace
             else:
                 namespaces'' = default_namespace
             kwargs'namespaces' = namespaces
 
-        if hasattr(file, 'write'):
-            file.write(etree_tostring(self._root, **kwargs))
-            file.close()
-        elif encoding == 'unicode':
-            with open(file, 'w', encoding='utf-8') as fp:
-                fp.write(etree_tostring(self._root, **kwargs))
+        _string = etree_tostring(self._root, **kwargs)
+
+        if isinstance(file, str):
+            if isinstance(_string, str):
+                with open(file, 'w', encoding='utf-8') as fp:
+                    fp.write(_string)
+            else:
+                with open(file, 'wb') as _fp:
+                    _fp.write(_string)
+
+        elif isinstance(file, TextIOBase):
+            if isinstance(_string, bytes):
+                file.write(_string.decode('utf-8'))
+            else:
+                file.write(_string)
+
+        elif isinstance(file, IOBase):
+            if isinstance(_string, str):
+                file.write(_string.encode('utf-8'))
+            else:
+                file.write(_string)
         else:
-            with open(file, 'wb') as fp:
-                fp.write(etree_tostring(self._root, **kwargs))
+            raise XMLSchemaTypeError(f"unexpected type {type(file)} for 'file' argument")

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/etree.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/etree.py Changed

@@ -11,8 +11,9 @@
 A unified setup module for ElementTree with a safe parser and helper functions.
 """
 import sys
-import importlib
 import re
+from collections import namedtuple
+from typing import Any, MutableMapping, Optional, Union
 
 from .exceptions import XMLSchemaTypeError
 
@@ -26,31 +27,30 @@
 # defining a safer XMLParser.
 #
 if '_elementtree' in sys.modules:
-    # Temporary remove the loaded modules
-    try:
-        ElementTree = sys.modules.pop('xml.etree.ElementTree')
-    except KeyError:
-        # Reimporting xml.etree.ElementTree causes the loading of pure Python
-        # module instead of the optimized C version, so it's better to raise
-        # an error instead of running silently with mismatched modules.
+    if 'xml.etree.ElementTree' not in sys.modules:
         raise RuntimeError("Inconsistent status for ElementTree module: module "
                            "is missing but the C optimized version is imported.")
 
+    import xml.etree.ElementTree as ElementTree
+
+    # Temporary remove the loaded modules
+    sys.modules.pop('xml.etree.ElementTree')
     _cmod = sys.modules.pop('_elementtree')
 
     # Load the pure Python module
-    sys.modules'_elementtree' = None
-    PyElementTree = importlib.import_module('xml.etree.ElementTree')
+    sys.modules'_elementtree' = None  # type: ignoreassignment
+    import xml.etree.ElementTree as PyElementTree
+    import xml.etree
 
     # Restore original modules
     sys.modules'_elementtree' = _cmod
-    sys.modules'xml.etree'.ElementTree = ElementTree
+    xml.etree.ElementTree = ElementTree
     sys.modules'xml.etree.ElementTree' = ElementTree
 
 else:
     # Load the pure Python module
-    sys.modules'_elementtree' = None
-    PyElementTree = importlib.import_module('xml.etree.ElementTree')
+    sys.modules'_elementtree' = None  # type: ignoreassignment
+    import xml.etree.ElementTree as PyElementTree
 
     # Remove the pure Python module from imported modules
     del sys.modules'xml.etree'
@@ -58,7 +58,7 @@
     del sys.modules'_elementtree'
 
     # Load the C optimized ElementTree module
-    ElementTree = importlib.import_module('xml.etree.ElementTree')
+    import xml.etree.ElementTree as ElementTree
 
 
 etree_element = ElementTree.Element
@@ -76,38 +76,56 @@
     :param encoding: if provided, its value overrides the encoding specified \
     in the XML file.
     """
-    def __init__(self, target=None, encoding=None):
+    def __init__(self, target: OptionalAny = None, encoding: Optionalstr = None) -> None:
         super(SafeXMLParser, self).__init__(target=target, encoding=encoding)
         self.parser.EntityDeclHandler = self.entity_declaration
         self.parser.UnparsedEntityDeclHandler = self.unparsed_entity_declaration
         self.parser.ExternalEntityRefHandler = self.external_entity_reference
 
-    def entity_declaration(self, entity_name, is_parameter_entity, value, base,
+    def entity_declaration(self, entity_name, is_parameter_entity, value, base,  # type: ignore
                            system_id, public_id, notation_name):
         raise PyElementTree.ParseError(
             "Entities are forbidden (entity_name={!r})".format(entity_name)
         )
 
-    def unparsed_entity_declaration(self, entity_name, base, system_id,
+    def unparsed_entity_declaration(self, entity_name, base, system_id,  # type: ignore
                                     public_id, notation_name):
         raise PyElementTree.ParseError(
             "Unparsed entities are forbidden (entity_name={!r})".format(entity_name)
         )
 
-    def external_entity_reference(self, context, base, system_id, public_id):
+    def external_entity_reference(self, context, base, system_id, public_id):  # type: ignore
         raise PyElementTree.ParseError(
             "External references are forbidden (system_id={!r}, "
             "public_id={!r})".format(system_id, public_id)
         )  # pragma: no cover (EntityDeclHandler is called before)
 
 
-def is_etree_element(obj):
+ElementData = namedtuple('ElementData', 'tag', 'text', 'content', 'attributes')
+"""
+Namedtuple for Element data interchange between decoders and converters.
+The field *tag* is a string containing the Element's tag, *text* can be `None`
+or a string representing the Element's text, *content* can be `None`, a list
+containing the Element's children or a dictionary containing element name to
+list of element contents for the Element's children (used for unordered input
+data), *attributes* can be `None` or a dictionary containing the Element's
+attributes.
+"""
+
+
+def is_etree_element(obj: Any) -> bool:
     """A checker for valid ElementTree elements that excludes XsdElement objects."""
     return hasattr(obj, 'append') and hasattr(obj, 'tag') and hasattr(obj, 'attrib')
 
 
-def etree_tostring(elem, namespaces=None, indent='', max_lines=None, spaces_for_tab=None,
-                   xml_declaration=None, encoding='unicode', method='xml'):
+def etree_tostring(elem: etree_element,
+                   namespaces: OptionalMutableMappingstr, str = None,
+                   indent: str = '',
+                   max_lines: Optionalint = None,
+                   spaces_for_tab: Optionalint = None,
+                   xml_declaration: Optionalbool = None,
+                   encoding: str = 'unicode',
+                   method: str = 'xml') -> Unionstr, bytes:
     """
     Serialize an Element tree to a string. Tab characters are replaced by whitespaces.
 
@@ -125,7 +143,7 @@
     :param method: is either "xml" (the default), "html" or "text".
     :return: a Unicode string.
     """
-    def reindent(line):
+    def reindent(line: str) -> str:
         if not line:
             return line
         elif line.startswith(min_indent):
@@ -133,6 +151,7 @@
         else:
             return indent + line
 
+    etree_module: Any
     if not is_etree_element(elem):
         raise XMLSchemaTypeError("{!r} is not an Element".format(elem))
 
@@ -141,7 +160,7 @@
     elif not hasattr(elem, 'nsmap'):
         etree_module = ElementTree
     else:
-        etree_module = importlib.import_module('lxml.etree')
+        import lxml.etree as etree_module  # type: ignoreno-redef
 
     if namespaces:
         default_namespace = namespaces.get('')
@@ -200,3 +219,7 @@
     if encoding == 'unicode':
         return '\n'.join(reindent(line) for line in lines)
     return '\n'.join(reindent(line) for line in lines).encode(encoding)
+
+
+__all__ = 'ElementTree', 'PyElementTree', 'ParseError', 'SafeXMLParser', 'etree_element',
+           'py_etree_element', 'ElementData', 'is_etree_element', 'etree_tostring'

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/exceptions.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/exceptions.py Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/extras/codegen.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/extras/codegen.py Changed

@@ -19,8 +19,11 @@
 from abc import ABC, ABCMeta
 from fnmatch import fnmatch
 from pathlib import Path
+from typing import Optional, List
+
 from jinja2 import Environment, ChoiceLoader, FileSystemLoader, \
     TemplateNotFound, TemplateAssertionError
+from elementpath import datatypes
 
 import xmlschema
 from xmlschema.validators import XsdType, XsdElement, XsdAttribute
@@ -55,10 +58,6 @@
 
 
 logger = logging.getLogger('xmlschema-codegen')
-logging_formatter = logging.Formatter('%(levelname)s %(message)s')
-logging_handler = logging.StreamHandler(sys.stderr)
-logging_handler.setFormatter(logging_formatter)
-logger.addHandler(logging_handler)
 
 
 class GeneratorMeta(ABCMeta):
@@ -126,10 +125,10 @@
     in generator class.
     :param types_map: a dictionary with custom mapping for XSD types.
     """
-    formal_language = None
+    formal_language: Optionalstr = None
     """The formal language associated to the code generator (eg. Python)."""
 
-    searchpaths = None
+    searchpaths: OptionalListstr = None
     """
     Directory paths for searching templates, specified with a list or a tuple.
     Each path must be provided as relative from the directory of the module
@@ -262,7 +261,7 @@
                 logger.info("write file %r", str(output_file))
                 with open(output_file, 'w') as fp:
                     fp.write(result)
-                rendered.append(template.filename)
+                rendered.append(str(output_file))
 
         return rendered
 
@@ -359,43 +358,48 @@
 
             try:
                 if obj0 == '{':
-                    namespace, local_name = obj.split('}')
+                    namespace, local_name = obj1:.split('}')
                     for prefix, uri in self.schema.namespaces.items():
                         if uri == namespace:
-                            qname = '%s:%s' % (uri, local_name)
+                            qname = '%s:%s' % (prefix, local_name)
                             break
                     else:
                         qname = local_name
                 else:
                     qname = obj
-            except (IndexError, ValueError):
+            except IndexError:
+                return ''
+            except ValueError:
                 return unnamed
 
         if not qname or QNAME_PATTERN.match(qname) is None:
             return unnamed
         return qname.replace('.', '_').replace('-', '_').replace(':', sep)
 
-    @staticmethod
     @filter_method
-    def namespace(obj):
+    def namespace(self, obj):
+        """Get the namespace URI of the provided object."""
         try:
             namespace = obj.target_namespace
         except AttributeError:
-            try:
-                obj = obj.name
-            except AttributeError:
-                pass
+            if isinstance(obj, datatypes.QName):
+                return obj.namespace
+            elif not isinstance(obj, str):
+                return ''
 
             try:
-                if not isinstance(obj, str) or obj0 != '{':
+                if obj0 == '{':
+                    namespace, _ = obj1:.split('}')
+                    return namespace
+                elif ':' in obj:
+                    prefix, _ = obj.split(':')
+                    return self.schema.namespaces.get(prefix, '')
+                else:
                     return ''
-                namespace, _ = obj.split('}')
             except (IndexError, ValueError):
                 return ''
         else:
-            if not isinstance(namespace, str):
-                return ''
-        return namespace
+            return namespace if isinstance(namespace, str) else ''
 
     @staticmethod
     @filter_method
@@ -416,9 +420,6 @@
         else:
             name = unnamed
 
-        if not name or NCNAME_PATTERN.match(name) is None:
-            name = unnamed
-
         if name.endswith('Type'):
             name = name:-4
         elif name.endswith('_type'):
@@ -449,9 +450,6 @@
         else:
             qname = unnamed
 
-        if not qname or QNAME_PATTERN.match(qname) is None:
-            qname = unnamed
-
         if qname.endswith('Type'):
             qname = qname:-4
         elif qname.endswith('_type'):
@@ -466,10 +464,11 @@
     @filter_method
     def sort_types(xsd_types, accept_circularity=False):
         """
-        Returns a sorted sequence of XSD types. Sorted types can be used to build code declarations.
+        Returns a sorted sequence of XSD types usable for building type declarations.
 
         :param xsd_types: a sequence with XSD types.
-        :param accept_circularity: if set to `True` circularities are accepted. Defaults to `False`.
+        :param accept_circularity: if set to `True` circularities \
+        are accepted. Defaults to `False`.
         :return: a list with ordered types.
         """
         if not isinstance(xsd_types, (list, tuple)):
@@ -484,7 +483,7 @@
         unordered = {x:  for x in xsd_types if x.is_complex() and not x.has_simple_content()}
 
         for xsd_type in unordered:
-            for e in xsd_type.content_type.iter_elements():
+            for e in xsd_type.content.iter_elements():
                 if e.type in unordered:
                     unorderedxsd_type.append(e.type)
 
@@ -502,7 +501,7 @@
 
             if not deleted:
                 if not accept_circularity:
-                    raise ValueError("Circularity found between {!r}".format(list(unordered)))
+                    raise ValueError("circularity found between {!r}".format(list(unordered)))
                 ordered_types.extend(list(unordered))
                 break
 
@@ -510,23 +509,32 @@
         return ordered_types
 
     def is_derived(self, xsd_type, *names, derivation=None):
+        """
+        Returns `True` if the argument XSD type is derived from any
+        of other types expressed by name, otherwise returns `False`.
+
+        :param xsd_type: an XsdComplexType/XsdSimpleType instance.
+        :param names: positional argument with the names of other \
+        XSD types.
+        :param derivation: the type of derivation, that can be \
+        *extension* or *restriction*, or both with a space separator. \
+        If no value is provided it only checks if it is derived from \
+        or if it is the XSD type itself.
+        """
         for type_name in names:
             if not isinstance(type_name, str) or not type_name:
-                continue
-            elif type_name0 == '{':
-                if xsd_type.is_derived(self.schema.maps.typestype_name, derivation):
-                    return True
-            elif ':' in type_name:
+                continue  # pragma: no cover
+            elif type_name0 != '{' and ':' in type_name:
                 try:
-                    other = self.schema.resolve_qname(type_name)
+                    type_name = self.schema.resolve_qname(type_name)
                 except xmlschema.XMLSchemaException:
                     continue
-                else:
-                    if xsd_type.is_derived(other, derivation):
-                        return True
-            else:
-                if xsd_type.is_derived(self.schema.typestype_name, derivation):
+
+            try:
+                if xsd_type.is_derived(self.schema.maps.typestype_name, derivation):
                     return True
+            except KeyError:
+                pass
 
         return False
 
@@ -545,9 +553,10 @@
     @staticmethod
     @test_method
     def multi_sequence(xsd_type):
-        if xsd_type.has_simple_content():
+        try:
+            return any(e.is_multiple() for e in xsd_type.content.iter_elements())
+        except AttributeError:
             return False
-        return any(e.is_multiple() for e in xsd_type.content_type.iter_elements())
 
 
 class PythonGenerator(AbstractGenerator):

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/extras/templates/python/bindings.py.jinja -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/extras/templates/python/bindings.py.jinja Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/helpers.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/helpers.py Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/namespaces.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/namespaces.py Changed

@@ -11,29 +11,33 @@
 This module contains classes for managing maps related to namespaces.
 """
 import re
-from collections.abc import MutableMapping, Mapping
+from typing import Any, Container, Dict, Iterator, List, Optional, MutableMapping, \
+    Mapping, TypeVar
 
 from .exceptions import XMLSchemaValueError, XMLSchemaTypeError
 from .helpers import local_name
+from .aliases import NamespacesType
 
 
 ###
 # Base classes for managing namespaces
 
-class NamespaceResourcesMap(MutableMapping):
+class NamespaceResourcesMap(MutableMappingstr, Any):
     """
     Dictionary for storing information about namespace resources. The values are
-    lists of strings. Setting an existing value appends the string to the value.
+    lists of objects. Setting an existing value appends the object to the value.
     Setting a value with a list sets/replaces the value.
     """
-    def __init__(self, *args, **kwargs):
-        self._store = dict()
+    __slots__ = ('_store',)
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        self._store: Dictstr, ListAny = {}
         self.update(*args, **kwargs)
 
-    def __getitem__(self, uri):
+    def __getitem__(self, uri: str) -> Any:
         return self._storeuri
 
-    def __setitem__(self, uri, value):
+    def __setitem__(self, uri: str, value: Any) -> None:
         if isinstance(value, list):
             self._storeuri = value:
         else:
@@ -42,23 +46,23 @@
             except KeyError:
                 self._storeuri = value
 
-    def __delitem__(self, uri):
+    def __delitem__(self, uri: str) -> None:
         del self._storeuri
 
-    def __iter__(self):
+    def __iter__(self) -> Iteratorstr:
         return iter(self._store)
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self._store)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return repr(self._store)
 
-    def clear(self):
+    def clear(self) -> None:
         self._store.clear()
 
 
-class NamespaceMapper(MutableMapping):
+class NamespaceMapper(MutableMappingstr, str):
     """
     A class to map/unmap namespace prefixes to URIs. The mapped namespaces are
     automatically registered when set. Namespaces can be updated overwriting
@@ -70,49 +74,53 @@
     :param strip_namespaces: if set to `True` uses name mapping methods that strip \
     namespace information.
     """
-    def __init__(self, namespaces=None, strip_namespaces=False):
+    __slots__ = '_namespaces', 'strip_namespaces', '__dict__'
+    _namespaces: NamespacesType
+
+    def __init__(self, namespaces: OptionalNamespacesType = None,
+                 strip_namespaces: bool = False):
         if namespaces is None:
             self._namespaces = {}
         else:
             self._namespaces = namespaces
         self.strip_namespaces = strip_namespaces
 
-    def __setattr__(self, name, value):
+    def __setattr__(self, name: str, value: str) -> None:
         if name == 'strip_namespaces':
             if value:
-                self.map_qname = self.unmap_qname = self._local_name
+                self.map_qname = self.unmap_qname = self._local_name  # type: ignoreassignment
             elif getattr(self, 'strip_namespaces', False):
-                self.map_qname = self._map_qname
-                self.unmap_qname = self._unmap_qname
+                self.map_qname = self._map_qname  # type: ignoreassignment
+                self.unmap_qname = self._unmap_qname  # type: ignoreassignment
         super(NamespaceMapper, self).__setattr__(name, value)
 
-    def __getitem__(self, prefix):
+    def __getitem__(self, prefix: str) -> str:
         return self._namespacesprefix
 
-    def __setitem__(self, prefix, uri):
+    def __setitem__(self, prefix: str, uri: str) -> None:
         self._namespacesprefix = uri
 
-    def __delitem__(self, prefix):
+    def __delitem__(self, prefix: str) -> None:
         del self._namespacesprefix
 
-    def __iter__(self):
+    def __iter__(self) -> Iteratorstr:
         return iter(self._namespaces)
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self._namespaces)
 
     @property
-    def namespaces(self):
+    def namespaces(self) -> NamespacesType:
         return self._namespaces
 
     @property
-    def default_namespace(self):
+    def default_namespace(self) -> Optionalstr:
         return self._namespaces.get('')
 
-    def clear(self):
+    def clear(self) -> None:
         self._namespaces.clear()
 
-    def insert_item(self, prefix, uri):
+    def insert_item(self, prefix: str, uri: str) -> None:
         """
         A method for setting an item that checks the prefix before inserting.
         In case of collision the prefix is changed adding a numerical suffix.
@@ -136,7 +144,7 @@
                 prefix += '0'
         self._namespacesprefix = uri
 
-    def _map_qname(self, qname):
+    def _map_qname(self, qname: str) -> str:
         """
         Converts an extended QName to the prefixed format. Only registered
         namespaces are mapped.
@@ -163,7 +171,8 @@
 
     map_qname = _map_qname
 
-    def _unmap_qname(self, qname, name_table=None):
+    def _unmap_qname(self, qname: str,
+                     name_table: OptionalContainerOptionalstr = None) -> str:
         """
         Converts a QName in prefixed format or a local name to the extended QName format.
         Local names are converted only if a default namespace is included in the instance.
@@ -202,10 +211,10 @@
     unmap_qname = _unmap_qname
 
     @staticmethod
-    def _local_name(qname, *_args, **_kwargs):
+    def _local_name(qname: str, *_args: Any, **_kwargs: Any) -> str:
         return local_name(qname)
 
-    def transfer(self, namespaces):
+    def transfer(self, namespaces: NamespacesType) -> None:
         """
         Transfers compatible prefix/namespace registrations from a dictionary.
         Registrations added to namespace mapper instance are deleted from argument.
@@ -225,12 +234,17 @@
             del namespacesk
 
 
-class NamespaceView(Mapping):
+T = TypeVar('T')
+
+
+class NamespaceView(Mappingstr, T):
     """
     A read-only map for filtered access to a dictionary that stores
     objects mapped from QNames in extended format.
     """
-    def __init__(self, qname_dict, namespace_uri):
+    __slots__ = 'target_dict', 'namespace', '_key_fmt'
+
+    def __init__(self, qname_dict: Dictstr, T, namespace_uri: str):
         self.target_dict = qname_dict
         self.namespace = namespace_uri
         if namespace_uri:
@@ -238,16 +252,16 @@
         else:
             self._key_fmt = '%s'
 
-    def __getitem__(self, key):
+    def __getitem__(self, key: str) -> T:
         return self.target_dictself._key_fmt % key
 
-    def __len__(self):
+    def __len__(self) -> int:
         if not self.namespace:
             return len(k for k in self.target_dict if not k or k0 != '{')
         return len(k for k in self.target_dict
                     if k and k0 == '{' and self.namespace == k1:k.rindex('}'))
 
-    def __iter__(self):
+    def __iter__(self) -> Iteratorstr:
         if not self.namespace:
             for k in self.target_dict:
                 if not k or k0 != '{':
@@ -257,16 +271,18 @@
                 if k and k0 == '{' and self.namespace == k1:k.rindex('}'):
                     yield kk.rindex('}') + 1:
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return '%s(%s)' % (self.__class__.__name__, str(self.as_dict()))
 
-    def __contains__(self, key):
-        return self._key_fmt % key in self.target_dict
+    def __contains__(self, key: object) -> bool:
+        if isinstance(key, str):
+            return self._key_fmt % key in self.target_dict
+        return key in self.target_dict
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> Any:
         return self.as_dict() == other
 
-    def as_dict(self, fqn_keys=False):
+    def as_dict(self, fqn_keys: bool = False) -> Dictstr, T:
         if not self.namespace:
             return {
                 k: v for k, v in self.target_dict.items() if not k or k0 != '{'

_service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/py.typed Added

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/resources.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/resources.py Changed

@@ -1,4 +1,4 @@
-#
+#
 # Copyright (c), 2016-2020, SISSA (International School for Advanced Studies).
 # All rights reserved.
 # This file is distributed under the terms of the MIT License.
@@ -7,37 +7,49 @@
 #
 # @author Davide Brunato <brunato@sissa.it>
 #
+import copy
 import os.path
+import platform
 import re
-from string import ascii_letters
-from elementpath import iter_select, XPath1Parser, XPathContext, XPath2Parser
+import string
 from io import StringIO, BytesIO
-from urllib.request import urlopen, pathname2url
-from urllib.parse import uses_relative, urlsplit, urljoin, urlunsplit
+from pathlib import Path, PurePath, PurePosixPath, PureWindowsPath
+from typing import cast, Any, AnyStr, Dict, Optional, IO, Iterator, List, \
+    MutableMapping, Union, Tuple
+from urllib.request import urlopen
+from urllib.parse import urlsplit, urlunsplit, unquote, quote_from_bytes
 from urllib.error import URLError
 
+from elementpath import iter_select, XPathContext, XPath2Parser
+from elementpath.protocols import ElementProtocol
+
 from .exceptions import XMLSchemaTypeError, XMLSchemaValueError, XMLResourceError
 from .names import XML_NAMESPACE
 from .etree import ElementTree, PyElementTree, SafeXMLParser, etree_tostring
+from .aliases import ElementType, ElementTreeType, NamespacesType, XMLSourceType, \
+    NormalizedLocationsType, LocationsType, NsmapType, ParentMapType
 from .helpers import get_namespace, is_etree_element, is_etree_document, \
     etree_iter_location_hints
 
-DEFUSE_MODES = ('never', 'remote', 'always')
-SECURITY_MODES = ('all', 'remote', 'local', 'sandbox')
-
+DEFUSE_MODES = frozenset(('never', 'remote', 'always'))
+SECURITY_MODES = frozenset(('all', 'remote', 'local', 'sandbox'))
 
 ###
 # Restricted XPath parser for XML resources
-LAZY_XML_XPATH_SYMBOLS = {
+LAZY_XML_XPATH_SYMBOLS = frozenset((
     'position', 'last', 'not', 'and', 'or', '!=', '<=', '>=', '(', ')', 'text',
-    '', '', '.', ',', '/', '|', '*', '=', '<', '>', ':', '(end)', '(name)',
-    '(string)', '(float)', '(decimal)', '(integer)', '@'
-}
+    '', '', '.', ',', '/', '|', '*', '=', '<', '>', ':', '@', '(end)',
+    '(unknown)', '(invalid)', '(name)', '(string)', '(float)', '(decimal)',
+    '(integer)'
+))
+
+DRIVE_LETTERS = frozenset(string.ascii_letters)
 
 
 class LazyXPath2Parser(XPath2Parser):
     symbol_table = {
-        k: v for k, v in XPath1Parser.symbol_table.items() if k in LAZY_XML_XPATH_SYMBOLS
+        k: v for k, v in XPath2Parser.symbol_table.items()  # type: ignoremisc
+        if k in LAZY_XML_XPATH_SYMBOLS
     }
     SYMBOLS = LAZY_XML_XPATH_SYMBOLS
 
@@ -45,15 +57,15 @@
 class LazySelector:
     """A limited XPath selector class for lazy XML resources."""
 
-    def __init__(self, path, namespaces=None):
+    def __init__(self, path: str, namespaces: OptionalNamespacesType = None) -> None:
         self.parser = LazyXPath2Parser(namespaces, strict=False)
         self.path = path
         self.root_token = self.parser.parse(path)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return '%s(path=%r)' % (self.__class__.__name__, self.path)
 
-    def select(self, root, **kwargs):
+    def select(self, root: ElementProtocol, **kwargs: Any) -> ListElementProtocol:
         context = XPathContext(root, **kwargs)
         results = self.root_token.get_results(context)
         if not isinstance(results, list) or any(not is_etree_element(x) for x in results):
@@ -61,151 +73,230 @@
             raise XMLResourceError(msg)
         return results
 
-    def iter_select(self, root, **kwargs):
+    def iter_select(self, root: ElementProtocol, **kwargs: Any) -> IteratorElementProtocol:
         context = XPathContext(root, **kwargs)
         for elem in self.root_token.select_results(context):
             if not is_etree_element(elem):
                 msg = "XPath expressions on lazy resources can select only elements"
                 raise XMLResourceError(msg)
-            yield elem
+            yield cast(ElementProtocol, elem)
 
 
 ###
 # URL normalization (that fixes many headaches :)
+class _PurePath(PurePath):
+    """
+    A version of pathlib.PurePath adapted for managing the creation
+    from URIs and the simple normalization of paths.
+    """
+    _from_parts: Any
+    _flavour: Any
+
+    def __new__(cls, *args: str) -> '_PurePath':
+        if cls is _PurePath:
+            cls = _PureWindowsPath if os.name == 'nt' else _PurePosixPath
+        return cast('_PurePath', cls._from_parts(args))
+
+    @classmethod
+    def from_uri(cls, uri: str) -> '_PurePath':
+        uri = uri.strip()
+        if not uri:
+            raise XMLSchemaValueError("Empty URI provided!")
+
+        if uri.startswith(r'\\'):
+            return _PureWindowsPath(uri)  # UNC path
+        elif uri.startswith('/'):
+            return cls(uri)
+
+        parts = urlsplit(uri)
+        if not parts.scheme:
+            return cls(uri)
+        elif parts.scheme in DRIVE_LETTERS and len(parts.scheme) == 1:
+            return _PureWindowsPath(uri)  # Eg. k:/Python/lib/....
+        elif parts.scheme != 'file':
+            return _PurePosixPath(unquote(parts.path))
+
+        # Get file URI path because urlsplit does not parse it well
+        start = 7 if uri.startswith('file:///') else 5
+        if parts.query:
+            path = uristart:uri.index('?')
+        elif parts.fragment:
+            path = uristart:uri.index('#')
+        else:
+            path = uristart:
+
+        if ':' in path:
+            # Windows path with a drive
+            pos = path.index(':')
+            if pos == 2 and path0 == '/' and path1 in DRIVE_LETTERS:
+                return _PureWindowsPath(unquote(path1:))
+
+            obj = _PureWindowsPath(unquote(path))
+            if len(obj.drive) != 2 or obj.drive1 != ':':
+                raise XMLSchemaValueError("Invalid URI {!r}".format(uri))
+            return obj
+
+        if '\\' in path:
+            return _PureWindowsPath(unquote(path))
+        return cls(unquote(path))
+
+    def as_uri(self) -> str:
+        if not self.is_absolute():
+            uri: str = self._flavour.make_uri(self)
+            while uri.startswith('file:/'):
+                uri = uri.replace('file:/', 'file:', 1)
+            return uri
+
+        uri = cast(str, self._flavour.make_uri(self))
+        if isinstance(self, _PureWindowsPath) and str(self).startswith(r'\\'):
+            # UNC format case: use the format where the host part is included
+            # in the path part, to let urlopen() works.
+            if not uri.startswith('file:////'):
+                return uri.replace('file://', 'file:////')
+        return uri
+
+    def normalize(self) -> '_PurePath':
+        normalized_path = self._flavour.pathmod.normpath(str(self))
+        return cast('_PurePath', self._from_parts((normalized_path,)))
+
+
+class _PurePosixPath(_PurePath, PurePosixPath):
+    __slots__ = ()
 
-def normalize_url(url, base_url=None, keep_relative=False):
+
+class _PureWindowsPath(_PurePath, PureWindowsPath):
+    __slots__ = ()
+
+
+def normalize_url(url: str, base_url: Optionalstr = None,
+                  keep_relative: bool = False) -> str:
     """
-    Returns a normalized URL doing a join with a base URL. URL scheme defaults to 'file' and
-    backslashes are replaced with slashes. For file paths the os.path.join is used instead of
-    urljoin.
+    Returns a normalized URL eventually joining it to a base URL if it's a relative path.
+    Path names are converted to 'file' scheme URLs.
 
     :param url: a relative or absolute URL.
-    :param base_url: the reference base URL for construct the normalized URL from \
-    the argument. For compatibility between "os.path.join" and "urljoin" a trailing \
-    '/' is added to not empty paths.
+    :param base_url: a reference base URL.
     :param keep_relative: if set to `True` keeps relative file paths, which would \
-    not strictly conformant to URL format specification.
-    :return: A normalized URL.
+    not strictly conformant to specification (RFC 8089), because *urlopen()* doesn't \
+    accept a simple pathname.
+    :return: a normalized URL string.
     """
-    def add_trailing_slash(x):
-        return urlunsplit(
-            (x0, x1, x2 + '/' if x2 and x2-1 != '/' else x2, x3, x4)
-        )
+    url_parts = urlsplit(url)
+    if not is_local_scheme(url_parts.scheme):
+        return url_parts.geturl()
 
-    def filter_url(x):
-        x = x.strip().replace('\\', '/')
-        while x.startswith('//'):
-            x = x.replace('//', '/', 1)
-        while x.startswith('file:////'):
-            x = x.replace('file:////', 'file:///', 1)
-        if urlsplit(x).scheme in {'', 'file'}:
-            x = x.replace('#', '%23')
-        return x
-
-    url = filter_url(url)
+    path = _PurePath.from_uri(url)
+    if path.is_absolute():
+        return path.normalize().as_uri()
 
     if base_url is not None:
-        base_url = filter_url(base_url)
         base_url_parts = urlsplit(base_url)
-        base_url = add_trailing_slash(base_url_parts)
-        if base_url_parts.scheme not in uses_relative:
-            base_url_parts = urlsplit('file:///{}'.format(base_url))
-        else:
-            base_url_parts = urlsplit(base_url)
-
-        if base_url_parts.scheme not in ('', 'file'):
-            url = urljoin(base_url, url)
-        else:
-            url_parts = urlsplit(url)
-            if url_parts.scheme not in ('', 'file'):
-                url = urljoin(base_url, url)
-            elif not url_parts.netloc or base_url_parts.netloc == url_parts.netloc:
-                # Join paths only if host parts (netloc) are equal, using the os.path.join
-                # instead of urljoin for path normalization.
-                url = urlunsplit((
-                    '',
-                    base_url_parts.netloc,
-                    os.path.normpath(os.path.join(base_url_parts.path, url_parts.path)),
-                    url_parts.query,
-                    url_parts.fragment,
-                ))
-
-                # Add 'file' scheme if '//' prefix is added
-                if base_url_parts.netloc and not url.startswith(base_url_parts.netloc) \
-                        and url.startswith('//'):
-                    url = 'file:' + url
-
-    url_parts = urlsplit(url, scheme='file')
-    if url_parts.scheme not in uses_relative:
-        normalized_url = 'file:///{}'.format(url_parts.geturl())  # Eg. k:/Python/lib/....
-    elif url_parts.scheme != 'file':
-        normalized_url = urlunsplit((
-            url_parts.scheme,
-            url_parts.netloc,
-            pathname2url(url_parts.path),
-            url_parts.query,
-            url_parts.fragment,
-        ))
-    elif os.path.isabs(url_parts.path):
-        normalized_url = url_parts.geturl()
-    elif keep_relative:
-        # Can't use urlunsplit with a scheme because it converts relative paths to absolute ones.
-        normalized_url = 'file:{}'.format(urlunsplit(('',) + url_parts1:))
-    else:
-        normalized_url = urlunsplit((
-            url_parts.scheme,
-            url_parts.netloc,
-            os.path.abspath(url_parts.path),
-            url_parts.query,
-            url_parts.fragment,
-        ))
-    return filter_url(normalized_url)
+        base_path = _PurePath.from_uri(base_url)
+        if is_local_scheme(base_url_parts.scheme):
+            path = base_path.joinpath(path)
+        elif not url_parts.scheme:
+            path = base_path.joinpath(path).normalize()
+            return urlunsplit((
+                base_url_parts.scheme,
+                base_url_parts.netloc,
+                quote_from_bytes(bytes(path)),
+                url_parts.query,
+                url_parts.fragment
+            ))
+
+    if path.is_absolute() or keep_relative:
+        return path.normalize().as_uri()
+
+    base_path = _PurePath(os.getcwd())
+    return base_path.joinpath(path).normalize().as_uri()
 
 
 ###
 # Internal helper functions
 
-def is_url(obj):
-    """
-    Checks if and object can be an URL, restricting to strings that cannot be XML data.
-    """
-    if not isinstance(obj, (str, bytes)):
-        return False
-    elif '\n' in obj or obj.lstrip().startswith('<'):
-        return False
+def is_local_scheme(scheme: str) -> bool:
+    return not scheme or scheme == 'file' or scheme in DRIVE_LETTERS
 
-    try:
-        urlsplit(obj.strip())
-    except ValueError:
-        return False
+
+def is_url(obj: object) -> bool:
+    """Returns `True` if the provided object is an URL, `False` otherwise."""
+    if isinstance(obj, str):
+        if '\n' in obj or obj.lstrip().startswith('<'):
+            return False
+        try:
+            urlsplit(obj.strip())
+        except ValueError:
+            return False
+    elif isinstance(obj, bytes):
+        if b'\n' in obj or obj.lstrip().startswith(b'<'):
+            return False
+        try:
+            urlsplit(obj.strip())
+        except ValueError:
+            return False
     else:
-        return True
+        return isinstance(obj, Path)
 
+    return True
 
-def is_remote_url(url):
-    if not is_url(url):
-        return False
-    scheme = urlsplit(normalize_url(url)).scheme
-    return scheme not in ('', 'file') and (len(scheme) > 1 or scheme not in ascii_letters)
 
+def is_remote_url(obj: object) -> bool:
+    if isinstance(obj, str):
+        if '\n' in obj or obj.lstrip().startswith('<'):
+            return False
+        try:
+            return not is_local_scheme(urlsplit(obj.strip()).scheme)
+        except ValueError:
+            return False
 
-def is_local_url(url):
-    if not is_url(url):
+    elif isinstance(obj, bytes):
+        if b'\n' in obj or obj.lstrip().startswith(b'<'):
+            return False
+        try:
+            return not is_local_scheme(urlsplit(obj.strip().decode('utf-8')).scheme)
+        except ValueError:
+            return False
+    else:
         return False
-    scheme = urlsplit(normalize_url(url)).scheme
-    return scheme in ('', 'file') or len(scheme) == 1 and scheme in ascii_letters
 
 
-def url_path_is_file(url):
+def is_local_url(obj: object) -> bool:
+    if isinstance(obj, str):
+        if '\n' in obj or obj.lstrip().startswith('<'):
+            return False
+        try:
+            return is_local_scheme(urlsplit(obj.strip()).scheme)
+        except ValueError:
+            return False
+
+    elif isinstance(obj, bytes):
+        if b'\n' in obj or obj.lstrip().startswith(b'<'):
+            return False
+        try:
+            return is_local_scheme(urlsplit(obj.strip().decode('utf-8')).scheme)
+        except ValueError:
+            return False
+    else:
+        return isinstance(obj, Path)
+
+
+def url_path_is_file(url: str) -> bool:
     if not is_local_url(url):
         return False
-    return os.path.isfile(url) or os.path.isfile(urlsplit(normalize_url(url)).path)
+    if os.path.isfile(url):
+        return True
+    path = unquote(urlsplit(normalize_url(url)).path)
+    if path.startswith('/') and platform.system() == 'Windows':
+        path = path1:
+    return os.path.isfile(path)
 
 
 ###
 # API for XML resources
 
-def normalize_locations(locations, base_url=None, keep_relative=False):
+def normalize_locations(locations: LocationsType,
+                        base_url: Optionalstr = None,
+                        keep_relative: bool = False) -> NormalizedLocationsType:
     """
     Returns a list of normalized locations. The locations are normalized using
     the base URL of the instance.
@@ -217,7 +308,7 @@
     :return: a list of couples containing normalized namespace location hints.
     """
     normalized_locations = 
-    try:
+    if isinstance(locations, dict):
         for ns, value in locations.items():
             if isinstance(value, list):
                 normalized_locations.extend(
@@ -225,14 +316,14 @@
                 )
             else:
                 normalized_locations.append((ns, normalize_url(value, base_url, keep_relative)))
-    except AttributeError:
+    else:
         normalized_locations.extend(
             (ns, normalize_url(url, base_url, keep_relative)) for ns, url in locations
         )
     return normalized_locations
 
 
-def fetch_resource(location, base_url=None, timeout=30):
+def fetch_resource(location: str, base_url: Optionalstr = None, timeout: int = 30) -> str:
     """
     Fetch a resource by trying to access it. If the resource is accessible
     returns its URL, otherwise raises an :class:`XMLResourceError`.
@@ -262,8 +353,12 @@
             raise XMLResourceError("cannot access to resource %r: %s" % (url, err.reason))
 
 
-def fetch_schema_locations(source, locations=None, base_url=None,
-                           allow='all', defuse='remote', timeout=30):
+def fetch_schema_locations(source: Union'XMLResource', XMLSourceType,
+                           locations: OptionalLocationsType = None,
+                           base_url: Optionalstr = None,
+                           allow: str = 'all',
+                           defuse: str = 'remote',
+                           timeout: int = 30) -> Tuplestr, NormalizedLocationsType:
     """
     Fetches schema location hints from an XML data source and a list of location hints.
     If an accessible schema location is not found raises a ValueError.
@@ -301,7 +396,12 @@
     raise XMLSchemaValueError("not found a schema for XML data resource {!r}.".format(source))
 
 
-def fetch_schema(source, locations=None, base_url=None, allow='all', defuse='remote', timeout=30):
+def fetch_schema(source: Union'XMLResource', XMLSourceType,
+                 locations: OptionalLocationsType = None,
+                 base_url: Optionalstr = None,
+                 allow: str = 'all',
+                 defuse: str = 'remote',
+                 timeout: int = 30) -> str:
     """
     Like :meth:`fetch_schema_locations` but returns only a reachable
     location hint for a schema related to the source's namespace.
@@ -309,7 +409,11 @@
     return fetch_schema_locations(source, locations, base_url, allow, defuse, timeout)0
 
 
-def fetch_namespaces(source, base_url=None, allow='all', defuse='remote', timeout=30):
+def fetch_namespaces(source: XMLSourceType,
+                     base_url: Optionalstr = None,
+                     allow: str = 'all',
+                     defuse: str = 'remote',
+                     timeout: int = 30) -> NamespacesType:
     """
     Fetches namespaces information from the XML data source. The argument *source*
     can be a string containing the XML document or file path or an url or a file-like
@@ -344,22 +448,41 @@
     iterated (`True` means 1).
     """
     # Protected attributes for data and resource location
-    _source = _root = _text = _url = _nsmap = _parent_map = None
-    _lazy = False
-
-    def __init__(self, source, base_url=None, allow='all',
-                 defuse='remote', timeout=300, lazy=False):
-
-        if base_url is not None and not isinstance(base_url, str):
-            msg = "invalid type {!r} for the attribute 'base_url'"
+    _source: XMLSourceType
+    _root: ElementType
+    _nsmap: DictElementType, ListTuplestr, str
+    _text: Optionalstr = None
+    _url: Optionalstr = None
+    _base_url: Optionalstr = None
+    _parent_map: OptionalParentMapType = None
+    _lazy: Unionbool, int = False
+
+    def __init__(self, source: XMLSourceType,
+                 base_url: UnionNone, str, Path, bytes = None,
+                 allow: str = 'all',
+                 defuse: str = 'remote',
+                 timeout: int = 300,
+                 lazy: Unionbool, int = False) -> None:
+
+        if isinstance(base_url, str):
+            if not is_url(base_url):
+                raise XMLSchemaValueError("'base_url' argument is not an URL")
+            self._base_url = base_url
+        elif isinstance(base_url, Path):
+            self._base_url = str(base_url)
+        elif isinstance(base_url, bytes):
+            if not is_url(base_url):
+                raise XMLSchemaValueError("'base_url' argument is not an URL")
+            self._base_url = base_url.decode()
+        elif base_url is not None:
+            msg = "invalid type {!r} for argument 'base_url'"
             raise XMLSchemaTypeError(msg.format(type(base_url)))
-        self._base_url = base_url
 
         if not isinstance(allow, str):
-            msg = "invalid type {!r} for the attribute 'allow'"
+            msg = "invalid type {!r} for argument 'allow'"
             raise XMLSchemaTypeError(msg.format(type(allow)))
         elif allow not in SECURITY_MODES:
-            msg = "'allow' attribute: {!r} is not a security mode"
+            msg = "'allow' argument: {!r} is not a security mode"
             raise XMLSchemaValueError(msg.format(allow))
         elif allow == 'sandbox' and self._base_url is None:
             msg = "block access to files out of sandbox requires 'base_url' to be set"
@@ -367,69 +490,87 @@
         self._allow = allow
 
         if not isinstance(defuse, str):
-            msg = "invalid type {!r} for the attribute 'defuse'"
+            msg = "invalid type {!r} for argument 'defuse'"
             raise XMLSchemaTypeError(msg.format(type(defuse)))
         elif defuse not in DEFUSE_MODES:
-            msg = "'defuse' attribute: {!r} is not a defuse mode"
+            msg = "'defuse' argument: {!r} is not a defuse mode"
             raise XMLSchemaValueError(msg.format(defuse))
         self._defuse = defuse
 
         if not isinstance(timeout, int):
-            msg = "invalid type {!r} for the attribute 'timeout'"
+            msg = "invalid type {!r} for argument 'timeout'"
             raise XMLSchemaTypeError(msg.format(type(timeout)))
         elif timeout <= 0:
-            msg = "the attribute 'timeout' must be a positive integer"
+            msg = "the argument 'timeout' must be a positive integer"
             raise XMLSchemaValueError(msg)
         self._timeout = timeout
 
         self.parse(source, lazy)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return '%s(root=%r)' % (self.__class__.__name__, self._root)
 
     @property
-    def source(self):
+    def source(self) -> XMLSourceType:
         """The XML data source."""
         return self._source
 
     @property
-    def root(self):
+    def root(self) -> ElementType:
         """The XML tree root Element."""
         return self._root
 
     @property
-    def text(self):
+    def text(self) -> Optionalstr:
         """The XML text source, `None` if it's not available."""
         return self._text
 
     @property
-    def url(self):
+    def name(self) -> Optionalstr:
+        """
+        The source name, is `None` if the instance is created from an Element or a string.
+        """
+        return None if self._url is None else os.path.basename(self._url)
+
+    @property
+    def url(self) -> Optionalstr:
         """
-        The source URL, `None` if the instance is created from an Element tree or from a string.
+        The source URL, `None` if the instance is created from an Element or a string.
         """
         return self._url
 
     @property
-    def base_url(self):
+    def base_url(self) -> Optionalstr:
         """The effective base URL used for completing relative locations."""
         return os.path.dirname(self._url) if self._url else self._base_url
 
     @property
-    def allow(self):
+    def filepath(self) -> Optionalstr:
+        """
+        The resource filepath if the instance is created from a local file, `None` otherwise.
+        """
+        if self._url:
+            url_parts = urlsplit(self._url)
+            if url_parts.scheme in ('', 'file'):
+                return url_parts.path
+        return None
+
+    @property
+    def allow(self) -> str:
         """The security mode for accessing resource locations."""
         return self._allow
 
     @property
-    def defuse(self):
+    def defuse(self) -> str:
         """When to defuse XML data."""
         return self._defuse
 
     @property
-    def timeout(self):
+    def timeout(self) -> int:
         """The timeout in seconds for accessing remote resources."""
         return self._timeout
 
-    def _access_control(self, url):
+    def _access_control(self, url: str) -> None:
         if self._allow == 'all':
             return
         elif self._allow == 'remote':
@@ -437,11 +578,11 @@
                 raise XMLResourceError("block access to local resource {}".format(url))
         elif is_remote_url(url):
             raise XMLResourceError("block access to remote resource {}".format(url))
-        elif self._allow == 'sandbox':
+        elif self._allow == 'sandbox' and self._base_url is not None:
             if not url.startswith(normalize_url(self._base_url)):
                 raise XMLResourceError("block access to out of sandbox file {}".format(url))
 
-    def _update_nsmap(self, nsmap, prefix, uri):
+    def _update_nsmap(self, nsmap: MutableMappingstr, str, prefix: str, uri: str) -> None:
         if not prefix:
             if not uri:
                 return
@@ -464,10 +605,14 @@
                 prefix += '0'
         nsmapprefix = uri
 
-    def _lazy_iterparse(self, source, nsmap=None):
+    def _lazy_iterparse(self, resource: IOAnyStr, nsmap: OptionalNsmapType = None) \
+            -> IteratorTuplestr, ElementType:
+        events: Tuplestr, ...
+        _nsmap: ListTuplestr, str
+
         if nsmap is None:
             events = 'start', 'end'
-            _nsmap = None
+            _nsmap = 
         else:
             events = 'start-ns', 'end-ns', 'start', 'end'
             if isinstance(nsmap, list):
@@ -479,13 +624,14 @@
         if self._defuse == 'remote' and is_remote_url(self.base_url) \
                 or self._defuse == 'always':
             safe_parser = SafeXMLParser(target=PyElementTree.TreeBuilder())
-            tree_iterator = PyElementTree.iterparse(source, events, safe_parser)
+            tree_iterator = PyElementTree.iterparse(resource, events, safe_parser)
         else:
-            tree_iterator = ElementTree.iterparse(source, events)
+            tree_iterator = ElementTree.iterparse(resource, events)
 
         root_started = False
         nsmap_update = False
-        _root = self._root
+
+        _root = cast(OptionalElementType, getattr(self, '_root', None))
 
         try:
             for event, node in tree_iterator:
@@ -493,7 +639,7 @@
                     if not root_started:
                         self._root = node
                         root_started = True
-                    if nsmap_update:
+                    if nsmap_update and isinstance(nsmap, dict):
                         for prefix, uri in _nsmap:
                             self._update_nsmap(nsmap, prefix, uri)
                         nsmap_update = False
@@ -501,26 +647,30 @@
 
                 elif event == 'end':
                     yield event, node
-                else:
+                elif nsmap is not None:
                     if event == 'start-ns':
                         _nsmap.append(node)
                     else:
                         _nsmap.pop()
-                    nsmap_update = nsmap is not _nsmap
+                    nsmap_update = isinstance(nsmap, dict)
 
         except Exception as err:
-            self._root = _root
+            if _root is not None:
+                self._root = _root
             if isinstance(err, PyElementTree.ParseError):
                 raise ElementTree.ParseError(str(err)) from None
             raise
 
-    def _parse(self, resource):
+    def _parse(self, resource: IOAnyStr) -> None:
         if self._defuse == 'remote' and is_remote_url(self.base_url) \
                 or self._defuse == 'always':
 
             if not hasattr(resource, 'seekable') or not resource.seekable():
                 text = resource.read()
-                resource = StringIO(text) if isinstance(text, str) else BytesIO(text)
+                if isinstance(text, str):
+                    resource = StringIO(text)
+                else:
+                    resource = BytesIO(text)
 
             safe_parser = SafeXMLParser(target=PyElementTree.TreeBuilder())
             try:
@@ -531,11 +681,12 @@
             else:
                 resource.seek(0)
 
-        elem = None
-        nsmap = 
+        elem: OptionalElementType = None
+        nsmap: ListTuplestr, str = 
         nsmap_changed = False
         namespaces = {}
         events = 'start-ns', 'end-ns', 'end'
+
         for event, node in ElementTree.iterparse(resource, events):
             if event == 'end':
                 if nsmap_changed or elem is None:
@@ -551,10 +702,27 @@
                 nsmap.pop()
                 nsmap_changed = True
 
+        assert elem is not None
         self._root = elem
         self._nsmap = namespaces
 
-    def parse(self, source, lazy=False):
+    def _parse_resource(self, resource: IOAnyStr,
+                        url: Optionalstr,
+                        lazy: Unionbool, int) -> None:
+        _url, self._url = self._url, url
+        try:
+            if not lazy:
+                self._parse(resource)
+            else:
+                nsmap: ListTuplestr, str = 
+                for _, root in self._lazy_iterparse(resource, nsmap):  # pragma: no cover
+                    self._nsmap = {root: nsmap}
+                    break
+        except Exception:
+            self._url = _url
+            raise
+
+    def parse(self, source: XMLSourceType, lazy: Unionbool, int = False) -> None:
         if isinstance(lazy, bool):
             pass
         elif not isinstance(lazy, int):
@@ -564,92 +732,79 @@
             msg = "invalid value {!r} for the attribute 'lazy'"
             raise XMLSchemaValueError(msg.format(lazy))
 
-        if is_url(source):
-            # source is a string containing an URL or a file path
-            url = normalize_url(source)
-            self._access_control(url)
+        url: Optionalstr
+        if isinstance(source, str):
+            if is_url(source):
+                # source is a string containing an URL or a file path
+                url = normalize_url(source, self._base_url)
+                self._access_control(url)
 
-            _url, self._url = self._url, url
-            try:
                 with urlopen(url, timeout=self._timeout) as resource:
-                    if not lazy:
-                        self._parse(resource)
-                    else:
-                        for _ in self._lazy_iterparse(resource):  # pragma: no cover
-                            break
-            except Exception:
-                self._url = _url
-                raise
+                    self._parse_resource(resource, url, lazy)
+
+                self._text = None
+                self._lazy = lazy
             else:
+                # source is a string containing an XML document
+                resource = StringIO(source)
+                self._parse_resource(resource, None, lazy)
+                self._text = source
+                self._lazy = False
+
+        elif isinstance(source, bytes):
+            if is_url(source):
+                url = normalize_url(source.decode(), self._base_url)
+                self._access_control(url)
+
+                with urlopen(url, timeout=self._timeout) as resource:
+                    self._parse_resource(resource, url, lazy)
+
                 self._text = None
                 self._lazy = lazy
 
-        elif isinstance(source, str):
-            # source is a string containing an XML document
-            _url, self._url = self._url, None
-            resource = StringIO(source)
-            try:
-                if not lazy:
-                    self._parse(resource)
-                else:
-                    for _ in self._lazy_iterparse(resource):  # pragma: no cover
-                        break
-            except Exception:
-                self._url = _url
-                raise
             else:
-                self._text = source
+                resource = BytesIO(source)
+                self._parse_resource(resource, None, lazy)
+                self._text = source.decode()
                 self._lazy = False
 
+        elif isinstance(source, Path):
+            url = normalize_url(str(source), self._base_url)
+            self._access_control(url)
+
+            with urlopen(url, timeout=self._timeout) as resource:
+                self._parse_resource(resource, url, lazy)
+
+            self._text = None
+            self._lazy = lazy
+
         elif isinstance(source, StringIO):
-            _url, self._url = self._url, None
-            try:
-                if not lazy:
-                    self._parse(source)
-                else:
-                    for _ in self._lazy_iterparse(source):  # pragma: no cover
-                        break
-            except Exception:
-                self._url = _url
-                raise
-            else:
-                self._text = source.getvalue()
-                self._lazy = lazy
+            self._parse_resource(source, None, lazy)
+            self._text = source.getvalue()
+            self._lazy = lazy
 
         elif hasattr(source, 'read'):
             # source is a readable resource (remote or local file)
-            try:
+            url = getattr(source, 'url', None)
+            if url is not None:
                 # Save remote urls for open new resources (non seekable)
-                if is_remote_url(source.url):
-                    url = source.url
+                if is_remote_url(url):
                     self._access_control(url)
                 else:
                     url = None
-            except AttributeError:
-                url = None
 
-            _url, self._url = self._url, url
-            try:
-                if not lazy:
-                    self._parse(source)
-                else:
-                    for _ in self._lazy_iterparse(source):  # pragma: no cover
-                        break
-            except Exception:
-                self._url = _url
-                raise
-            else:
-                self._text = None
-                self._lazy = lazy
+            self._parse_resource(cast(IOstr, source), url, lazy)
+            self._text = None
+            self._lazy = lazy
 
         else:
             # Source is already an Element or an ElementTree.
             if hasattr(source, 'tag') and hasattr(source, 'attrib'):
                 # Source is already an Element --> nothing to parse
-                self._root = source
+                self._root = cast(ElementType, source)
             elif is_etree_document(source):
                 # Could be only an ElementTree object at last
-                self._root = source.getroot()
+                self._root = cast(ElementTreeType, source).getroot()
             else:
                 raise XMLSchemaTypeError(
                     "wrong type %r for 'source' attribute: an ElementTree object or "
@@ -659,13 +814,13 @@
 
             self._text = self._url = None
             self._lazy = False
-            if not hasattr(self._root, 'nsmap'):
-                self._nsmap = None
-            else:
-                self._nsmap = {}
+            self._nsmap = {}
 
-                nsmap = lxml_nsmap = None
-                for elem in self._root.iter():
+            # TODO for Python 3.8+: need a Protocol for checking this with isinstance()
+            if hasattr(self._root, 'nsmap'):
+                nsmap = 
+                lxml_nsmap = None
+                for elem in cast(Any, self._root.iter()):
                     if lxml_nsmap != elem.nsmap:
                         lxml_nsmap = elem.nsmap
                         nsmap = (k or '', v) for k, v in elem.nsmap.items()
@@ -675,20 +830,32 @@
         self._source = source
 
     @property
-    def namespace(self):
+    def namespace(self) -> str:
         """The namespace of the XML resource."""
-        return get_namespace(self._root.tag)
+        return '' if self._root is None else get_namespace(self._root.tag)
 
     @property
-    def parent_map(self):
+    def parent_map(self) -> DictElementType, OptionalElementType:
         if self._lazy:
             raise XMLResourceError("cannot create the parent map of a lazy resource")
         if self._parent_map is None:
+            assert self._root is not None
             self._parent_map = {child: elem for elem in self._root.iter() for child in elem}
             self._parent_mapself._root = None
         return self._parent_map
 
-    def get_absolute_path(self, path=None):
+    def get_nsmap(self, elem: ElementType) -> ListTuplestr, str:
+        """
+        Returns a list of couples with the namespace (nsmap) map of the element.
+        Lazy resources have only a nsmap for the root element. If no nsmap is
+        found for the element returns an empty list.
+        """
+        try:
+            return self._nsmapelem
+        except KeyError:
+            return 
+
+    def get_absolute_path(self, path: Optionalstr = None) -> str:
         if path is None:
             if self._lazy:
                 return '/%s/%s' % (self._root.tag, '/'.join('*' * int(self._lazy)))
@@ -698,7 +865,7 @@
         else:
             return '/%s/%s' % (self._root.tag, path)
 
-    def get_text(self):
+    def get_text(self) -> str:
         """
         Gets the source text of the XML document. If the source text is not
         available creates an encoded string representation of the XML tree.
@@ -708,20 +875,25 @@
             return self._text
         elif self._url is not None:
             self.load()
-            return self._text
-        else:
-            return self.tostring(xml_declaration=True)
+            if self._text is not None:
+                return self._text
+
+        return self.tostring(xml_declaration=True)
 
-    def tostring(self, indent='', max_lines=None, spaces_for_tab=4, xml_declaration=False):
+    def tostring(self, indent: str = '', max_lines: Optionalint = None,
+                 spaces_for_tab: int = 4, xml_declaration: bool = False) -> str:
         """Generates a string representation of the XML resource."""
         if self._lazy:
             raise XMLResourceError("cannot serialize a lazy resource")
 
         elem = self._root
         namespaces = self.get_namespaces(root_only=False)
-        return etree_tostring(elem, namespaces, indent, max_lines, spaces_for_tab, xml_declaration)
+        _string = etree_tostring(elem, namespaces, indent, max_lines,
+                                 spaces_for_tab, xml_declaration)
 
-    def subresource(self, elem):
+        return _string.decode('utf-8') if isinstance(_string, bytes) else _string
+
+    def subresource(self, elem: ElementType) -> 'XMLResource':
         """Create an XMLResource instance from a subelement of a non-lazy XML tree."""
         if self._lazy:
             raise XMLResourceError("cannot create a subresource from a lazy resource")
@@ -733,8 +905,8 @@
             msg = "{!r} is not an element or the XML resource tree"
             raise XMLResourceError(msg.format(elem))
 
-        resource = XMLResource(elem, self._base_url, self._allow, self._defuse, self._timeout)
-        if not hasattr(elem, 'nsmap'):
+        resource = XMLResource(elem, self.base_url, self._allow, self._defuse, self._timeout)
+        if not hasattr(elem, 'nsmap') and self._nsmap is not None:
             namespaces = {}
             _nsmap = self._nsmapelem
             _nsmap_initial_len = len(_nsmap)
@@ -751,53 +923,53 @@
 
         return resource
 
-    def open(self):
+    def open(self) -> IOAnyStr:
         """
         Returns a opened resource reader object for the instance URL. If the
         source attribute is a seekable file-like object rewind the source and
         return it.
         """
         if self.seek(0) == 0:
-            return self._source
+            return cast(IOAnyStr, self._source)
         elif self._url is None:
             raise XMLResourceError("can't open, the resource has no URL associated.")
 
         try:
-            return urlopen(self._url, timeout=self._timeout)
+            return cast(IOAnyStr, urlopen(self._url, timeout=self._timeout))
         except URLError as err:
             raise XMLResourceError(
                 "cannot access to resource %r: %s" % (self._url, err.reason)
             )
 
-    def seek(self, position):
+    def seek(self, position: int) -> Optionalint:
         """
         Change stream position if the XML resource was created with a seekable
         file-like object. In the other cases this method has no effect.
         """
         if not hasattr(self._source, 'read'):
-            return
+            return None
 
         try:
-            if not self._source.seekable():
-                return
+            if not self._source.seekable():  # type: ignoreunion-attr
+                return None
         except AttributeError:
-            pass  # pragma: no cover
+            return None  # pragma: no cover
         except ValueError as err:
             raise XMLResourceError(str(err)) from None
         else:
-            return self._source.seek(position)
+            return self._source.seek(position)  # type: ignoreunion-attr
 
-    def close(self):
+    def close(self) -> None:
         """
         Close the XML resource if it's created with a file-like object.
         In other cases this method has no effect.
         """
         try:
-            self._source.close()
+            self._source.close()  # type: ignoreunion-attr
         except (AttributeError, TypeError):
             pass
 
-    def load(self):
+    def load(self) -> None:
         """
         Loads the XML text from the data source. If the data source is an Element
         the source XML text can't be retrieved.
@@ -827,31 +999,32 @@
 
         self._text = text
 
-    def is_lazy(self):
+    def is_lazy(self) -> bool:
         """Returns `True` if the XML resource is lazy."""
         return bool(self._lazy)
 
-    def is_remote(self):
+    def is_remote(self) -> bool:
         """Returns `True` if the resource is related with remote XML data."""
         return is_remote_url(self._url)
 
-    def is_local(self):
+    def is_local(self) -> bool:
         """Returns `True` if the resource is related with local XML data."""
         return is_local_url(self._url)
 
     @property
-    def lazy_depth(self):
+    def lazy_depth(self) -> int:
         """
         The optimal depth for validate this resource. Is a positive
         integer for lazy resources and 0 for fully loaded XML trees.
         """
         return int(self._lazy)
 
-    def is_loaded(self):
+    def is_loaded(self) -> bool:
         """Returns `True` if the XML text of the data source is loaded."""
         return self._text is not None
 
-    def iter(self, tag=None, nsmap=None):
+    def iter(self, tag: Optionalstr = None, nsmap: OptionalNsmapType = None) \
+            -> IteratorElementType:
         """
         XML resource tree iterator. The iteration of a lazy resource
         is in reverse order (top level element is the last). If tag
@@ -894,7 +1067,7 @@
 
                 yield elem
 
-    def iter_location_hints(self, tag=None):
+    def iter_location_hints(self, tag: Optionalstr = None) -> IteratorTuplestr, str:
         """
         Yields all schema location hints of the XML resource. If tag
         is not None or '*', only location hints of elements whose tag
@@ -903,7 +1076,8 @@
         for elem in self.iter(tag):
             yield from etree_iter_location_hints(elem)
 
-    def iter_depth(self, mode=1, nsmap=None, ancestors=None):
+    def iter_depth(self, mode: int = 1, nsmap: OptionalNsmapType = None,
+                   ancestors: OptionalListElementType = None) -> IteratorElementType:
         """
         Iterates XML subtrees. For fully loaded resources yields the root element.
         On lazy resources the argument *mode* can change the sequence and the
@@ -969,7 +1143,10 @@
             if self._source is not resource:
                 resource.close()
 
-    def iterfind(self, path, namespaces=None, nsmap=None, ancestors=None):
+    def iterfind(self, path: str,
+                 namespaces: OptionalNamespacesType = None,
+                 nsmap: OptionalNsmapType = None,
+                 ancestors: OptionalListElementType = None) -> IteratorElementType:
         """
         Apply XPath selection to XML resource that yields full subtrees.
 
@@ -981,6 +1158,8 @@
         the tracking is on the whole tree, renaming prefixes in case of conflicts.
         :param ancestors: provide a list for tracking the ancestors of yielded elements.
         """
+        selector: Any
+
         if self._lazy:
             selector = LazySelector(path, namespaces)
             path = path.replace(' ', '').replace('./', '')
@@ -1029,7 +1208,8 @@
                 parent_map = self.parent_map
                 ancestors.clear()
 
-                def selector(*args, **kwargs):
+                def selector(*args: Any, **kwargs: Any) -> IteratorAny:
+                    assert ancestors is not None
                     for e in iter_select(*args, **kwargs):
                         if e is self._root:
                             ancestors.clear()
@@ -1069,13 +1249,18 @@
 
                     yield elem
 
-    def find(self, path, namespaces=None, nsmap=None, ancestors=None):
+    def find(self, path: str,
+             namespaces: OptionalNamespacesType = None,
+             nsmap: OptionalNsmapType = None,
+             ancestors: OptionalListElementType = None) -> OptionalElementType:
         return next(self.iterfind(path, namespaces, nsmap, ancestors), None)
 
-    def findall(self, path, namespaces=None):
+    def findall(self, path: str, namespaces: OptionalNamespacesType = None) \
+            -> ListElementType:
         return list(self.iterfind(path, namespaces))
 
-    def get_namespaces(self, namespaces=None, root_only=None):
+    def get_namespaces(self, namespaces: OptionalNamespacesType = None,
+                       root_only: Optionalbool = None) -> NamespacesType:
         """
         Extracts namespaces with related prefixes from the XML resource. If a duplicate
         prefix declaration is encountered and the prefix maps a different namespace,
@@ -1088,27 +1273,28 @@
         only the namespaces declared in the root element.
         :return: a dictionary for mapping namespace prefixes to full URI.
         """
-        if root_only is None:
-            root_only = bool(self._lazy)
-
         if namespaces is None:
             namespaces = {}
         elif namespaces.get('xml', XML_NAMESPACE) != XML_NAMESPACE:
             msg = "reserved prefix (xml) must not be bound to another namespace name"
             raise XMLSchemaValueError(msg)
         else:
-            namespaces = namespaces.copy()
+            namespaces = copy.copy(namespaces)
 
         try:
-            for _ in self.iter(nsmap=namespaces):
-                if root_only:
+            if root_only or root_only is None and self._lazy:
+                for _ in self.iter(nsmap=namespaces):
                     break
+            else:
+                for _ in self.iter(nsmap=namespaces):
+                    pass
         except (ElementTree.ParseError, PyElementTree.ParseError, UnicodeEncodeError):
             pass
 
         return namespaces
 
-    def get_locations(self, locations=None, root_only=None):
+    def get_locations(self, locations: OptionalLocationsType = None,
+                      root_only: Optionalbool = None) -> NormalizedLocationsType:
         """
         Extracts a list of schema location hints from the XML resource.
         The locations are normalized using the base URL of the instance.
@@ -1121,7 +1307,7 @@
         :returns: a list of couples containing normalized location hints.
         """
         if root_only is None:
-            root_only = self._lazy
+            root_only = bool(self._lazy)
 
         if not locations:
             location_hints =

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/testing/builders.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/testing/builders.py Changed

@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 #
 # Copyright (c), 2016-2020, SISSA (International School for Advanced Studies).
 # All rights reserved.
@@ -10,15 +9,20 @@
 #
 import pdb
 import os
+import ast
 import pickle
 import time
 import logging
+import importlib
+import tempfile
 import warnings
+from typing import Optional, Type
 
 try:
     import lxml.etree as lxml_etree
 except ImportError:
-    lxml_etree = lxml_etree_element = None
+    lxml_etree = None  # type: ignoreassignment
+    lxml_etree_element = None
 else:
     lxml_etree_element = lxml_etree.Element
 
@@ -26,11 +30,19 @@
 from xmlschema import XMLSchemaBase, XMLSchema11, XMLSchemaValidationError, \
     XMLSchemaParseError, UnorderedConverter, ParkerConverter, BadgerFishConverter, \
     AbderaConverter, JsonMLConverter, ColumnarConverter
+from xmlschema.names import XSD_IMPORT
+from xmlschema.helpers import local_name
 from xmlschema.etree import etree_tostring, ElementTree, \
     py_etree_element
 from xmlschema.resources import fetch_namespaces
 from xmlschema.xpath import XMLSchemaContext
 from xmlschema.validators import XsdValidator, XsdType, Xsd11ComplexType
+from xmlschema.dataobjects import DataElementConverter, DataBindingConverter, DataElement
+
+try:
+    from xmlschema.extras.codegen import PythonGenerator
+except ImportError:
+    PythonGenerator: OptionalType = None  # type: ignoreno-redef
 
 from .helpers import iter_nested_items, etree_elements_assert_equal
 from .case_class import XsdValidatorTestCase
@@ -56,7 +68,9 @@
     inspect = test_args.inspect
     locations = test_args.locations
     defuse = test_args.defuse
+    no_pickle = test_args.no_pickle
     debug_mode = test_args.debug
+    codegen = test_args.codegen
     loglevel = logging.DEBUG if debug_mode else None
 
     class TestSchema(XsdValidatorTestCase):
@@ -73,30 +87,31 @@
 
         def check_xsd_file(self):
             if expected_errors > 0:
-                xs = schema_class(xsd_file, validation='lax', locations=locations,
-                                  defuse=defuse, loglevel=loglevel)
+                schema = schema_class(xsd_file, validation='lax', locations=locations,
+                                      defuse=defuse, loglevel=loglevel)
             else:
-                xs = schema_class(xsd_file, locations=locations, defuse=defuse, loglevel=loglevel)
-            self.errors.extend(xs.maps.all_errors)
+                schema = schema_class(xsd_file, locations=locations,
+                                      defuse=defuse, loglevel=loglevel)
+            self.errors.extend(schema.maps.all_errors)
 
             if inspect:
-                components_ids = set(id(c) for c in xs.maps.iter_components())
-                components_ids.update(id(c) for c in xs.meta_schema.iter_components())
+                components_ids = set(id(c) for c in schema.maps.iter_components())
+                components_ids.update(id(c) for c in schema.meta_schema.iter_components())
                 missing = 
                     c for c in SchemaObserver.components if id(c) not in components_ids
                 
                 if missing:
                     raise ValueError("schema missing %d components: %r" % (len(missing), missing))
 
-            # Pickling test (only for Python 3, skip inspected schema classes test)
-            if not inspect:
+            # Pickling test (skip inspected schema classes test)
+            if not inspect and not no_pickle:
                 try:
-                    obj = pickle.dumps(xs)
+                    obj = pickle.dumps(schema)
                     deserialized_schema = pickle.loads(obj)
                 except pickle.PicklingError:
                     # Don't raise if some schema parts (eg. a schema loaded from remote)
                     # are built with the SafeXMLParser that uses pure Python elements.
-                    for e in xs.maps.iter_components():
+                    for e in schema.maps.iter_components():
                         elem = getattr(e, 'elem', getattr(e, 'root', None))
                         if isinstance(elem, py_etree_element):
                             break
@@ -104,12 +119,12 @@
                         raise
                 else:
                     self.assertTrue(isinstance(deserialized_schema, XMLSchemaBase), msg=xsd_file)
-                    self.assertEqual(xs.built, deserialized_schema.built, msg=xsd_file)
+                    self.assertEqual(schema.built, deserialized_schema.built, msg=xsd_file)
 
             # XPath API tests
             if not inspect and not self.errors:
-                context = XMLSchemaContext(xs)
-                elements = x for x in xs.iter()  # Contains schema elements only
+                context = XMLSchemaContext(schema)
+                elements = x for x in schema.iter()  # Contains schema elements only
                 xpath_context_elements = x for x in context.iter() if isinstance(x, XsdValidator)
                 descendants = x for x in context.iter_descendants('descendant-or-self')
                 self.assertTrue(x in descendants for x in xpath_context_elements)
@@ -118,7 +133,7 @@
                     self.assertIn(e, xpath_context_elements, msg=xsd_file)
 
             # Checks on XSD types
-            for xsd_type in xs.maps.iter_components(xsd_classes=XsdType):
+            for xsd_type in schema.maps.iter_components(xsd_classes=XsdType):
                 self.assertIn(
                     xsd_type.content_type_label, {'empty', 'simple', 'element-only', 'mixed'},
                     msg=xsd_file
@@ -133,13 +148,31 @@
                             "is simple or has a simple content" not in str(err):
                         raise  # Not a case of forbidden complex content extension
 
-                    xs = schema_class(xsd_file, validation='lax', locations=locations,
-                                      defuse=defuse, loglevel=loglevel)
-                    for error in xs.all_errors:
+                    schema = schema_class(xsd_file, validation='lax', locations=locations,
+                                          defuse=defuse, loglevel=loglevel)
+                    for error in schema.all_errors:
                         if not isinstance(err.validator, Xsd11ComplexType) or \
                                 "is simple or has a simple content" not in str(err):
                             raise error
 
+            # Check XML bindings module only for schemas that do not have errors
+            if codegen and PythonGenerator is not None and not self.errors and \
+                    all('schemaLocation' in e.attrib for e in schema.root if e.tag == XSD_IMPORT):
+
+                generator = PythonGenerator(schema)
+                with tempfile.TemporaryDirectory() as tempdir:
+                    cwd = os.getcwd()
+                    try:
+                        schema.export(tempdir, save_remote=True)
+                        os.chdir(tempdir)
+                        generator.render_to_files('bindings.py.jinja')
+
+                        spec = importlib.util.spec_from_file_location(tempdir, 'bindings.py')
+                        module = importlib.util.module_from_spec(spec)
+                        spec.loader.exec_module(module)
+                    finally:
+                        os.chdir(cwd)
+
         def check_xsd_file_with_lxml(self, xmlschema_time):
             start_time = time.time()
             lxs = lxml_etree.parse(xsd_file)
@@ -207,8 +240,11 @@
     inspect = test_args.inspect
     locations = test_args.locations
     defuse = test_args.defuse
+    validation_only = test_args.validation_only
+    no_pickle = test_args.no_pickle
     lax_encode = test_args.lax_encode
     debug_mode = test_args.debug
+    codegen = test_args.codegen
 
     class TestValidator(XsdValidatorTestCase):
 
@@ -271,9 +307,13 @@
                 # or if the XML case has defaults taken from the schema or some part of data
                 # decoding is skipped by schema wildcards (set the specific argument in testfiles).
                 if lax_encode:
-                    pass  # can't ensure encode equivalence if the test case use defaults
-                elif lossy:
-                    pass  # can't check encode equivalence if the converter is lossy
+                    # can't ensure encode equivalence on this case,
+                    # for example if the test case use defaults.
+                    pass
+                elif lossy or unordered:
+                    # can't check encode equivalence if the converter
+                    # is lossy or if it is not fully ordered.
+                    pass
                 elif losslessly:
                     if debug_mode:
                         pdb.set_trace()
@@ -422,6 +462,10 @@
             self.check_decode_encode(root, JsonMLConverter, **options)
             self.check_decode_encode(root, ColumnarConverter, validation='lax', **options)
 
+            self.check_decode_encode(root, DataElementConverter, **options)
+            self.check_decode_encode(root, DataBindingConverter, **options)
+            self.schema.maps.clear_bindings()
+
             self.check_json_serialization(root, cdata_prefix='#', **options)
             self.check_json_serialization(root, UnorderedConverter, **options)
             self.check_json_serialization(root, ParkerConverter, validation='lax', **options)
@@ -431,6 +475,21 @@
             self.check_json_serialization(root, JsonMLConverter, **options)
             self.check_json_serialization(root, ColumnarConverter, validation='lax', **options)
 
+            self.check_decode_to_objects(root)
+            self.check_decode_to_objects(root, with_bindings=True)
+            self.schema.maps.clear_bindings()
+
+        def check_decode_to_objects(self, root, with_bindings=False):
+            data_element = self.schema.to_objects(xml_file, with_bindings)
+            self.assertIsInstance(data_element, DataElement)
+            self.assertEqual(data_element.tag, root.tag)
+
+            if not with_bindings:
+                self.assertIs(data_element.__class__, DataElement)
+            else:
+                self.assertEqual(data_element.tag, root.tag)
+                self.assertTrue(data_element.__class__.__name__.endswith('Binding'))
+
         def check_data_conversion_with_lxml(self):
             xml_tree = lxml_etree.parse(xml_file)
             namespaces = fetch_namespaces(xml_file)
@@ -515,21 +574,67 @@
                 else:
                     self.assertTrue(schema.validate(xml_tree), msg=xml_file)
 
+        def check_validation_with_generated_code(self):
+            generator = PythonGenerator(self.schema)
+
+            python_module = generator.render('bindings.py.jinja')0
+            ast_module = ast.parse(python_module)
+            self.assertIsInstance(ast_module, ast.Module)
+
+            with tempfile.TemporaryDirectory() as tempdir:
+                module_name = '{}.py'.format(self.schema.name.rstrip('.xsd'))
+                cwd = os.getcwd()
+
+                try:
+                    self.schema.export(tempdir, save_remote=True)
+                    os.chdir(tempdir)
+                    with open(module_name, 'w') as fp:
+                        fp.write(python_module)
+
+                    spec = importlib.util.spec_from_file_location(tempdir, module_name)
+                    module = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(module)
+
+                    xml_root = ElementTree.parse(os.path.join(cwd, xml_file)).getroot()
+                    bindings = x for x in filter(lambda x: x.endswith('Binding'), dir(module))
+                    if len(bindings) == 1:
+                        class_name = bindings0
+                    else:
+                        class_name = '{}Binding'.format(
+                            local_name(xml_root.tag).title().replace('_', ''))
+
+                    binding_class = getattr(module, class_name)
+                    xml_data = binding_class.fromsource(os.path.join(cwd, xml_file))
+                    self.assertEqual(xml_data.tag, xml_root.tag)
+                finally:
+                    os.chdir(cwd)
+
         def test_xml_document_validation(self):
-            self.check_decoding_with_element_tree()
-            if not inspect:
-                self.check_schema_serialization()
+            if not validation_only:
+                self.check_decoding_with_element_tree()
+                if not inspect and not no_pickle:
+                    self.check_schema_serialization()
 
-            if not self.errors:
-                self.check_data_conversion_with_element_tree()
+                if not self.errors:
+                    self.check_data_conversion_with_element_tree()
 
-            if lxml_etree is not None:
-                self.check_data_conversion_with_lxml()
+                if lxml_etree is not None:
+                    self.check_data_conversion_with_lxml()
 
             self.check_iter_errors()
             self.check_validate_and_is_valid_api()
             if check_with_lxml and lxml_etree is not None:
                 self.check_lxml_validation()
 
+            # Test validation with XML data bindings only for instances and
+            # schemas that do not have errors and imports without locations
+            if not validation_only and codegen and PythonGenerator is not None and \
+                    not self.errors and not self.schema.all_errors and \
+                    all('schemaLocation' in e.attrib
+                        for e in self.schema.root
+                        if e.tag == XSD_IMPORT):
+
+                self.check_validation_with_generated_code()
+
     TestValidator.__name__ = TestValidator.__qualname__ = 'TestValidator{0:03}'.format(test_num)
     return TestValidator

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/testing/factory.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/testing/factory.py Changed

@@ -64,6 +64,8 @@
     # xmlschema's arguments
     parser.add_argument('--lxml', dest='lxml', action='store_true', default=False,
                         help='Check also with lxml.etree.XMLSchema (for XSD 1.0)')
+    parser.add_argument('--codegen', action="store_true", default=False,
+                        help="Test code generation with XML data bindings module.")
     parser.add_argument('testfiles', type=str, nargs='*', default=default_testfiles,
                         help="Test cases directory.")
     return parser
@@ -105,6 +107,14 @@
         help="Timeout for fetching resources (default=300)."
     )
     parser.add_argument(
+        '--validation-only', action="store_true", default=False,
+        help="Skip decode/encode tests on XML data."
+    )
+    parser.add_argument(
+        '--no-pickle', action="store_true", default=False,
+        help="Skip pickling/unpickling test on schema (max recursion exceeded)."
+    )
+    parser.add_argument(
         '--lax-encode', action="store_true", default=False,
         help="Use lax mode on encode checks (for cases where test data uses default or "
              "fixed values or some test data are skipped by wildcards processContents). "
@@ -114,18 +124,28 @@
         '--debug', action="store_true", default=False,
         help="Activate the debug mode (only the cases with --debug are executed).",
     )
+    parser.add_argument(
+        '--codegen', action="store_true", default=False,
+        help="Test code generation with XML data bindings module. For default "
+             "test code generation if the same command option is provided.",
+    )
     return parser
 
 
-def factory_tests(test_class_builder, testfiles, suffix, check_with_lxml=False):
+def factory_tests(test_class_builder, testfiles, suffix,
+                  check_with_lxml=False, codegen=False, verbosity=1):
     """
     Factory function for file based schema/validation cases.
 
     :param test_class_builder: the test class builder function.
     :param testfiles: a single or a list of testfiles indexes.
     :param suffix: the suffix ('xml' or 'xsd') to consider for cases.
-    :param check_with_lxml: if `True` compare with lxml XMLSchema class, reporting \
-    anomalies. Works only for XSD 1.0 tests.
+    :param check_with_lxml: if `True` compare with lxml XMLSchema class, \
+    reporting anomalies. Works only for XSD 1.0 tests.
+    :param codegen: if `True` is provided checks code generation with XML data \
+    bindings module for all tests. For default is `False` and code generation \
+    is tested only for the cases where the same option is provided.
+    :param verbosity: the unittest's verbosity, can be 0, 1 or 2.
     :return: a list of test classes.
     """
     test_classes = {}
@@ -156,6 +176,8 @@
         test_args = test_line_parser.parse_args(get_test_args(line))
         if test_args.locations is not None:
             test_args.locations = {k.strip('\'"'): v for k, v in test_args.locations}
+        if codegen:
+            test_args.codegen = True
 
         test_file = os.path.join(os.path.dirname(fileinput.filename()), test_args.filename)
         if os.path.isdir(test_file):
@@ -192,6 +214,9 @@
             )
 
         test_classestest_class.__name__ = test_class
+        if verbosity == 2:
+            print(f"Create case {test_class.__name__} for file {os.path.relpath(test_file)}")
+
         logger.debug("Add XSD %s test class %r.", test_args.version, test_class.__name__)
 
     if line_buffer:

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/testing/helpers.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/testing/helpers.py Changed

@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 #
 # Copyright (c), 2016-2020, SISSA (International School for Advanced Studies).
 # All rights reserved.
@@ -9,12 +8,16 @@
 # @author Davide Brunato <brunato@sissa.it>
 #
 import re
-from xmlschema.helpers import get_namespace, get_qname
+from typing import Any, Dict, List, Type, Union, Iterator
+from ..helpers import get_namespace, get_qname
+from ..etree import etree_element
 
 _REGEX_SPACES = re.compile(r'\s+')
 
 
-def iter_nested_items(items, dict_class=dict, list_class=list):
+def iter_nested_items(items: UnionDictAny, Any, ListAny,
+                      dict_class: TypeDictAny, Any = dict,
+                      list_class: TypeListAny = list) -> IteratorAny:
     """Iterates a nested object composed by lists and dictionaries."""
     if isinstance(items, dict_class):
         for k, v in items.items():
@@ -30,7 +33,9 @@
         yield items
 
 
-def etree_elements_assert_equal(elem, other, strict=True, skip_comments=True, unordered=False):
+def etree_elements_assert_equal(elem: etree_element, other: etree_element,
+                                strict: bool = True, skip_comments: bool = True,
+                                unordered: bool = False) -> None:
     """
     Tests the equality of two XML Element trees.
 
@@ -41,6 +46,8 @@
     :param unordered: children may have different order.
     :raise: an AssertionError containing information about first difference encountered.
     """
+    children: Unionetree_element, Listetree_element
+
     if unordered:
         children = sorted(elem, key=lambda x: '' if callable(x.tag) else x.tag)
         other_children = iter(sorted(
@@ -107,7 +114,7 @@
             if strict:
                 raise AssertionError(message)
             elif e1.text is None:
-                if e2.text.strip():
+                if e2.text is not None and e2.text.strip():
                     raise AssertionError(message)
             elif e2.text is None:
                 if e1.text.strip():
@@ -144,7 +151,7 @@
             if strict:
                 raise AssertionError(message)
             elif e1.tail is None:
-                if e2.tail.strip():
+                if e2.tail is not None and e2.tail.strip():
                     raise AssertionError(message)
             elif e2.tail is None:
                 if e1.tail.strip():

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/testing/observers.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/testing/observers.py Changed

@@ -11,18 +11,19 @@
 Observers for testing XMLSchema classes.
 """
 from functools import wraps
+from typing import List
 
 from xmlschema.names import XSD_NAMESPACE, XSD_ANY_TYPE
 from xmlschema.validators import XMLSchema10, XMLSchema11, \
-    XsdGroup, XsdAttributeGroup, XsdComplexType
+    XsdGroup, XsdAttributeGroup, XsdComplexType, XsdComponent
 
 
 class SchemaObserver:
     """
     Observer that registers created components. Run the 'clear' method after each usage.
     """
-    components = 
-    dummy_components = 
+    components: ListXsdComponent = 
+    dummy_components: ListXsdComponent = 
 
     @classmethod
     def observed_builder(cls, builder):
@@ -70,15 +71,38 @@
         return False
 
 
+observed_builder = SchemaObserver.observed_builder
+
+
 class ObservedXMLSchema10(XMLSchema10):
-    BUILDERS = {
-        k: SchemaObserver.observed_builder(getattr(XMLSchema10.BUILDERS, k))
-        for k in getattr(XMLSchema10.BUILDERS, '_fields')
-    }
+    xsd_notation_class = observed_builder(XMLSchema10.xsd_notation_class)
+    xsd_complex_type_class = observed_builder(XMLSchema10.xsd_complex_type_class)
+    xsd_attribute_class = observed_builder(XMLSchema10.xsd_attribute_class)
+    xsd_any_attribute_class = observed_builder(XMLSchema10.xsd_any_attribute_class)
+    xsd_attribute_group_class = observed_builder(XMLSchema10.xsd_attribute_group_class)
+    xsd_group_class = observed_builder(XMLSchema10.xsd_group_class)
+    xsd_element_class = observed_builder(XMLSchema10.xsd_element_class)
+    xsd_any_class = observed_builder(XMLSchema10.xsd_any_class)
+    xsd_atomic_restriction_class = observed_builder(XMLSchema10.xsd_atomic_restriction_class)
+    xsd_list_class = observed_builder(XMLSchema10.xsd_list_class)
+    xsd_union_class = observed_builder(XMLSchema10.xsd_union_class)
+    xsd_key_class = observed_builder(XMLSchema10.xsd_key_class)
+    xsd_keyref_class = observed_builder(XMLSchema10.xsd_keyref_class)
+    xsd_unique_class = observed_builder(XMLSchema10.xsd_unique_class)
 
 
 class ObservedXMLSchema11(XMLSchema11):
-    BUILDERS = {
-        k: SchemaObserver.observed_builder(getattr(XMLSchema11.BUILDERS, k))
-        for k in getattr(XMLSchema11.BUILDERS, '_fields')
-    }
+    xsd_notation_class = observed_builder(XMLSchema11.xsd_notation_class)
+    xsd_complex_type_class = observed_builder(XMLSchema11.xsd_complex_type_class)
+    xsd_attribute_class = observed_builder(XMLSchema11.xsd_attribute_class)
+    xsd_any_attribute_class = observed_builder(XMLSchema11.xsd_any_attribute_class)
+    xsd_attribute_group_class = observed_builder(XMLSchema11.xsd_attribute_group_class)
+    xsd_group_class = observed_builder(XMLSchema11.xsd_group_class)
+    xsd_element_class = observed_builder(XMLSchema11.xsd_element_class)
+    xsd_any_class = observed_builder(XMLSchema11.xsd_any_class)
+    xsd_atomic_restriction_class = observed_builder(XMLSchema11.xsd_atomic_restriction_class)
+    xsd_list_class = observed_builder(XMLSchema11.xsd_list_class)
+    xsd_union_class = observed_builder(XMLSchema11.xsd_union_class)
+    xsd_key_class = observed_builder(XMLSchema11.xsd_key_class)
+    xsd_keyref_class = observed_builder(XMLSchema11.xsd_keyref_class)
+    xsd_unique_class = observed_builder(XMLSchema11.xsd_unique_class)

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/validators/__init__.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/validators/__init__.py Changed

@@ -27,15 +27,15 @@
 from .wildcards import XsdAnyElement, Xsd11AnyElement, XsdAnyAttribute, Xsd11AnyAttribute, \
     XsdOpenContent, XsdDefaultOpenContent
 from .attributes import XsdAttribute, Xsd11Attribute, XsdAttributeGroup
-from .simple_types import xsd_simple_type_factory, XsdSimpleType, XsdAtomic, XsdAtomicBuiltin, \
+from .simple_types import XsdSimpleType, XsdAtomic, XsdAtomicBuiltin, \
     XsdAtomicRestriction, Xsd11AtomicRestriction, XsdList, XsdUnion, Xsd11Union
 from .complex_types import XsdComplexType, Xsd11ComplexType
-from .models import ModelGroup, ModelVisitor
+from .models import ModelVisitor
 from .groups import XsdGroup, Xsd11Group
 from .elements import XsdElement, Xsd11Element, XsdAlternative
 
 from .global_maps import XsdGlobals
-from .schema import XMLSchemaMeta, XMLSchemaBase, XMLSchema, XMLSchema10, XMLSchema11
+from .schemas import XMLSchemaMeta, XMLSchemaBase, XMLSchema, XMLSchema10, XMLSchema11
 
 
 __all__ = 
@@ -52,10 +52,9 @@
     'XsdTotalDigitsFacet', 'XsdExplicitTimezoneFacet', 'XsdPatternFacets',
     'XsdEnumerationFacets', 'XsdAssertionFacet', 'XsdAnyElement', 'Xsd11AnyElement',
     'XsdAnyAttribute', 'Xsd11AnyAttribute', 'XsdOpenContent', 'XsdDefaultOpenContent',
-    'XsdAttribute', 'Xsd11Attribute', 'XsdAttributeGroup', 'xsd_simple_type_factory',
-    'XsdSimpleType', 'XsdAtomic', 'XsdAtomicBuiltin', 'XsdAtomicRestriction',
-    'Xsd11AtomicRestriction', 'XsdList', 'XsdUnion', 'Xsd11Union', 'XsdComplexType',
-    'Xsd11ComplexType', 'ModelGroup', 'ModelVisitor', 'XsdGroup', 'Xsd11Group',
-    'XsdElement', 'Xsd11Element', 'XsdAlternative', 'XsdGlobals', 'XMLSchemaMeta',
-    'XMLSchemaBase', 'XMLSchema', 'XMLSchema10', 'XMLSchema11'
+    'XsdAttribute', 'Xsd11Attribute', 'XsdAttributeGroup', 'XsdSimpleType', 'XsdAtomic',
+    'XsdAtomicBuiltin', 'XsdAtomicRestriction', 'Xsd11AtomicRestriction', 'XsdList',
+    'XsdUnion', 'Xsd11Union', 'XsdComplexType', 'Xsd11ComplexType', 'ModelVisitor',
+    'XsdGroup', 'Xsd11Group', 'XsdElement', 'Xsd11Element', 'XsdAlternative', 'XsdGlobals',
+    'XMLSchemaMeta', 'XMLSchemaBase', 'XMLSchema', 'XMLSchema10', 'XMLSchema11'

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/validators/assertions.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/validators/assertions.py Changed

@@ -8,16 +8,27 @@
 # @author Davide Brunato <brunato@sissa.it>
 #
 import threading
-from elementpath import XPath2Parser, XPathContext, ElementPathError
+from typing import TYPE_CHECKING, cast, Any, Dict, Iterator, Optional, Union
+from elementpath import XPath2Parser, XPathContext, XPathToken, ElementPathError
 
 from ..names import XSD_ASSERT
-from ..xpath import ElementPathMixin, XMLSchemaProxy
+from ..aliases import ElementType, SchemaType, SchemaElementType, NamespacesType
+from ..xpath import XMLSchemaProtocol, ElementProtocol, ElementPathMixin, XMLSchemaProxy
 
-from .exceptions import XMLSchemaValidationError
+from .exceptions import XMLSchemaNotBuiltError, XMLSchemaValidationError
 from .xsdbase import XsdComponent
+from .groups import XsdGroup
 
 
-class XsdAssert(XsdComponent, ElementPathMixin):
+if TYPE_CHECKING:
+    from ..resources import XMLResource
+    from .attributes import XsdAttributeGroup
+    from .complex_types import XsdComplexType
+    from .elements import XsdElement
+    from .wildcards import XsdAnyElement
+
+
+class XsdAssert(XsdComponent, ElementPathMixinUnion'XsdAssert', SchemaElementType):
     """
     Class for XSD *assert* constraint definitions.
 
@@ -29,38 +40,37 @@
           Content: (annotation?)
         </assert>
     """
+    parent: 'XsdComplexType'
     _ADMITTED_TAGS = {XSD_ASSERT}
-    token = None
-    parser = None
+    token: OptionalXPathToken = None
+    parser: OptionalXPath2Parser = None
     path = 'true()'
 
-    def __init__(self, elem, schema, parent, base_type):
+    def __init__(self, elem: ElementType,
+                 schema: SchemaType,
+                 parent: 'XsdComplexType',
+                 base_type: 'XsdComplexType') -> None:
+
+        self._xpath_lock = threading.Lock()
         self.base_type = base_type
-        self._assert_xpath_lock = threading.Lock()  # Lock for assertion XPath operations
         super(XsdAssert, self).__init__(elem, schema, parent)
-        ElementPathMixin.__init__(self)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         if len(self.path) < 40:
             return '%s(test=%r)' % (self.__class__.__name__, self.path)
         else:
             return '%s(test=%r)' % (self.__class__.__name__, self.path:37 + '...')
 
-    def __getstate__(self):
+    def __getstate__(self) -> Dictstr, Any:
         state = self.__dict__.copy()
-        state.pop('_assert_xpath_lock', None)
         state.pop('_xpath_lock', None)
-        state.pop('_xpath_parser', None)
-        state.pop('xpath_tokens', None)  # For schema objects
         return state
 
-    def __setstate__(self, state):
+    def __setstate__(self, state: Any) -> None:
         self.__dict__.update(state)
         self._xpath_lock = threading.Lock()
-        self._assert_xpath_lock = threading.Lock()
 
-    def _parse(self):
-        super(XsdAssert, self)._parse()
+    def _parse(self) -> None:
         if self.base_type.is_simple():
             self.parse_error("base_type=%r is not a complexType definition" % self.base_type)
         else:
@@ -75,16 +85,18 @@
             self.xpath_default_namespace = self.schema.xpath_default_namespace
 
     @property
-    def built(self):
-        return self.token is not None and (self.base_type.parent is None or self.base_type.built)
+    def built(self) -> bool:
+        return self.parser is not None and self.token is not None
 
-    def build(self):
+    def build(self) -> None:
+        # Assert requires a schema bound parser because select
+        # is on XML elements and with XSD type decoded values
         self.parser = XPath2Parser(
             namespaces=self.namespaces,
             variable_types={'value': self.base_type.sequence_type},
             strict=False,
             default_namespace=self.xpath_default_namespace,
-            schema=XMLSchemaProxy(self.schema, self)
+            schema=self.xpath_proxy,
         )
 
         try:
@@ -93,16 +105,30 @@
             self.parse_error(err)
             self.token = self.parser.parse('true()')
         finally:
-            self.parser.variable_types.clear()
+            if self.parser.variable_types:
+                self.parser.variable_types.clear()
+
+    def __call__(self, elem: ElementType,
+                 value: Any = None,
+                 namespaces: OptionalNamespacesType = None,
+                 source: Optional'XMLResource' = None,
+                 **kwargs: Any) -> IteratorXMLSchemaValidationError:
+
+        if self.parser is None or self.token is None:
+            raise XMLSchemaNotBuiltError(self, "schema bound parser not set")
 
-    def __call__(self, elem, value=None, namespaces=None, source=None, **kwargs):
         with self._xpath_lock:
-            if not self.parser.is_schema_bound():
+            if not self.parser.is_schema_bound() and self.parser.schema:
                 self.parser.schema.bind_parser(self.parser)
 
+        if namespaces is None or isinstance(namespaces, dict):
+            _namespaces = namespaces
+        else:
+            _namespaces = dict(namespaces)
+
         variables = {'value': None if value is None else self.base_type.text_decode(value)}
         if source is not None:
-            context = XPathContext(source.root, namespaces=namespaces,
+            context = XPathContext(source.root, namespaces=_namespaces,
                                    item=elem, variables=variables)
         else:
             # If validated from a component (could not work with rooted XPath expressions)
@@ -115,18 +141,21 @@
             yield XMLSchemaValidationError(self, obj=elem, reason=str(err))
 
     # For implementing ElementPathMixin
-    def __iter__(self):
-        if not self.parent.has_simple_content():
+    def __iter__(self) -> IteratorUnion'XsdElement', 'XsdAnyElement':
+        if isinstance(self.parent.content, XsdGroup):
             yield from self.parent.content.iter_elements()
 
     @property
-    def attrib(self):
+    def attrib(self) -> 'XsdAttributeGroup':
         return self.parent.attributes
 
     @property
-    def type(self):
+    def type(self) -> 'XsdComplexType':
         return self.parent
 
     @property
-    def xpath_proxy(self):
-        return XMLSchemaProxy(self.schema, self)
+    def xpath_proxy(self) -> 'XMLSchemaProxy':
+        return XMLSchemaProxy(
+            schema=cast(XMLSchemaProtocol, self.schema),
+            base_element=cast(ElementProtocol, self)
+        )

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/validators/attributes.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/validators/attributes.py Changed

@@ -11,15 +11,17 @@
 This module contains classes for XML Schema attributes and attribute groups.
 """
 from decimal import Decimal
-from collections.abc import MutableMapping
 from elementpath.datatypes import AbstractDateTime, Duration, AbstractBinary
-from typing import Union, Dict, Optional
+from typing import cast, Any, Callable, Union, Dict, List, Optional, \
+    Iterator, MutableMapping, Tuple
 
 from ..exceptions import XMLSchemaValueError
 from ..names import XSI_NAMESPACE, XSD_ANY_SIMPLE_TYPE, XSD_SIMPLE_TYPE, \
     XSD_ATTRIBUTE_GROUP, XSD_COMPLEX_TYPE, XSD_RESTRICTION, XSD_EXTENSION, \
     XSD_SEQUENCE, XSD_ALL, XSD_CHOICE, XSD_ATTRIBUTE, XSD_ANY_ATTRIBUTE, \
     XSD_ASSERT, XSD_NOTATION_TYPE, XSD_ANNOTATION
+from ..aliases import ComponentClassType, ElementType, IterDecodeType, \
+    IterEncodeType, AtomicValueType, SchemaType, DecodedValueType, EncodedValueType
 from ..helpers import get_namespace, get_qname
 
 from .exceptions import XMLSchemaValidationError
@@ -28,7 +30,7 @@
 from .wildcards import XsdAnyAttribute
 
 
-class XsdAttribute(XsdComponent, ValidationMixin):
+class XsdAttribute(XsdComponent, ValidationMixinstr, DecodedValueType):
     """
     Class for XSD 1.0 *attribute* declarations.
 
@@ -49,16 +51,22 @@
     """
     _ADMITTED_TAGS = {XSD_ATTRIBUTE}
 
-    type = None
-    qualified = False
-    default = None
-    fixed = None
-    form = None
-    use = 'optional'
-    inheritable = False  # For XSD 1.1 attributes, always False for XSD 1.0 attributes.
+    name: str
+    local_name: str
+    qualified_name: str
+    prefixed_name: str
 
-    def _parse(self):
-        super(XsdAttribute, self)._parse()
+    type: XsdSimpleType
+    copy: Callable'XsdAttribute', 'XsdAttribute'
+
+    qualified: bool = False
+    default: Optionalstr = None
+    fixed: Optionalstr = None
+    form: Optionalstr = None
+    use: str = 'optional'
+    inheritable: bool = False  # For XSD 1.1 attributes, always False for XSD 1.0 attributes.
+
+    def _parse(self) -> None:
         attrib = self.elem.attrib
 
         if 'use' in attrib and self.parent is not None and \
@@ -125,7 +133,7 @@
                     self.parse_error(err)
                 else:
                     try:
-                        self.type = self.maps.lookup_type(type_qname)
+                        self.type = cast(XsdSimpleType, self.maps.lookup_type(type_qname))
                     except LookupError as err:
                         self.type = self.any_simple_type
                         self.parse_error(err)
@@ -135,7 +143,7 @@
 
             elif child is not None:
                 # No 'type' attribute in declaration, parse for child local simpleType
-                self.type = self.schema.BUILDERS.simple_type_factory(child, self.schema, self)
+                self.type = self.schema.simple_type_factory(child, self.schema, self)
             else:
                 # Empty declaration means xsdAnySimpleType
                 self.type = self.any_simple_type
@@ -169,78 +177,82 @@
                 self.parse_error("xs:ID key attributes cannot have a fixed value")
 
     @property
-    def built(self):
+    def built(self) -> bool:
         return True
 
     @property
-    def validation_attempted(self):
+    def validation_attempted(self) -> str:
         return 'full'
 
     @property
-    def scope(self):
+    def scope(self) -> str:
         """The scope of the attribute declaration that can be 'global' or 'local'."""
         return 'global' if self.parent is None else 'local'
 
     @property
-    def value_constraint(self):
+    def value_constraint(self) -> Optionalstr:
         """The fixed or the default value if either is defined, `None` otherwise."""
         return self.fixed if self.fixed is not None else self.default
 
-    def is_optional(self):
+    def is_optional(self) -> bool:
         return self.use == 'optional'
 
-    def is_required(self):
+    def is_required(self) -> bool:
         return self.use == 'required'
 
-    def is_prohibited(self):
+    def is_prohibited(self) -> bool:
         return self.use == 'prohibited'
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         return self.fixed == '' or self.type.is_empty()
 
-    def iter_components(self, xsd_classes=None):
+    def iter_components(self, xsd_classes: ComponentClassType = None) \
+            -> IteratorXsdComponent:
         if xsd_classes is None or isinstance(self, xsd_classes):
             yield self
         if self.ref is None and self.type.parent is not None:
             yield from self.type.iter_components(xsd_classes)
 
-    def data_value(self, text):
+    def data_value(self, text: str) -> AtomicValueType:
         """Returns the decoded data value of the provided text as XPath fn:data()."""
-        return self.decode(text, validation='skip')
+        return cast(AtomicValueType, self.decode(text, validation='skip'))
 
-    def iter_decode(self, text, validation='lax', **kwargs):
-        if text is None and self.default is not None:
-            text = self.default
+    def iter_decode(self, obj: str, validation: str = 'lax', **kwargs: Any) \
+            -> IterDecodeTypeDecodedValueType:
+        if obj is None and self.default is not None:
+            obj = self.default
 
         if self.type.is_notation():
             if self.type.name == XSD_NOTATION_TYPE:
                 msg = "cannot validate against xs:NOTATION directly, " \
                       "only against a subtype with an enumeration facet"
-                yield self.validation_error(validation, msg, text, **kwargs)
+                yield self.validation_error(validation, msg, obj, **kwargs)
             elif not self.type.enumeration:
                 msg = "missing enumeration facet in xs:NOTATION subtype"
-                yield self.validation_error(validation, msg, text, **kwargs)
+                yield self.validation_error(validation, msg, obj, **kwargs)
 
         if self.fixed is not None:
-            if text is None:
-                text = self.fixed
-            elif text != self.fixed and \
-                    self.type.text_decode(text) != self.type.text_decode(self.fixed):
+            if obj is None:
+                obj = self.fixed
+            elif obj != self.fixed and \
+                    self.type.text_decode(obj) != self.type.text_decode(self.fixed):
                 msg = "attribute {!r} has a fixed value {!r}".format(self.name, self.fixed)
-                yield self.validation_error(validation, msg, text, **kwargs)
+                yield self.validation_error(validation, msg, obj, **kwargs)
 
-        for value in self.type.iter_decode(text, validation, **kwargs):
+        for value in self.type.iter_decode(obj, validation, **kwargs):
             if isinstance(value, XMLSchemaValidationError):
                 value.reason = 'attribute {}={!r}: {}'.format(
-                    self.prefixed_name, text, value.reason
+                    self.prefixed_name, obj, value.reason
                 )
                 yield value
                 continue
+            elif 'value_hook' in kwargs:
+                yield kwargs'value_hook'(value, self.type)
             elif isinstance(value, (int, float, list)) or value is None:
                 yield value
             elif isinstance(value, str):
                 if value.startswith('{') and self.type.is_qname():
-                    yield text
+                    yield obj
                 else:
                     yield value
             elif isinstance(value, Decimal):
@@ -249,18 +261,16 @@
                 except (KeyError, TypeError):
                     yield value
             elif isinstance(value, (AbstractDateTime, Duration)):
-                yield value if kwargs.get('datetime_types') else text
+                yield value if kwargs.get('datetime_types') else obj.strip()
             elif isinstance(value, AbstractBinary) and not kwargs.get('binary_types'):
-                yield text
+                yield str(value)
             else:
                 yield value
-            break
+            break  # pragma: no cover
 
-    def iter_encode(self, obj, validation='lax', **kwargs):
-        for result in self.type.iter_encode(obj, validation):
-            yield result
-            if not isinstance(result, XMLSchemaValidationError):
-                return
+    def iter_encode(self, obj: Any, validation: str = 'lax', **kwargs: Any) \
+            -> IterEncodeTypeUnionEncodedValueType:
+        yield from self.type.iter_encode(obj, validation, **kwargs)
 
 
 class Xsd11Attribute(XsdAttribute):
@@ -282,10 +292,10 @@
           Content: (annotation?, simpleType?)
         </attribute>
     """
-    _target_namespace = None
+    _target_namespace: Optionalstr = None
 
     @property
-    def target_namespace(self):
+    def target_namespace(self) -> str:
         if self._target_namespace is not None:
             return self._target_namespace
         elif self.ref is not None:
@@ -293,8 +303,8 @@
         else:
             return self.schema.target_namespace
 
-    def _parse(self):
-        super(Xsd11Attribute, self)._parse()
+    def _parse(self) -> None:
+        super()._parse()
         if self.use == 'prohibited' and 'fixed' in self.elem.attrib:
             self.parse_error("attribute 'fixed' with use=prohibited is not allowed in XSD 1.1")
         if 'inheritable' in self.elem.attrib:
@@ -303,7 +313,10 @@
         self._parse_target_namespace()
 
 
-class XsdAttributeGroup(MutableMapping, XsdComponent, ValidationMixin):
+class XsdAttributeGroup(
+        MutableMappingOptionalstr, UnionXsdAttribute, XsdAnyAttribute, XsdComponent,
+        ValidationMixinMutableMappingstr, str, ListTuplestr, Any
+):
     """
     Class for XSD *attributeGroup* definitions.
 
@@ -319,17 +332,21 @@
         XSD_ATTRIBUTE_GROUP, XSD_COMPLEX_TYPE, XSD_RESTRICTION, XSD_EXTENSION,
         XSD_SEQUENCE, XSD_ALL, XSD_CHOICE, XSD_ATTRIBUTE, XSD_ANY_ATTRIBUTE
     }
+    copy: Callable'XsdAttributeGroup', 'XsdAttributeGroup'
 
-    def __init__(self, elem, schema, parent, derivation=None, base_attributes=None):
+    def __init__(self, elem: ElementType,
+                 schema: SchemaType,
+                 parent: OptionalXsdComponent = None,
+                 derivation: Optionalstr = None,
+                 base_attributes: Optional'XsdAttributeGroup' = None) -> None:
+
+        self._attribute_group: DictOptionalstr, UnionXsdAttribute, XsdAnyAttribute = {}
         self.derivation = derivation
-        self._attribute_group: Dictstr, UnionXsdAttribute, XsdAnyAttribute = {}
         self.base_attributes = base_attributes
         XsdComponent.__init__(self, elem, schema, parent)
 
-    def __repr__(self):
-        if self.ref is not None:
-            return '%s(ref=%r)' % (self.__class__.__name__, self.name)
-        elif self.name is not None:
+    def __repr__(self) -> str:
+        if self.name is not None:
             return '%s(name=%r)' % (self.__class__.__name__, self.name)
         elif self:
             names = a if a.name is None else a.name for a in self.values()
@@ -338,59 +355,47 @@
             return '%s()' % self.__class__.__name__
 
     # Implementation of abstract methods
-    def __getitem__(self, key):
+    def __getitem__(self, key: Optionalstr) -> UnionXsdAttribute, XsdAnyAttribute:
         return self._attribute_groupkey
 
-    def __setitem__(self, key, value: UnionXsdAttribute, XsdAnyAttribute):
-        if key is None:
-            self._attribute_groupkey = value
-        else:
-            if key0 != '{':
-                if value.local_name != key:
-                    raise XMLSchemaValueError("%r name and key %r mismatch." % (value.name, key))
-                if value.target_namespace != self.target_namespace:
-                    # Qualify attributes of other namespaces
-                    key = value.qualified_name
-            elif value.qualified_name != key:
-                raise XMLSchemaValueError("%r name and key %r mismatch." % (value.name, key))
-
-            self._attribute_groupkey = value
-
-    def __delitem__(self, key):
+    def __setitem__(self, key: Optionalstr,
+                    value: UnionXsdAttribute, XsdAnyAttribute) -> None:
+        if value.name != key:
+            raise XMLSchemaValueError("%r name and key %r mismatch" % (value.name, key))
+        self._attribute_groupkey = value
+
+    def __delitem__(self, key: Optionalstr) -> None:
         del self._attribute_groupkey
 
-    def __iter__(self):
+    def __iter__(self) -> IteratorOptionalstr:
         if None in self._attribute_group:
             # Put AnyAttribute ('None' key) at the end of iteration
-            return iter(sorted(self._attribute_group, key=lambda x: (x is None, x)))
+            yield from sorted(self._attribute_group, key=lambda x: (x is None, x))
         else:
-            return iter(self._attribute_group)
+            yield from self._attribute_group
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self._attribute_group)
 
-    def _parse(self):
-        super(XsdAttributeGroup, self)._parse()
-        any_attribute = None
-        attribute_group_refs = 
-
+    def _parse(self) -> None:
         if self.elem.tag == XSD_ATTRIBUTE_GROUP:
             if self.parent is not None:
-                return  # Skip dummy definitions
+                return  # Skip parsing dummy instances
             try:
                 self.name = get_qname(self.target_namespace, self.elem.attrib'name')
             except KeyError:
-                self.parse_error("an attribute group declaration requires a 'name' attribute.")
                 return
             else:
                 if self.schema.default_attributes == self.name and self.xsd_version > '1.0':
                     self.schema.default_attributes = self
 
+        any_attribute = None
+        attribute_group_refs = 
         attributes: DictOptionalstr, UnionXsdAttribute, XsdAnyAttribute = {}
 
         for child in self.elem:
             if child.tag == XSD_ANNOTATION or callable(child.tag):
-                continue
+                continue  # pragma: no cover
             elif any_attribute is not None:
                 if child.tag == XSD_ANY_ATTRIBUTE:
                     self.parse_error("more anyAttribute declarations in the same attribute group")
@@ -398,24 +403,21 @@
                     self.parse_error("another declaration after anyAttribute")
 
             elif child.tag == XSD_ANY_ATTRIBUTE:
-                any_attribute = self.schema.BUILDERS.any_attribute_class(child, self.schema, self)
+                any_attribute = self.schema.xsd_any_attribute_class(child, self.schema, self)
                 if None in attributes:
-                    attributesNone = attributesNone.copy()
-                    attributesNone.intersection(any_attribute)
+                    attributesNone = attr = attributesNone.copy()
+                    assert isinstance(attr, XsdAnyAttribute)
+                    attr.intersection(any_attribute)
                 else:
                     attributesNone = any_attribute
 
             elif child.tag == XSD_ATTRIBUTE:
-                try:
-                    attribute = self.schema.BUILDERS.attribute_class(child, self.schema, self)
-                except TypeError as err:
-                    self.parse_error(err, elem=child)
-                else:
-                    if attribute.name in attributes:
-                        self.parse_error("multiple declaration for attribute "
-                                         "{!r}".format(attribute.name))
-                    elif attribute.use != 'prohibited' or self.elem.tag != XSD_ATTRIBUTE_GROUP:
-                        attributesattribute.name = attribute
+                attribute = self.schema.xsd_attribute_class(child, self.schema, self)
+                if attribute.name in attributes:
+                    self.parse_error("multiple declaration for attribute "
+                                     "{!r}".format(attribute.name))
+                elif attribute.use != 'prohibited' or self.elem.tag != XSD_ATTRIBUTE_GROUP:
+                    attributesattribute.name = attribute
 
             elif child.tag == XSD_ATTRIBUTE_GROUP:
                 try:
@@ -438,7 +440,7 @@
                                 self.parse_error("in a redefinition the reference "
                                                  "to itself must be the first")
                             attribute_group_refs.append(attribute_group_qname)
-                            attributes.update(self._attribute_group.items())
+                            attributes.update(self._attribute_group)
                             continue
                         elif not attribute_group_refs:
                             # May be an attributeGroup restriction with a ref to another group
@@ -451,20 +453,24 @@
                     attribute_group_refs.append(attribute_group_qname)
 
                     try:
-                        base_attrs = self.maps.lookup_attribute_group(attribute_group_qname)
+                        ref_attributes = self.maps.lookup_attribute_group(attribute_group_qname)
                     except LookupError:
                         self.parse_error("unknown attribute group %r" % child.attrib'ref')
                     else:
-                        if not isinstance(base_attrs, tuple):
-                            for name, attr in base_attrs.items():
+                        if not isinstance(ref_attributes, tuple):
+                            for name, base_attr in ref_attributes.items():
                                 if name not in attributes:
-                                    attributesname = attr
+                                    attributesname = base_attr
                                 elif name is not None:
-                                    self.parse_error("multiple declaration for attribute "
-                                                     "{!r}".format(name))
+                                    if base_attr is not attributesname:
+                                        self.parse_error(
+                                            f"multiple declaration of attribute {name!r}"
+                                        )
                                 else:
-                                    attributesNone = attributesNone.copy()
-                                    attributesNone.intersection(attr)
+                                    assert isinstance(base_attr, XsdAnyAttribute)
+                                    attributesNone = attr = attributesNone.copy()
+                                    assert isinstance(attr, XsdAnyAttribute)
+                                    attr.intersection(base_attr)
 
                         elif self.xsd_version == '1.0':
                             self.parse_error(
@@ -488,7 +494,10 @@
 
                 base_attr = self.base_attributesname
 
-                if name is None:
+                if isinstance(attr, XsdAnyAttribute):
+                    assert name is None, "name key resolves to an xs:anyAttribute"
+                    assert isinstance(base_attr, XsdAnyAttribute), "invalid base attribute"
+
                     if self.derivation == 'extension':
                         try:
                             attr.union(base_attr)
@@ -498,6 +507,10 @@
                         self.parse_error("Attribute wildcard is not a restriction "
                                          "of the base wildcard")
                     continue
+
+                assert name is not None, "None key resolves to an xs:attribute"
+                assert isinstance(base_attr, XsdAttribute), "invalid base attribute"
+
                 if self.derivation == 'restriction' and attr.type.name != XSD_ANY_SIMPLE_TYPE and \
                         not attr.type.is_derived(base_attr.type, 'restriction'):
                     self.parse_error("Attribute type is not a restriction "
@@ -505,11 +518,11 @@
                 if base_attr.use != 'optional' and attr.use == 'optional' or \
                         base_attr.use == 'required' and attr.use != 'required':
                     self.parse_error("Attribute %r: unmatched attribute use in restriction" % name)
-                if base_attr.fixed is not None and \
-                        attr.type.normalize(attr.fixed) != \
-                        base_attr.type.normalize(base_attr.fixed):
-                    self.parse_error("Attribute %r: derived attribute "
-                                     "has a different fixed value" % name)
+                if base_attr.fixed is not None:
+                    if attr.fixed is None or attr.type.normalize(attr.fixed) != \
+                            base_attr.type.normalize(base_attr.fixed):
+                        self.parse_error("Attribute %r: derived attribute "
+                                         "has a different fixed value" % name)
                 if base_attr.inheritable is not attr.inheritable:
                     msg = "Attribute %r: attribute 'inheritable' value change in restriction"
                     self.parse_error(msg % name)
@@ -558,7 +571,7 @@
         if self.xsd_version == '1.0':
             has_key = False
             for attr in self._attribute_group.values():
-                if attr.name and attr.type.is_key():
+                if attr.type is not None and attr.type.is_key():
                     if has_key:
                         self.parse_error("multiple ID attributes not allowed for XSD 1.0")
                         break
@@ -568,49 +581,52 @@
             self.schema.default_attributes = self
 
     @property
-    def built(self):
+    def built(self) -> bool:
         return True
 
-    def parse_error(self, error, elem=None, validation=None):
+    def parse_error(self, error: Unionstr, Exception,
+                    elem: OptionalElementType = None,
+                    validation: Optionalstr = None) -> None:
         if self.parent is None:
-            super(XsdAttributeGroup, self).parse_error(error, elem, validation)
+            super().parse_error(error, elem, validation)
         else:
             self.parent.parse_error(error, elem, validation)
 
-    def iter_required(self):
+    def iter_required(self) -> Iteratorstr:
         for k, v in self._attribute_group.items():
-            if k is not None and v.use == 'required':
-                yield k
+            if isinstance(v, XsdAttribute) and k is not None:
+                if v.use == 'required':
+                    yield k
 
-    def iter_value_constraints(self, use_defaults=True):
+    def iter_value_constraints(self, use_defaults: bool = True) -> IteratorTuplestr, str:
         if use_defaults:
             for k, v in self._attribute_group.items():
-                if not k:
-                    continue
-                elif v.fixed is not None:
+                if v.fixed is not None and k:
                     yield k, v.fixed
-                elif v.default is not None:
+                elif v.default is not None and k:
                     yield k, v.default
         else:
             for k, v in self._attribute_group.items():
-                if k and v.fixed is not None:
+                if v.fixed is not None and k:
                     yield k, v.fixed
 
-    def iter_components(self, xsd_classes=None):
+    def iter_components(self, xsd_classes: ComponentClassType = None) \
+            -> IteratorXsdComponent:
         if xsd_classes is None or isinstance(self, xsd_classes):
             yield self
-        if self.ref is None:
-            for attr in self.values():
-                if attr.parent is not None:
-                    yield from attr.iter_components(xsd_classes)
 
-    def iter_decode(self, attrs, validation='lax', **kwargs):
-        if not attrs and not self:
+        for attr in self.values():
+            if attr.parent is not None:
+                yield from attr.iter_components(xsd_classes)
+
+    def iter_decode(self, obj: MutableMappingstr, str, validation: str = 'lax',
+                    **kwargs: Any) -> IterDecodeTypeListTuplestr, Any:
+        if not obj and not self:
             return
 
-        for name in filter(lambda x: x not in attrs, self.iter_required()):
+        for name in filter(lambda x: x not in obj, self.iter_required()):
             reason = "missing required attribute {!r}".format(name)
-            yield self.validation_error(validation, reason, attrs, **kwargs)
+            yield self.validation_error(validation, reason, obj, **kwargs)
 
         kwargs'level' = kwargs.get('level', 0) + 1
         try:
@@ -619,45 +635,47 @@
             use_defaults = True
 
         additional_attrs = 
-            (k, v) for k, v in self.iter_value_constraints(use_defaults) if k not in attrs
+            (k, v) for k, v in self.iter_value_constraints(use_defaults) if k not in obj
         
         if additional_attrs:
-            attrs = {k: v for k, v in attrs.items()}
-            attrs.update(additional_attrs)
+            obj = {k: v for k, v in obj.items()}
+            obj.update(additional_attrs)
 
         if self.xsd_version == '1.0':
             kwargs'id_list' = 
 
         filler = kwargs.get('filler')
-        result_list = 
-        for name, value in attrs.items():
+        result_list: ListTuplestr, DecodedValueType = 
+
+        value: Any
+        for name, value in obj.items():
             try:
-                xsd_attribute = selfname
+                xsd_attribute = self._attribute_groupname
             except KeyError:
                 if get_namespace(name) == XSI_NAMESPACE:
                     try:
                         xsd_attribute = self.maps.lookup_attribute(name)
                     except LookupError:
                         try:
-                            xsd_attribute = selfNone  # None key ==> anyAttribute
+                            xsd_attribute = self._attribute_groupNone  # None == anyAttribute
                             value = (name, value)
                         except KeyError:
                             reason = "%r is not an attribute of the XSI namespace." % name
-                            yield self.validation_error(validation, reason, attrs, **kwargs)
+                            yield self.validation_error(validation, reason, obj, **kwargs)
                             continue
                 else:
                     try:
-                        xsd_attribute = selfNone  # None key ==> anyAttribute
+                        xsd_attribute = self._attribute_groupNone  # None == anyAttribute
                         value = (name, value)
                     except KeyError:
                         reason = "%r attribute not allowed for element." % name
-                        yield self.validation_error(validation, reason, attrs, **kwargs)
+                        yield self.validation_error(validation, reason, obj, **kwargs)
                         continue
             else:
                 if xsd_attribute.use == 'prohibited' and \
-                        (None not in self or not selfNone.is_matching(name)):
+                        (None not in self or not self._attribute_groupNone.is_matching(name)):
                     reason = "use of attribute %r is prohibited" % name
-                    yield self.validation_error(validation, reason, attrs, **kwargs)
+                    yield self.validation_error(validation, reason, obj, **kwargs)
 
             for result in xsd_attribute.iter_decode(value, validation, **kwargs):
                 if isinstance(result, XMLSchemaValidationError):
@@ -672,20 +690,21 @@
         if kwargs.get('fill_missing'):
             if filler is None:
                 result_list.extend((k, None) for k in self._attribute_group
-                                   if k is not None and k not in attrs)
+                                   if k is not None and k not in obj)
             else:
                 result_list.extend((k, filler(v)) for k, v in self._attribute_group.items()
-                                   if k is not None and k not in attrs)
+                                   if k is not None and k not in obj)
 
         yield result_list
 
-    def iter_encode(self, attrs, validation='lax', **kwargs):
-        if not attrs and not self:
+    def iter_encode(self, obj: MutableMappingstr, Any, validation: str = 'lax',
+                    **kwargs: Any) -> IterEncodeTypeListTuplestr, Unionstr, Liststr:
+        if not obj and not self:
             return
 
-        for name in filter(lambda x: x not in attrs, self.iter_required()):
+        for name in filter(lambda x: x not in obj, self.iter_required()):
             reason = "missing required attribute {!r}".format(name)
-            yield self.validation_error(validation, reason, attrs, **kwargs)
+            yield self.validation_error(validation, reason, obj, **kwargs)
 
         try:
             use_defaults = kwargs'use_defaults'
@@ -693,9 +712,9 @@
             use_defaults = True
 
         result_list = 
-        for name, value in attrs.items():
+        for name, value in obj.items():
             try:
-                xsd_attribute = selfname
+                xsd_attribute = self._attribute_groupname
             except KeyError:
                 namespace = get_namespace(name) or self.target_namespace
                 if namespace == XSI_NAMESPACE:
@@ -703,19 +722,19 @@
                         xsd_attribute = self.maps.lookup_attribute(name)
                     except LookupError:
                         try:
-                            xsd_attribute = selfNone  # None key ==> anyAttribute
+                            xsd_attribute = self._attribute_groupNone  # None == anyAttribute
                             value = (name, value)
                         except KeyError:
                             reason = "%r is not an attribute of the XSI namespace." % name
-                            yield self.validation_error(validation, reason, attrs, **kwargs)
+                            yield self.validation_error(validation, reason, obj, **kwargs)
                             continue
                 else:
                     try:
-                        xsd_attribute = selfNone  # None key ==> anyAttribute
+                        xsd_attribute = self._attribute_groupNone  # None == anyAttribute
                         value = (name, value)
                     except KeyError:
                         reason = "%r attribute not allowed for element." % name
-                        yield self.validation_error(validation, reason, attrs, **kwargs)
+                        yield self.validation_error(validation, reason, obj, **kwargs)
                         continue
 
             for result in xsd_attribute.iter_encode(value, validation, **kwargs):
@@ -727,6 +746,6 @@
                     break
 
         result_list.extend(
-            (k, v) for k, v in self.iter_value_constraints(use_defaults) if k not in attrs
+            (k, v) for k, v in self.iter_value_constraints(use_defaults) if k not in obj
         )
         yield result_list

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/validators/builtins.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/validators/builtins.py Changed

@@ -15,6 +15,7 @@
 """
 from decimal import Decimal
 from elementpath import datatypes
+from typing import cast, Any, Dict, Optional, Type, Tuple, Union
 
 from ..exceptions import XMLSchemaValueError
 from ..names import XSD_LENGTH, XSD_MIN_LENGTH, XSD_MAX_LENGTH, XSD_ENUMERATION, \
@@ -31,6 +32,7 @@
     XSD_HEX_BINARY, XSD_NOTATION_TYPE, XSD_ERROR, XSD_ASSERTION, XSD_SIMPLE_TYPE, \
     XSD_ANY_TYPE, XSD_ANY_ATOMIC_TYPE, XSD_ANY_SIMPLE_TYPE
 from ..etree import etree_element
+from ..aliases import ElementType, SchemaType, BaseXsdType
 
 from .helpers import decimal_validator, qname_validator, byte_validator, \
     short_validator, int_validator, long_validator, unsigned_byte_validator, \
@@ -81,7 +83,7 @@
 )
 
 
-XSD_COMMON_BUILTIN_TYPES = (
+XSD_COMMON_BUILTIN_TYPES: TupleDictstr, Any, ... = (
     # ***********************
     # *** Primitive types ***
     # ***********************
@@ -326,7 +328,7 @@
     },  # only negative value allowed < 0
 )
 
-XSD_10_BUILTIN_TYPES = XSD_COMMON_BUILTIN_TYPES + (
+XSD_10_BUILTIN_TYPES: TupleDictstr, Any, ... = XSD_COMMON_BUILTIN_TYPES + (
     {
         'name': XSD_DOUBLE,
         'python_type': float,
@@ -371,7 +373,7 @@
     },  # -Y*YYYY-MM
 )
 
-XSD_11_BUILTIN_TYPES = XSD_COMMON_BUILTIN_TYPES + (
+XSD_11_BUILTIN_TYPES: TupleDictstr, Any, ... = XSD_COMMON_BUILTIN_TYPES + (
     {
         'name': XSD_DOUBLE,
         'python_type': float,
@@ -444,7 +446,10 @@
 )
 
 
-def xsd_builtin_types_factory(meta_schema, xsd_types, atomic_builtin_class=None):
+def xsd_builtin_types_factory(
+        meta_schema: SchemaType,
+        xsd_types: Dictstr, UnionBaseXsdType, TupleElementType, SchemaType,
+        atomic_builtin_class: OptionalTypeXsdAtomicBuiltin = None) -> None:
     """
     Builds the dictionary for XML Schema built-in types mapping.
     """
@@ -465,7 +470,7 @@
 
     # xs:anySimpleType
     # Ref: https://www.w3.org/TR/xmlschema11-2/#builtin-stds
-    xsd_typesXSD_ANY_SIMPLE_TYPE = XsdSimpleType(
+    xsd_any_simple_type = xsd_typesXSD_ANY_SIMPLE_TYPE = XsdSimpleType(
         elem=etree_element(XSD_SIMPLE_TYPE, name=XSD_ANY_SIMPLE_TYPE),
         schema=meta_schema,
         parent=None,
@@ -474,39 +479,41 @@
 
     # xs:anyAtomicType
     # Ref: https://www.w3.org/TR/xmlschema11-2/#builtin-stds
-    xsd_typesXSD_ANY_ATOMIC_TYPE = meta_schema.BUILDERS.restriction_class(
+    xsd_typesXSD_ANY_ATOMIC_TYPE = meta_schema.xsd_atomic_restriction_class(
         elem=etree_element(XSD_SIMPLE_TYPE, name=XSD_ANY_ATOMIC_TYPE),
         schema=meta_schema,
         parent=None,
         name=XSD_ANY_ATOMIC_TYPE,
-        base_type=xsd_typesXSD_ANY_SIMPLE_TYPE
+        base_type=xsd_any_simple_type,
     )
 
     for item in builtin_types:
         item = item.copy()
-        name = item'name'
+        name: str = item'name'
         try:
-            elem, schema = xsd_typesname
+            value = cast(TupleElementType, SchemaType, xsd_typesname)
         except KeyError:
             # If builtin type element is missing create a dummy element. Necessary for the
             # meta-schema XMLSchema.xsd of XSD 1.1, that not includes builtins declarations.
             elem = etree_element(XSD_SIMPLE_TYPE, name=name, id=name)
         else:
+            elem, schema = value
             if schema is not meta_schema:
                 raise XMLSchemaValueError("loaded entry schema is not the meta-schema!")
 
+        base_type: UnionNone, BaseXsdType, TupleElementType, SchemaType
         if 'base_type' in item:
             base_type = item'base_type' = xsd_typesitem'base_type'
         else:
             base_type = None
 
         facets = item.pop('facets', None)
-        builtin_type = atomic_builtin_class(elem, meta_schema, **item)
+        builtin_type: XsdAtomicBuiltin = atomic_builtin_class(elem, meta_schema, **item)
         if facets:
             built_facets = builtin_type.facets
             for e in facets:
                 try:
-                    cls = facets_mape.tag
+                    cls: Any = facets_mape.tag
                 except AttributeError:
                     built_facetsNone = e
                 else:

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/validators/complex_types.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/validators/complex_types.py Changed

@@ -8,27 +8,32 @@
 # @author Davide Brunato <brunato@sissa.it>
 #
 from collections.abc import MutableSequence
+from typing import cast, Any, Callable, Iterator, List, Optional, Tuple, Union
 
 from ..exceptions import XMLSchemaValueError
 from ..names import XSD_GROUP, XSD_ATTRIBUTE_GROUP, XSD_SEQUENCE, XSD_OVERRIDE, \
     XSD_ALL, XSD_CHOICE, XSD_ANY_ATTRIBUTE, XSD_ATTRIBUTE, XSD_COMPLEX_CONTENT, \
     XSD_RESTRICTION, XSD_COMPLEX_TYPE, XSD_EXTENSION, XSD_ANY_TYPE, XSD_ASSERT, \
     XSD_UNTYPED_ATOMIC, XSD_SIMPLE_CONTENT, XSD_OPEN_CONTENT, XSD_ANNOTATION
+from ..aliases import ElementType, NamespacesType, SchemaType, ComponentClassType, \
+    DecodeType, IterDecodeType, IterEncodeType, BaseXsdType, AtomicValueType, \
+    ExtraValidatorType
 from ..helpers import get_prefixed_qname, get_qname, local_name
 from .. import dataobjects
 
 from .exceptions import XMLSchemaDecodeError
 from .helpers import get_xsd_derivation_attribute
 from .xsdbase import XSD_TYPE_DERIVATIONS, XsdComponent, XsdType, ValidationMixin
+from .attributes import XsdAttributeGroup
 from .assertions import XsdAssert
-from .simple_types import XsdSimpleType
+from .simple_types import FacetsValueType, XsdSimpleType, XsdUnion
 from .groups import XsdGroup
-from .wildcards import XsdOpenContent
+from .wildcards import XsdOpenContent, XsdDefaultOpenContent
 
 XSD_MODEL_GROUP_TAGS = {XSD_GROUP, XSD_SEQUENCE, XSD_ALL, XSD_CHOICE}
 
 
-class XsdComplexType(XsdType, ValidationMixin):
+class XsdComplexType(XsdType, ValidationMixinUnionElementType, str, bytes, Any):
     """
     Class for XSD 1.0 *complexType* definitions.
 
@@ -48,22 +53,29 @@
           ((group | all | choice | sequence)?, ((attribute | attributeGroup)*, anyAttribute?))))
         </complexType>
     """
-    abstract = False
-    mixed = False
-    assertions = ()
-    open_content = None
-    content = None
-    default_open_content = None
-    _block = None
+    attributes: XsdAttributeGroup
+    copy: Callable'XsdComplexType', 'XsdComplexType'
+    content: UnionXsdGroup, XsdSimpleType = None  # type: ignoreassignment
+
+    abstract: bool = False
+    mixed: bool = False
+    assertions: UnionTuple(), ListXsdAssert = ()
+    open_content: OptionalXsdOpenContent = None
+    _block: Optionalstr = None
 
     _ADMITTED_TAGS = {XSD_COMPLEX_TYPE, XSD_RESTRICTION}
     _CONTENT_TAIL_TAGS = {XSD_ATTRIBUTE, XSD_ATTRIBUTE_GROUP, XSD_ANY_ATTRIBUTE}
 
     @staticmethod
-    def normalize(text):
+    def normalize(text: Unionstr, bytes) -> str:
         return text.decode('utf-8') if isinstance(text, bytes) else text
 
-    def __init__(self, elem, schema, parent, name=None, **kwargs):
+    def __init__(self, elem: ElementType,
+                 schema: SchemaType,
+                 parent: OptionalXsdComponent = None,
+                 name: Optionalstr = None,
+                 **kwargs: Any) -> None:
+
         if kwargs:
             if 'content' in kwargs:
                 self.content = kwargs'content'
@@ -76,8 +88,9 @@
             if 'final' in kwargs:
                 self._final = kwargs'final'
         super(XsdComplexType, self).__init__(elem, schema, parent, name)
+        assert self.content is not None
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         if self.name is not None:
             return '%s(name=%r)' % (self.__class__.__name__, self.prefixed_name)
         elif not hasattr(self, 'content') or not hasattr(self, 'attributes'):
@@ -88,8 +101,7 @@
                 a if a.name is None else a.prefixed_name for a in self.attributes.values()
             )
 
-    def _parse(self):
-        super(XsdComplexType, self)._parse()
+    def _parse(self) -> None:
         if self.elem.tag == XSD_RESTRICTION:
             return  # a local restriction is already parsed by the caller
 
@@ -130,14 +142,14 @@
             self.content = self.schema.create_empty_content_group(self)
             self._parse_content_tail(self.elem)
             default_open_content = self.default_open_content
-            if default_open_content and \
+            if default_open_content is not None and \
                     (self.mixed or self.content or default_open_content.applies_to_empty):
                 self.open_content = default_open_content
 
         elif content_elem.tag in {XSD_GROUP, XSD_SEQUENCE, XSD_ALL, XSD_CHOICE}:
-            self.content = self.schema.BUILDERS.group_class(content_elem, self.schema, self)
+            self.content = self.schema.xsd_group_class(content_elem, self.schema, self)
             default_open_content = self.default_open_content
-            if default_open_content and \
+            if default_open_content is not None and \
                     (self.mixed or self.content or default_open_content.applies_to_empty):
                 self.open_content = default_open_content
             self._parse_content_tail(self.elem)
@@ -177,17 +189,15 @@
             if derivation_elem is None:
                 return
 
-            base_type = self._parse_base_type(derivation_elem, complex_content=True)
-            if base_type is not self:
-                self.base_type = base_type
-            elif self.redefine:
+            self.base_type = self._parse_base_type(derivation_elem, complex_content=True)
+            if self.base_type is self and self.redefine is not None:
                 self.base_type = self.redefine
                 self.open_content = None
 
             if derivation_elem.tag == XSD_RESTRICTION:
-                self._parse_complex_content_restriction(derivation_elem, base_type)
+                self._parse_complex_content_restriction(derivation_elem, self.base_type)
             else:
-                self._parse_complex_content_extension(derivation_elem, base_type)
+                self._parse_complex_content_extension(derivation_elem, self.base_type)
 
             if content_elem is not self.elem-1:
                 k = 2 if content_elem is not self.elem0 else 1
@@ -205,11 +215,11 @@
                     if content_elem is not child:
                         continue
                     elif self.elemindex + 1.tag in {XSD_GROUP, XSD_SEQUENCE, XSD_ALL, XSD_CHOICE}:
-                        self.content = self.schema.BUILDERS.group_class(
+                        self.content = self.schema.xsd_group_class(
                             self.elemindex + 1, self.schema, self
                         )
                     else:
-                        self.content = self.schema.self.schema.create_empty_content_group(self)
+                        self.content = self.schema.create_empty_content_group(self)
                     break
             self._parse_content_tail(self.elem)
 
@@ -228,32 +238,30 @@
         elif self.base_type is None or self.base_type.name != self.name:
             self.parse_error("wrong redefinition without self-reference")
 
-    def _parse_content_tail(self, elem, **kwargs):
-        self.attributes = self.schema.BUILDERS.attribute_group_class(
+    def _parse_content_tail(self, elem: ElementType, **kwargs: Any) -> None:
+        self.attributes = self.schema.xsd_attribute_group_class(
             elem, self.schema, self, **kwargs
         )
 
-    def _parse_derivation_elem(self, elem):
+    def _parse_derivation_elem(self, elem: ElementType) -> OptionalElementType:
         derivation_elem = self._parse_child_component(elem)
-        if getattr(derivation_elem, 'tag', None) not in (XSD_RESTRICTION, XSD_EXTENSION):
+        if derivation_elem is None or derivation_elem.tag not in {XSD_RESTRICTION, XSD_EXTENSION}:
             self.parse_error("restriction or extension tag expected", derivation_elem)
             self.content = self.schema.create_any_content_group(self)
             self.attributes = self.schema.create_any_attribute_group(self)
-            return
-
-        derivation = local_name(derivation_elem.tag)
-        if self.derivation is None:
-            self.derivation = derivation
-        elif self.redefine is None:
-            raise XMLSchemaValueError(
-                "%r is expected to have a redefined/overridden component" % self
-            )
+            return None
 
-        if self.base_type is not None and derivation in self.base_type.final:
-            self.parse_error("%r derivation not allowed for %r." % (derivation, self))
+        if self.derivation is not None and self.redefine is None:
+            raise XMLSchemaValueError("{!r} is expected to have a redefined/"
+                                      "overridden component".format(self))
+        self.derivation = local_name(derivation_elem.tag)
+
+        if self.base_type is not None and self.derivation in self.base_type.final:
+            self.parse_error(f"{self.derivation!r} derivation not allowed for {self!r}")
         return derivation_elem
 
-    def _parse_base_type(self, elem, complex_content=False):
+    def _parse_base_type(self, elem: ElementType, complex_content: bool = False) \
+            -> UnionXsdSimpleType, 'XsdComplexType':
         try:
             base_qname = self.schema.resolve_qname(elem.attrib'base')
         except (KeyError, ValueError, RuntimeError) as err:
@@ -286,7 +294,7 @@
 
             return base_type
 
-    def _parse_simple_content_restriction(self, elem, base_type):
+    def _parse_simple_content_restriction(self, elem: ElementType, base_type: Any) -> None:
         # simpleContent restriction: the base type must be a complexType with a simple
         # content or a complex content with a mixed and emptiable content.
         if base_type.is_simple():
@@ -295,19 +303,19 @@
             self._parse_content_tail(elem)
         else:
             if base_type.is_empty():
-                self.content = self.schema.BUILDERS.restriction_class(elem, self.schema, self)
+                self.content = self.schema.xsd_atomic_restriction_class(elem, self.schema, self)
                 if not self.is_empty():
                     self.parse_error("a not empty simpleContent cannot restrict "
                                      "an empty content type", elem)
                     self.content = self.schema.create_any_content_group(self)
 
             elif base_type.has_simple_content():
-                self.content = self.schema.BUILDERS.restriction_class(elem, self.schema, self)
+                self.content = self.schema.xsd_atomic_restriction_class(elem, self.schema, self)
                 if not self.content.is_derived(base_type.content, 'restriction'):
                     self.parse_error("content type is not a restriction of base content", elem)
 
             elif base_type.mixed and base_type.is_emptiable():
-                self.content = self.schema.BUILDERS.restriction_class(elem, self.schema, self)
+                self.content = self.schema.xsd_atomic_restriction_class(elem, self.schema, self)
             else:
                 self.parse_error("with simpleContent cannot restrict an "
                                  "element-only content type", elem)
@@ -316,7 +324,7 @@
             self._parse_content_tail(elem, derivation='restriction',
                                      base_attributes=base_type.attributes)
 
-    def _parse_simple_content_extension(self, elem, base_type):
+    def _parse_simple_content_extension(self, elem: ElementType, base_type: Any) -> None:
         # simpleContent extension: the base type must be a simpleType or a complexType
         # with simple content.
         child = self._parse_child_component(elem, strict=False)
@@ -336,7 +344,7 @@
             self._parse_content_tail(elem, derivation='extension',
                                      base_attributes=base_type.attributes)
 
-    def _parse_complex_content_restriction(self, elem, base_type):
+    def _parse_complex_content_restriction(self, elem: ElementType, base_type: Any) -> None:
         if 'restriction' in base_type.final:
             self.parse_error("the base type is not derivable by restriction")
         if base_type.is_simple() or base_type.has_simple_content():
@@ -349,7 +357,7 @@
                 self.open_content = XsdOpenContent(child, self.schema, self)
                 continue
             elif child.tag in XSD_MODEL_GROUP_TAGS:
-                content = self.schema.BUILDERS.group_class(child, self.schema, self)
+                content = self.schema.xsd_group_class(child, self.schema, self)
                 if not base_type.content.admits_restriction(content.model):
                     self.parse_error(
                         "restriction of an xs:{} with more than one particle with xs:{} is "
@@ -372,9 +380,9 @@
                 "derived an empty content from base type that has not empty content.", elem
             )
 
-        if not self.open_content:
+        if self.open_content is None:
             default_open_content = self.default_open_content
-            if default_open_content and \
+            if default_open_content is not None and \
                     (self.mixed or content or default_open_content.applies_to_empty):
                 self.open_content = default_open_content
 
@@ -387,10 +395,11 @@
         self._parse_content_tail(elem, derivation='restriction',
                                  base_attributes=base_type.attributes)
 
-    def _parse_complex_content_extension(self, elem, base_type):
+    def _parse_complex_content_extension(self, elem: ElementType, base_type: Any) -> None:
         if 'extension' in base_type.final:
             self.parse_error("the base type is not derivable by extension")
 
+        group_elem: OptionalElementType
         for group_elem in elem:
             if group_elem.tag != XSD_ANNOTATION and not callable(group_elem.tag):
                 break
@@ -401,7 +410,7 @@
             if not base_type.mixed:
                 # Empty element-only model extension: don't create a nested group.
                 if group_elem is not None and group_elem.tag in XSD_MODEL_GROUP_TAGS:
-                    self.content = self.schema.BUILDERS.group_class(
+                    self.content = self.schema.xsd_group_class(
                         group_elem, self.schema, self
                     )
                 elif base_type.is_simple() or base_type.has_simple_content():
@@ -416,7 +425,7 @@
                 self.content.append(self.schema.create_empty_content_group(self.content))
 
                 if group_elem is not None and group_elem.tag in XSD_MODEL_GROUP_TAGS:
-                    group = self.schema.BUILDERS.group_class(
+                    group = self.schema.xsd_group_class(
                         group_elem, self.schema, self.content
                     )
                     if not self.mixed:
@@ -435,7 +444,7 @@
                 self.parse_error("base %r is simple or has a simple content." % base_type, elem)
                 base_type = self.any_type
 
-            group = self.schema.BUILDERS.group_class(group_elem, self.schema, self)
+            group = self.schema.xsd_group_class(group_elem, self.schema, self)
 
             if group.model == 'all':
                 self.parse_error("cannot extend a complex content with xs:all")
@@ -473,32 +482,39 @@
         self._parse_content_tail(elem, derivation='extension', base_attributes=base_type.attributes)
 
     @property
-    def block(self):
+    def default_open_content(self) -> OptionalXsdDefaultOpenContent:
+        return None
+
+    @property
+    def block(self) -> str:
         return self.schema.block_default if self._block is None else self._block
 
     @property
-    def built(self):
+    def built(self) -> bool:
         return self.content.parent is not None or self.content.built
 
     @property
-    def validation_attempted(self):
+    def validation_attempted(self) -> str:
         return 'full' if self.built else self.content.validation_attempted
 
     @property
-    def simple_type(self):
+    def simple_type(self) -> OptionalXsdSimpleType:
         return self.content if isinstance(self.content, XsdSimpleType) else None
 
     @property
-    def model_group(self):
+    def model_group(self) -> OptionalXsdGroup:
         return self.content if isinstance(self.content, XsdGroup) else None
 
     @property
-    def content_type(self):
+    def content_type(self) -> UnionXsdGroup, XsdSimpleType:
         """Property that returns the attribute *content*, for backward compatibility."""
+        import warnings
+        warnings.warn("'content_type' attribute has been replaced by 'content' "
+                      "and will be removed in version 2.0", DeprecationWarning, stacklevel=2)
         return self.content
 
     @property
-    def content_type_label(self):
+    def content_type_label(self) -> str:
         if self.is_empty():
             return 'empty'
         elif isinstance(self.content, XsdSimpleType):
@@ -509,39 +525,39 @@
             return 'element-only'
 
     @property
-    def sequence_type(self):
+    def sequence_type(self) -> str:
         if self.is_empty():
             return 'empty-sequence()'
         elif not self.has_simple_content():
-            sequence_type = get_prefixed_qname(XSD_UNTYPED_ATOMIC, self.namespaces)
+            st = get_prefixed_qname(XSD_UNTYPED_ATOMIC, self.namespaces)
         else:
             try:
-                sequence_type = self.content.primitive_type.prefixed_name
+                st = self.content.primitive_type.prefixed_name  # type: ignoreunion-attr
             except AttributeError:
-                sequence_type = get_prefixed_qname(XSD_UNTYPED_ATOMIC, self.namespaces)
+                st = get_prefixed_qname(XSD_UNTYPED_ATOMIC, self.namespaces)
             else:
-                if sequence_type is None:
-                    sequence_type = 'item()'
+                if st is None:
+                    st = 'item()'
 
-        return '{}{}'.format(sequence_type, '*' if self.is_emptiable() else '+')
+        return f"{st}{'*' if self.is_emptiable() else '+'}"
 
     @staticmethod
-    def is_simple():
+    def is_simple() -> bool:
         return False
 
     @staticmethod
-    def is_complex():
+    def is_complex() -> bool:
         return True
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         if self.open_content and self.open_content.mode != 'none':
             return False
         return self.content.is_empty()
 
-    def is_emptiable(self):
+    def is_emptiable(self) -> bool:
         return self.content.is_emptiable()
 
-    def has_simple_content(self):
+    def has_simple_content(self) -> bool:
         if not isinstance(self.content, XsdGroup):
             return not self.content.is_empty()
         elif self.content or self.content.mixed or self.base_type is None:
@@ -549,14 +565,14 @@
         else:
             return self.base_type.is_simple() or self.base_type.has_simple_content()
 
-    def has_complex_content(self):
+    def has_complex_content(self) -> bool:
         if not isinstance(self.content, XsdGroup):
             return False
         elif self.open_content and self.open_content.mode != 'none':
             return True
         return not self.content.is_empty()
 
-    def has_mixed_content(self):
+    def has_mixed_content(self) -> bool:
         if not isinstance(self.content, XsdGroup):
             return False
         elif self.content.is_empty():
@@ -564,7 +580,7 @@
         else:
             return self.content.mixed
 
-    def is_element_only(self):
+    def is_element_only(self) -> bool:
         if not isinstance(self.content, XsdGroup):
             return False
         elif self.content.is_empty():
@@ -572,101 +588,149 @@
         else:
             return not self.content.mixed
 
-    def is_list(self):
-        return self.has_simple_content() and self.content.is_list()
-
-    def is_valid(self, source, use_defaults=True, namespaces=None):
-        if hasattr(source, 'tag'):
-            return super(XsdComplexType, self).is_valid(source, use_defaults, namespaces)
+    def is_list(self) -> bool:
+        return isinstance(self.content, XsdSimpleType) and self.content.is_list()
+
+    def validate(self, obj: UnionElementType, str, bytes,
+                 use_defaults: bool = True,
+                 namespaces: OptionalNamespacesType = None,
+                 max_depth: Optionalint = None,
+                 extra_validator: OptionalExtraValidatorType = None) -> None:
+        kwargs: Any = {
+            'use_defaults': use_defaults,
+            'namespaces': namespaces,
+            'max_depth': max_depth,
+            'extra_validator': extra_validator
+        }
+        if not isinstance(obj, (str, bytes)):
+            super(XsdComplexType, self).validate(obj, **kwargs)
         elif isinstance(self.content, XsdSimpleType):
-            return self.content.is_valid(source, use_defaults, namespaces)
+            self.content.validate(obj, **kwargs)
+        elif not self.mixed and self.base_type is not None:
+            self.base_type.validate(obj, **kwargs)
+
+    def is_valid(self, obj: UnionElementType, str, bytes,
+                 use_defaults: bool = True,
+                 namespaces: OptionalNamespacesType = None,
+                 max_depth: Optionalint = None,
+                 extra_validator: OptionalExtraValidatorType = None) -> bool:
+        kwargs: Any = {
+            'use_defaults': use_defaults,
+            'namespaces': namespaces,
+            'max_depth': max_depth,
+            'extra_validator': extra_validator
+        }
+        if not isinstance(obj, (str, bytes)):
+            return super(XsdComplexType, self).is_valid(obj, **kwargs)
+        elif isinstance(self.content, XsdSimpleType):
+            return self.content.is_valid(obj, **kwargs)
         else:
             return self.mixed or self.base_type is not None and \
-                self.base_type.is_valid(source, use_defaults, namespaces)
+                self.base_type.is_valid(obj, **kwargs)
 
-    def is_derived(self, other, derivation=None):
+    def is_derived(self, other: UnionBaseXsdType, TupleElementType, SchemaType,
+                   derivation: Optionalstr = None) -> bool:
         if derivation and derivation == self.derivation:
             derivation = None  # derivation mode checked
 
         if self is other:
             return derivation is None
+        elif isinstance(other, tuple):
+            other1.parse_error(f"global type {other0.tag!r} is not built")
+            return False
         elif other.name == XSD_ANY_TYPE:
             return True
         elif self.base_type is other:
             return derivation is None  # or self.base_type.derivation == derivation
-        elif hasattr(other, 'member_types'):
+        elif isinstance(other, XsdUnion):
             return any(self.is_derived(m, derivation) for m in other.member_types)
         elif self.base_type is None:
             if not self.has_simple_content():
                 return False
-            return self.content.is_derived(other, derivation)
+            return isinstance(self.content, XsdSimpleType) and \
+                self.content.is_derived(other, derivation)
         elif self.has_simple_content():
-            return self.content.is_derived(other, derivation) or \
+            return isinstance(self.content, XsdSimpleType) and \
+                self.content.is_derived(other, derivation) or \
                 self.base_type.is_derived(other, derivation)
         else:
             return self.base_type.is_derived(other, derivation)
 
-    def iter_components(self, xsd_classes=None):
+    def iter_components(self, xsd_classes: ComponentClassType = None) \
+            -> IteratorXsdComponent:
         if xsd_classes is None or isinstance(self, xsd_classes):
             yield self
         if self.attributes and self.attributes.parent is not None:
             yield from self.attributes.iter_components(xsd_classes)
         if self.content.parent is not None:
             yield from self.content.iter_components(xsd_classes)
-        if getattr(self.base_type, 'parent', None) is not None:
+        if self.base_type is not None and self.base_type.parent is not None:
             yield from self.base_type.iter_components(xsd_classes)
 
         for obj in filter(lambda x: x.base_type is self, self.assertions):
             if xsd_classes is None or isinstance(obj, xsd_classes):
                 yield obj
 
-    def get_facet(self, tag):
+    def get_facet(self, tag: str) -> OptionalFacetsValueType:
         if isinstance(self.content, XsdSimpleType):
             return self.content.get_facet(tag)
+        return None
 
-    def admit_simple_restriction(self):
+    def admit_simple_restriction(self) -> bool:
         if 'restriction' in self.final:
             return False
         else:
             return self.has_simple_content() or self.mixed and self.is_emptiable()
 
-    def has_restriction(self):
+    def has_restriction(self) -> bool:
         return self.derivation == 'restriction'
 
-    def has_extension(self):
+    def has_extension(self) -> bool:
         return self.derivation == 'extension'
 
-    def text_decode(self, text):
-        if self.has_simple_content():
-            return self.content.decode(text, validation='skip')
+    def text_decode(self, text: str) -> OptionalAtomicValueType:
+        if isinstance(self.content, XsdSimpleType):
+            return cast(OptionalAtomicValueType, self.content.decode(text, 'skip'))
         else:
             return text
 
-    def decode(self, data, *args, **kwargs):
-        if hasattr(data, 'attrib') or self.is_simple():
-            return super(XsdComplexType, self).decode(data, *args, **kwargs)
-        elif self.has_simple_content():
-            return self.content.decode(data, *args, **kwargs)
+    def decode(self, obj: UnionElementType, str, bytes, *args: Any, **kwargs: Any) \
+            -> DecodeTypeAny:
+        if not isinstance(obj, (str, bytes)):
+            return super(XsdComplexType, self).decode(obj, *args, **kwargs)
+        elif isinstance(self.content, XsdSimpleType):
+            return self.content.decode(obj, *args, **kwargs)
         else:
-            raise XMLSchemaDecodeError(self, data, "cannot decode %r data with %r" % (data, self))
+            raise XMLSchemaDecodeError(
+                self, obj, str, "cannot decode %r data with %r" % (obj, self)
+            )
 
-    def iter_decode(self, elem, validation='lax', **kwargs):
+    def iter_decode(self, obj: UnionElementType, str, bytes,
+                    validation: str = 'lax', **kwargs: Any) -> IterDecodeTypeAny:
         """
-        Decode an Element instance. A dummy element is created for the type and it's
-        used for decode data. Typically used for decoding with xs:anyType when an XSD
-        element is not available.
+        Decodes an Element instance using a dummy XSD element. Typically used
+        for decoding with xs:anyType when an XSD element is not available.
+        Also decodes strings if the type has a simple content.
 
-        :param elem: the Element that has to be decoded.
+        :param obj: the XML data that has to be decoded.
         :param validation: the validation mode. Can be 'lax', 'strict' or 'skip'.
         :param kwargs: keyword arguments for the decoding process.
         :return: yields a decoded object, eventually preceded by a sequence of \
         validation or decoding errors.
         """
-        xsd_element = self.schema.create_element(elem.tag, parent=self, form='unqualified')
-        xsd_element.type = self
-        yield from xsd_element.iter_decode(elem, validation, **kwargs)
+        if not isinstance(obj, (str, bytes)):
+            xsd_element = self.schema.create_element(obj.tag, parent=self, form='unqualified')
+            xsd_element.type = self
+            yield from xsd_element.iter_decode(obj, validation, **kwargs)
+        elif isinstance(self.content, XsdSimpleType):
+            yield from self.content.iter_decode(obj, validation, **kwargs)
+        else:
+            raise XMLSchemaDecodeError(
+                self, obj, str, "cannot decode %r data with %r" % (obj, self)
+            )
 
-    def iter_encode(self, obj, validation='lax', **kwargs):
+    def iter_encode(self, obj: Any, validation: str = 'lax', **kwargs: Any) \
+            -> IterEncodeTypeElementType:
         """
         Encode XML data. A dummy element is created for the type and it's used for
         encode data. Typically used for encoding with xs:anyType when an XSD element
@@ -724,20 +788,25 @@
     _CONTENT_TAIL_TAGS = {XSD_ATTRIBUTE_GROUP, XSD_ATTRIBUTE, XSD_ANY_ATTRIBUTE, XSD_ASSERT}
 
     @property
-    def default_attributes(self):
+    def default_attributes(self) -> OptionalXsdAttributeGroup:
         if self.redefine is not None:
-            return self.schema.default_attributes
-
-        for child in self.schema.root:
-            if child.tag == XSD_OVERRIDE and self.elem in child:
-                schema = self.schema.includeschild.attrib'schemaLocation'
-                if schema.override is self.schema:
-                    return schema.default_attributes
+            default_attributes = self.schema.default_attributes
         else:
-            return self.schema.default_attributes
+            for child in self.schema.root:
+                if child.tag == XSD_OVERRIDE and self.elem in child:
+                    schema = self.schema.includeschild.attrib'schemaLocation'
+                    if schema.override is self.schema:
+                        default_attributes = schema.default_attributes
+                        break
+            else:
+                default_attributes = self.schema.default_attributes
+
+        if isinstance(default_attributes, str):
+            return None
+        return default_attributes
 
     @property
-    def default_open_content(self):
+    def default_open_content(self) -> OptionalXsdDefaultOpenContent:
         if self.parent is not None:
             return self.schema.default_open_content
 
@@ -749,7 +818,7 @@
         else:
             return self.schema.default_open_content
 
-    def _parse(self):
+    def _parse(self) -> None:
         super(Xsd11ComplexType, self)._parse()
 
         if self.base_type and self.base_type.base_type is self.any_simple_type and \
@@ -771,31 +840,33 @@
                 self.content.suffix = self.open_content.any_element
 
         # Add inheritable attributes
-        try:
+        if isinstance(self.base_type, XsdComplexType):
             for name, attr in self.base_type.attributes.items():
                 if attr.inheritable:
                     if name not in self.attributes:
                         self.attributesname = attr
                     elif not self.attributesname.inheritable:
                         self.parse_error("attribute %r must be inheritable")
-        except AttributeError:
-            pass
 
-        if 'defaultAttributesApply' in self.elem.attrib:
-            attr = self.elem.attrib'defaultAttributesApply'.strip()
-            self.default_attributes_apply = False if attr in {'false', '0'} else True
+        if 'defaultAttributesApply' not in self.elem.attrib:
+            self.default_attributes_apply = True
+        elif self.elem.attrib'defaultAttributesApply'.strip() in {'false', '0'}:
+            self.default_attributes_apply = False
         else:
             self.default_attributes_apply = True
 
         # Add default attributes
-        if self.default_attributes_apply and isinstance(self.default_attributes, XsdComponent):
-            if self.redefine is None and any(k in self.attributes for k in self.default_attributes):
-                self.parse_error(
-                    "at least a default attribute is already declared in the complex type"
-                )
+        if self.default_attributes_apply and \
+                isinstance(self.default_attributes, XsdAttributeGroup):
+            if self.redefine is None:
+                for k in self.default_attributes:
+                    if k in self.attributes:
+                        self.parse_error(f"default attribute {k!r} is already "
+                                         f"declared in the complex type")
+
             self.attributes.update((k, v) for k, v in self.default_attributes.items())
 
-    def _parse_complex_content_extension(self, elem, base_type):
+    def _parse_complex_content_extension(self, elem: ElementType, base_type: Any) -> None:
         # Complex content extension with simple base is forbidden XSD 1.1.
         # For the detailed rule refer to XSD 1.1 documentation:
         #   https://www.w3.org/TR/2012/REC-xmlschema11-1-20120405/#sec-cos-ct-extends
@@ -807,6 +878,7 @@
             self.parse_error("the base type is not derivable by extension")
 
         # Parse openContent
+        group_elem: Any
         for group_elem in elem:
             if group_elem.tag == XSD_ANNOTATION or callable(group_elem.tag):
                 continue
@@ -814,7 +886,8 @@
                 break
             self.open_content = XsdOpenContent(group_elem, self.schema, self)
             try:
-                self.open_content.any_element.union(base_type.open_content.any_element)
+                any_element = base_type.open_content.any_element
+                self.open_content.any_element.union(any_element)
             except AttributeError:
                 pass
         else:
@@ -824,7 +897,7 @@
             if not base_type.mixed:
                 # Empty element-only model extension: don't create a nested sequence group.
                 if group_elem is not None and group_elem.tag in XSD_MODEL_GROUP_TAGS:
-                    self.content = self.schema.BUILDERS.group_class(
+                    self.content = self.schema.xsd_group_class(
                         group_elem, self.schema, self
                     )
                 elif base_type.content.max_occurs is None:
@@ -848,7 +921,7 @@
                 self.content.append(self.schema.create_empty_content_group(self.content))
 
                 if group_elem is not None and group_elem.tag in XSD_MODEL_GROUP_TAGS:
-                    group = self.schema.BUILDERS.group_class(
+                    group = self.schema.xsd_group_class(
                         group_elem, self.schema, self.content
                     )
                     if not self.mixed:
@@ -864,7 +937,7 @@
                 self.content.elem.append(group.elem)
 
         elif group_elem is not None and group_elem.tag in XSD_MODEL_GROUP_TAGS:
-            group = self.schema.BUILDERS.group_class(group_elem, self.schema, self)
+            group = self.schema.xsd_group_class(group_elem, self.schema, self)
 
             if base_type.content.model != 'all':
                 content = self.schema.create_empty_content_group(self)
@@ -917,35 +990,36 @@
                     "extended type has a mixed content but the base is element-only", elem
                 )
 
-        if not self.open_content:
+        if self.open_content is None:
             default_open_content = self.default_open_content
-            if default_open_content and \
+            if default_open_content is not None and \
                     (self.mixed or self.content or default_open_content.applies_to_empty):
                 self.open_content = default_open_content
-            elif base_type.open_content:
+            elif base_type.open_content is not None:
                 self.open_content = base_type.open_content
 
-        if base_type.open_content and self.open_content is not base_type.open_content:
+        if base_type.open_content is not None and \
+                self.open_content is not None and \
+                self.open_content is not base_type.open_content:
+
             if self.open_content.mode == 'none':
                 self.open_content = base_type.open_content
             elif not base_type.open_content.is_restriction(self.open_content):
                 msg = "{!r} is not an extension of the base type {!r}"
                 self.parse_error(msg.format(self.open_content, base_type.open_content))
 
-        self._parse_content_tail(elem, derivation='extension', base_attributes=base_type.attributes)
+        self._parse_content_tail(elem, derivation='extension',
+                                 base_attributes=base_type.attributes)
 
-    def _parse_content_tail(self, elem, **kwargs):
-        self.attributes = self.schema.BUILDERS.attribute_group_class(
+    def _parse_content_tail(self, elem: ElementType, **kwargs: Any) -> None:
+        self.attributes = self.schema.xsd_attribute_group_class(
             elem, self.schema, self, **kwargs
         )
 
-        self.assertions = 
-            XsdAssert(e, self.schema, self, self) for e in elem if e.tag == XSD_ASSERT
-        
-        try:
+        self.assertions = XsdAssert(e, self.schema, self, self)
+                           for e in elem if e.tag == XSD_ASSERT
+        if isinstance(self.base_type, XsdComplexType):
             self.assertions.extend(
                 XsdAssert(assertion.elem, self.schema, self, self)
                 for assertion in self.base_type.assertions
             )
-        except AttributeError:
-            pass

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/validators/elements.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/validators/elements.py Changed

@@ -12,32 +12,47 @@
 """
 import warnings
 from decimal import Decimal
-from typing import Optional
-from elementpath import XPath2Parser, ElementPathError, XPathContext
+from types import GeneratorType
+from typing import TYPE_CHECKING, cast, Any, Dict, Iterator, List, Optional, Tuple, Type, Union
+from elementpath import XPath2Parser, ElementPathError, XPathContext, XPathToken
 from elementpath.datatypes import AbstractDateTime, Duration, AbstractBinary
 
 from ..exceptions import XMLSchemaTypeError, XMLSchemaValueError
 from ..names import XSD_COMPLEX_TYPE, XSD_SIMPLE_TYPE, XSD_ALTERNATIVE, \
     XSD_ELEMENT, XSD_ANY_TYPE, XSD_UNIQUE, XSD_KEY, XSD_KEYREF, XSI_NIL, \
     XSI_TYPE, XSD_ERROR, XSD_NOTATION_TYPE
-from ..etree import etree_element
+from ..etree import ElementData, etree_element
+from ..aliases import ElementType, SchemaType, BaseXsdType, SchemaElementType, \
+    ModelParticleType, ComponentClassType, AtomicValueType, DecodeType, \
+    IterDecodeType, IterEncodeType
 from ..helpers import get_qname, get_namespace, etree_iter_location_hints, \
     raw_xml_encode, strictly_equal
 from .. import dataobjects
-from ..converters import ElementData, XMLSchemaConverter
-from ..xpath import XMLSchemaProxy, ElementPathMixin
+from ..converters import XMLSchemaConverter
+from ..xpath import XMLSchemaProtocol, ElementProtocol, XMLSchemaProxy, \
+    ElementPathMixin, XPathElement
 
 from .exceptions import XMLSchemaValidationError, XMLSchemaTypeTableWarning
 from .helpers import get_xsd_derivation_attribute
 from .xsdbase import XSD_TYPE_DERIVATIONS, XSD_ELEMENT_DERIVATIONS, \
-    XsdComponent, XsdType, ValidationMixin
-from .particles import ParticleMixin
-from .models import OccursCounter
-from .identities import XsdKeyref
+    XsdComponent, ValidationMixin
+from .particles import ParticleMixin, OccursCalculator
+from .identities import IdentityXPathContext, XsdIdentity, XsdKey, XsdUnique, \
+    XsdKeyref, IdentityCounter, IdentityCounterType
+from .simple_types import XsdSimpleType
+from .attributes import XsdAttribute
 from .wildcards import XsdAnyElement
 
+if TYPE_CHECKING:
+    from .attributes import XsdAttributeGroup
+    from .groups import XsdGroup
 
-class XsdElement(XsdComponent, ValidationMixin, ParticleMixin, ElementPathMixin):
+DataBindingType = Type'dataobjects.DataElement'
+
+
+class XsdElement(XsdComponent, ParticleMixin,
+                 ElementPathMixinSchemaElementType,
+                 ValidationMixinElementType, Any):
     """
     Class for XSD 1.0 *element* declarations.
 
@@ -63,50 +78,69 @@
           Content: (annotation?, ((simpleType | complexType)?, (unique | key | keyref)*))
         </element>
     """
+    name: str
+    local_name: str
+    qualified_name: str
+    prefixed_name: str
+
+    parent: Optional'XsdGroup'
+    ref: Optional'XsdElement'
+    attributes: 'XsdAttributeGroup'
+
+    type: BaseXsdType
     abstract = False
     nillable = False
     qualified = False
-    form = None
-    default = None
-    fixed = None
-    substitution_group = None
+    form: Optionalstr = None
+    default: Optionalstr = None
+    fixed: Optionalstr = None
+    substitution_group: Optionalstr = None
 
-    alternatives = ()
-    inheritable = ()
+    identities: Dictstr, XsdIdentity
+    alternatives = ()  # type: UnionTuple(), ListXsdAlternative
+    inheritable = ()  # type: UnionTuple(), Dictstr, XsdAttribute
 
     _ADMITTED_TAGS = {XSD_ELEMENT}
-    _block = None
-    _final = None
+    _block: Optionalstr = None
+    _final: Optionalstr = None
     _head_type = None
+    _build = True
 
-    binding = None
+    binding: OptionalDataBindingType = None
 
-    def __init__(self, elem, schema, parent):
+    def __init__(self, elem: etree_element,
+                 schema: SchemaType,
+                 parent: OptionalXsdComponent = None,
+                 build: bool = True) -> None:
+
+        if not build:
+            self._build = False
         super(XsdElement, self).__init__(elem, schema, parent)
-        ElementPathMixin.__init__(self)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return '%s(%s=%r, occurs=%r)' % (
             self.__class__.__name__,
             'name' if self.ref is None else 'ref',
             self.prefixed_name,
-            self.occurs
+            list(self.occurs)
         )
 
-    def __setattr__(self, name: str, value: OptionalXsdType):
+    def __setattr__(self, name: str, value: Any) -> None:
         if name == "type":
-            try:
-                self.attributes = value.attributes
-            except AttributeError:
+            if isinstance(value, XsdSimpleType):
                 self.attributes = self.schema.create_empty_attribute_group(self)
+            else:
+                self.attributes = value.attributes
         super(XsdElement, self).__setattr__(name, value)
 
-    def __iter__(self):
+    def __iter__(self) -> IteratorSchemaElementType:
         if self.type.has_complex_content():
-            yield from self.type.content.iter_elements()
+            yield from self.type.content.iter_elements()  # type: ignoreunion-attr
+
+    def _parse(self) -> None:
+        if not self._build:
+            return
 
-    def _parse(self):
-        XsdComponent._parse(self)
         self._parse_particle(self.elem)
         self._parse_attributes()
 
@@ -117,7 +151,7 @@
             if self.parent is None and 'substitutionGroup' in self.elem.attrib:
                 self._parse_substitution_group(self.elem.attrib'substitutionGroup')
 
-    def _parse_attributes(self):
+    def _parse_attributes(self) -> None:
         attrib = self.elem.attrib
         if self._parse_reference():
             try:
@@ -196,7 +230,7 @@
                     msg = "attribute {!r} not allowed in a local element declaration"
                     self.parse_error(msg.format(attr_name))
 
-    def _parse_type(self):
+    def _parse_type(self) -> None:
         type_name = self.elem.get('type')
         if type_name is not None:
             try:
@@ -223,13 +257,13 @@
             if child is None:
                 self.type = self.any_type
             elif child.tag == XSD_COMPLEX_TYPE:
-                self.type = self.schema.BUILDERS.complex_type_class(child, self.schema, self)
+                self.type = self.schema.xsd_complex_type_class(child, self.schema, self)
             elif child.tag == XSD_SIMPLE_TYPE:
-                self.type = self.schema.BUILDERS.simple_type_factory(child, self.schema, self)
+                self.type = self.schema.simple_type_factory(child, self.schema, self)
             else:
                 self.type = self.any_type
 
-    def _parse_constraints(self):
+    def _parse_constraints(self) -> None:
         # Value constraints
         if 'default' in self.elem.attrib:
             self.default = self.elem.attrib'default'
@@ -256,13 +290,14 @@
 
         # Identity constraints
         self.identities = {}
+        constraint: UnionXsdKey, XsdUnique, XsdKeyref
         for child in self.elem:
             if child.tag == XSD_UNIQUE:
-                constraint = self.schema.BUILDERS.unique_class(child, self.schema, self)
+                constraint = self.schema.xsd_unique_class(child, self.schema, self)
             elif child.tag == XSD_KEY:
-                constraint = self.schema.BUILDERS.key_class(child, self.schema, self)
+                constraint = self.schema.xsd_key_class(child, self.schema, self)
             elif child.tag == XSD_KEYREF:
-                constraint = self.schema.BUILDERS.keyref_class(child, self.schema, self)
+                constraint = self.schema.xsd_keyref_class(child, self.schema, self)
             else:
                 # Invalid tags already caught by validation against the meta-schema
                 continue
@@ -274,14 +309,14 @@
                 continue
 
             try:
-                if child != self.maps.identitiesconstraint.name:
+                if child != self.maps.identitiesconstraint.name.elem:
                     self.parse_error("duplicated identity constraint %r:" % constraint.name, child)
             except KeyError:
                 self.maps.identitiesconstraint.name = constraint
             finally:
                 self.identitiesconstraint.name = constraint
 
-    def _parse_substitution_group(self, substitution_group):
+    def _parse_substitution_group(self, substitution_group: str) -> None:
         try:
             substitution_group_qname = self.schema.resolve_qname(substitution_group)
         except (KeyError, ValueError, RuntimeError) as err:
@@ -334,16 +369,26 @@
             self.substitution_group = substitution_group_qname
 
     @property
-    def xpath_proxy(self):
-        return XMLSchemaProxy(self.schema, self)
+    def xpath_proxy(self) -> XMLSchemaProxy:
+        return XMLSchemaProxy(
+            schema=cast(XMLSchemaProtocol, self.schema),
+            base_element=cast(ElementProtocol, self)
+        )
+
+    def build(self) -> None:
+        if self._build:
+            return
+        self._build = True
+        self._parse()
 
     @property
-    def built(self):
-        return (self.type.parent is None or self.type.built) and \
+    def built(self) -> bool:
+        return hasattr(self, 'type') and \
+            (self.type.parent is None or self.type.built) and \
             all(c.built for c in self.identities.values())
 
     @property
-    def validation_attempted(self):
+    def validation_attempted(self) -> str:
         if self.built:
             return 'full'
         elif self.type.validation_attempted == 'partial':
@@ -354,17 +399,17 @@
             return 'none'
 
     @property
-    def scope(self):
+    def scope(self) -> str:
         """The scope of the element declaration that can be 'global' or 'local'."""
         return 'global' if self.parent is None else 'local'
 
     @property
-    def value_constraint(self):
+    def value_constraint(self) -> Optionalstr:
         """The fixed or the default value if either is defined, `None` otherwise."""
         return self.fixed if self.fixed is not None else self.default
 
     @property
-    def final(self):
+    def final(self) -> str:
         if self.ref is not None:
             return self.ref.final
         elif self._final is not None:
@@ -372,14 +417,15 @@
         return self.schema.final_default
 
     @property
-    def block(self):
+    def block(self) -> str:
         if self.ref is not None:
             return self.ref.block
         elif self._block is not None:
             return self._block
         return self.schema.block_default
 
-    def get_binding(self, *bases, replace_existing=False, **attrs):
+    def get_binding(self, *bases: TypeAny, replace_existing: bool = False, **attrs: Any) \
+            -> DataBindingType:
         """
         Gets data object binding for XSD element, creating a new one if it doesn't exist.
 
@@ -387,33 +433,38 @@
         :param replace_existing: provide `True` to replace an existing binding class.
         :param attrs: attribute and method definitions for the binding class body.
         """
-        if self.binding is None or replace_existing:
+        if self.binding is None or not replace_existing:
             if not bases:
                 bases = (dataobjects.DataElement,)
             attrs'xsd_element' = self
             class_name = '{}Binding'.format(self.local_name.title().replace('_', ''))
-            self.binding = dataobjects.DataBindingMeta(class_name, bases, attrs)
-
+            self.binding = cast(DataBindingType,
+                                dataobjects.DataBindingMeta(class_name, bases, attrs))
         return self.binding
 
-    def get_attribute(self, name):
+    def get_attribute(self, name: str) -> OptionalXsdAttribute:
         if name0 != '{':
-            return self.type.attributesget_qname(self.type.target_namespace, name)
-        return self.type.attributesname
-
-    def get_type(self, elem, inherited=None):
+            name = get_qname(self.type.target_namespace, name)
+        if not isinstance(self.type, XsdSimpleType):
+            xsd_attribute = self.type.attributesname
+            assert isinstance(xsd_attribute, XsdAttribute)
+            return xsd_attribute
+        return None
+
+    def get_type(self, elem: UnionElementType, ElementData,
+                 inherited: OptionalDictstr, Any = None) -> BaseXsdType:
         return self._head_type or self.type
 
-    def get_attributes(self, xsd_type):
-        try:
+    def get_attributes(self, xsd_type: BaseXsdType) -> 'XsdAttributeGroup':
+        if not isinstance(xsd_type, XsdSimpleType):
             return xsd_type.attributes
-        except AttributeError:
-            if xsd_type is self.type:
-                return self.attributes
-            else:
-                return self.schema.create_empty_attribute_group(self)
+        elif xsd_type is self.type:
+            return self.attributes
+        else:
+            return self.schema.create_empty_attribute_group(self)
 
-    def get_path(self, ancestor=None, reverse=False):
+    def get_path(self, ancestor: OptionalXsdComponent = None,
+                 reverse: bool = False) -> Optionalstr:
         """
         Returns the XPath expression of the element. The path is relative to the schema instance
         in which the element is contained or is relative to a specific ancestor passed as argument.
@@ -423,33 +474,35 @@
         an ancestor of the element.
         :param reverse: if set to `True` returns the reverse path, from the element to ancestor.
         """
-        path = 
-        xsd_component = self
+        path: Liststr = 
+        xsd_component: OptionalXsdComponent = self
         while xsd_component is not None:
             if xsd_component is ancestor:
                 return '/'.join(reversed(path)) or '.'
-            elif hasattr(xsd_component, 'tag'):
+            elif isinstance(xsd_component, XsdElement):
                 path.append('..' if reverse else xsd_component.name)
             xsd_component = xsd_component.parent
         else:
             if ancestor is None:
                 return '/'.join(reversed(path)) or '.'
+            return None
+
+    def iter_components(self, xsd_classes: OptionalComponentClassType = None) \
+            -> IteratorXsdComponent:
 
-    def iter_components(self, xsd_classes=None):
         if xsd_classes is None:
             yield self
             yield from self.identities.values()
         else:
             if isinstance(self, xsd_classes):
                 yield self
-            for obj in self.identities.values():
-                if isinstance(obj, xsd_classes):
-                    yield obj
+            if issubclass(XsdIdentity, xsd_classes):
+                yield from self.identities.values()
 
         if self.ref is None and self.type.parent is not None:
             yield from self.type.iter_components(xsd_classes)
 
-    def iter_substitutes(self):
+    def iter_substitutes(self) -> Iterator'XsdElement':
         if self.parent is None or self.ref is not None:
             for xsd_element in self.maps.substitution_groups.get(self.name, ()):
                 if not xsd_element.abstract:
@@ -458,21 +511,22 @@
                     if not e.abstract:
                         yield e
 
-    def data_value(self, elem):
+    def data_value(self, elem: ElementType) -> OptionalAtomicValueType:
         """Returns the decoded data value of the provided element as XPath fn:data()."""
         text = elem.text
         if text is None:
             text = self.fixed if self.fixed is not None else self.default
             if text is None:
-                return
+                return None
         return self.type.text_decode(text)
 
-    def check_dynamic_context(self, elem, **kwargs):
+    def check_dynamic_context(self, elem: ElementType, **kwargs: Any) -> None:
         try:
             locations = kwargs'locations'
         except KeyError:
             return
 
+        schema: OptionalSchemaType
         for ns, url in etree_iter_location_hints(elem):
             if ns not in locations:
                 locationsns = url
@@ -483,9 +537,12 @@
             if ns == self.target_namespace:
                 schema = self.schema.include_schema(url, self.schema.base_url)
             else:
-                schema = self.schema.import_namespace(ns, url, self.schema.base_url)
+                schema = self.schema.import_schema(ns, url, self.schema.base_url)
 
-            if not schema.built:
+            if schema is None:
+                reason = f"missing dynamic loaded schema from {url}"
+                raise XMLSchemaValidationError(self, elem, reason)
+            elif not schema.built:
                 reason = "dynamic loaded schema change the assessment"
                 raise XMLSchemaValidationError(self, elem, reason)
 
@@ -501,7 +558,7 @@
             if ns not in locations:
                 locationsns = None
 
-    def start_identities(self, identities):
+    def start_identities(self, identities: DictXsdIdentity, IdentityCounter) -> None:
         """
         Start tracking of XSD element's identities.
 
@@ -513,7 +570,7 @@
             except KeyError:
                 identitiesconstraint = constraint.get_counter()
 
-    def stop_identities(self, identities):
+    def stop_identities(self, identities: DictXsdIdentity, IdentityCounter) -> None:
         """
         Stop tracking of XSD element's identities.
 
@@ -525,11 +582,12 @@
             except KeyError:
                 identitiesidentity = identity.get_counter(enabled=False)
 
-    def iter_decode(self, elem, validation='lax', **kwargs):
+    def iter_decode(self, obj: ElementType, validation: str = 'lax', **kwargs: Any) \
+            -> IterDecodeTypeAny:
         """
         Creates an iterator for decoding an Element instance.
 
-        :param elem: the Element that has to be decoded.
+        :param obj: the Element that has to be decoded.
         :param validation: the validation mode, can be 'lax', 'strict' or 'skip'.
         :param kwargs: keyword arguments for the decoding process.
         :return: yields a decoded object, eventually preceded by a sequence of \
@@ -537,7 +595,7 @@
         """
         if self.abstract:
             reason = "cannot use an abstract element for validation"
-            yield self.validation_error(validation, reason, elem, **kwargs)
+            yield self.validation_error(validation, reason, obj, **kwargs)
 
         try:
             namespaces = kwargs'namespaces'
@@ -561,105 +619,123 @@
         except KeyError:
             converter = kwargs'converter' = self.schema.get_converter(**kwargs)
         else:
-            if not isinstance(converter, XMLSchemaConverter) and converter is not None:
+            if converter is not None and not isinstance(converter, XMLSchemaConverter):
                 converter = kwargs'converter' = self.schema.get_converter(**kwargs)
 
         try:
             pass  # self.check_dynamic_context(elem, **kwargs) TODO: dynamic schema load
         except XMLSchemaValidationError as err:
-            yield self.validation_error(validation, err, elem, **kwargs)
+            yield self.validation_error(validation, err, obj, **kwargs)
 
         inherited = kwargs.get('inherited')
         value = content = attributes = None
         nilled = False
 
         # Get the instance effective type
-        xsd_type = self.get_type(elem, inherited)
-        if XSI_TYPE in elem.attrib:
-            type_name = elem.attribXSI_TYPE.strip()
+        xsd_type = self.get_type(obj, inherited)
+        if XSI_TYPE in obj.attrib:
+            type_name = obj.attribXSI_TYPE.strip()
             try:
                 xsd_type = self.maps.get_instance_type(type_name, xsd_type, namespaces)
             except (KeyError, TypeError) as err:
-                yield self.validation_error(validation, err, elem, **kwargs)
+                yield self.validation_error(validation, err, obj, **kwargs)
+            else:
+                if self.identities:
+                    xpath_element = XPathElement(self.name, xsd_type)
+                    for identity in self.identities.values():
+                        if isinstance(identity.elements, tuple):
+                            continue  # Skip unbuilt identities
+
+                        context = IdentityXPathContext(
+                            self.schema, item=xpath_element  # type: ignorearg-type
+                        )
+                        for e in identity.selector.token.select_results(context):
+                            if not isinstance(e, XsdElement):
+                                reason = "selector xpath expression can only select elements"
+                                yield self.validation_error(validation, reason, e, **kwargs)
+                            elif e not in identity.elements:
+                                identity.elementse = None
 
             if xsd_type.is_blocked(self):
                 reason = "usage of %r is blocked" % xsd_type
-                yield self.validation_error(validation, reason, elem, **kwargs)
+                yield self.validation_error(validation, reason, obj, **kwargs)
 
         if xsd_type.abstract:
-            yield self.validation_error(validation, "%r is abstract", elem, **kwargs)
+            yield self.validation_error(validation, "%r is abstract", obj, **kwargs)
         if xsd_type.is_complex() and self.xsd_version == '1.1':
             kwargs'id_list' =   # Track XSD 1.1 multiple xs:ID attributes/children
 
-        content_decoder = xsd_type.content if xsd_type.is_complex() else xsd_type
+        content_decoder = xsd_type if isinstance(xsd_type, XsdSimpleType) else xsd_type.content
 
         # Decode attributes
         attribute_group = self.get_attributes(xsd_type)
-        for result in attribute_group.iter_decode(elem.attrib, validation, **kwargs):
+        result: Any
+        for result in attribute_group.iter_decode(obj.attrib, validation, **kwargs):
             if isinstance(result, XMLSchemaValidationError):
-                yield self.validation_error(validation, result, elem, **kwargs)
+                yield self.validation_error(validation, result, obj, **kwargs)
             else:
                 attributes = result
 
-        if self.inheritable and any(name in self.inheritable for name in elem.attrib):
+        if self.inheritable and any(name in self.inheritable for name in obj.attrib):
             if inherited:
                 inherited = inherited.copy()
-                inherited.update((k, v) for k, v in elem.attrib.items() if k in self.inheritable)
+                inherited.update((k, v) for k, v in obj.attrib.items() if k in self.inheritable)
             else:
-                inherited = {k: v for k, v in elem.attrib.items() if k in self.inheritable}
+                inherited = {k: v for k, v in obj.attrib.items() if k in self.inheritable}
             kwargs'inherited' = inherited
 
         # Checks the xsi:nil attribute of the instance
-        if XSI_NIL in elem.attrib:
-            xsi_nil = elem.attribXSI_NIL.strip()
+        if XSI_NIL in obj.attrib:
+            xsi_nil = obj.attribXSI_NIL.strip()
             if not self.nillable:
                 reason = "element is not nillable."
-                yield self.validation_error(validation, reason, elem, **kwargs)
+                yield self.validation_error(validation, reason, obj, **kwargs)
             elif xsi_nil not in {'0', '1', 'false', 'true'}:
                 reason = "xsi:nil attribute must have a boolean value."
-                yield self.validation_error(validation, reason, elem, **kwargs)
+                yield self.validation_error(validation, reason, obj, **kwargs)
             elif xsi_nil in ('0', 'false'):
                 pass
             elif self.fixed is not None:
                 reason = "xsi:nil='true' but the element has a fixed value."
-                yield self.validation_error(validation, reason, elem, **kwargs)
-            elif elem.text is not None or len(elem):
+                yield self.validation_error(validation, reason, obj, **kwargs)
+            elif obj.text is not None or len(obj):
                 reason = "xsi:nil='true' but the element is not empty."
-                yield self.validation_error(validation, reason, elem, **kwargs)
+                yield self.validation_error(validation, reason, obj, **kwargs)
             else:
                 nilled = True
 
-        if xsd_type.is_empty() and elem.text and xsd_type.normalize(elem.text):
+        if xsd_type.is_empty() and obj.text and xsd_type.normalize(obj.text):
             reason = "character data is not allowed because content is empty"
-            yield self.validation_error(validation, reason, elem, **kwargs)
+            yield self.validation_error(validation, reason, obj, **kwargs)
 
         if nilled:
             pass
-        elif xsd_type.model_group is not None:
-            for assertion in xsd_type.assertions:
-                for error in assertion(elem, **kwargs):
-                    yield self.validation_error(validation, error, **kwargs)
+        elif not isinstance(content_decoder, XsdSimpleType):
+            if not isinstance(xsd_type, XsdSimpleType):
+                for assertion in xsd_type.assertions:
+                    for error in assertion(obj, **kwargs):
+                        yield self.validation_error(validation, error, **kwargs)
 
-            for result in content_decoder.iter_decode(elem, validation, **kwargs):
+            for result in content_decoder.iter_decode(obj, validation, **kwargs):
                 if isinstance(result, XMLSchemaValidationError):
-                    yield self.validation_error(validation, result, elem, **kwargs)
+                    yield self.validation_error(validation, result, obj, **kwargs)
                 else:
                     content = result
 
-            if len(content) == 1 and content00 == 1:
+            if content and len(content) == 1 and content00 == 1:
                 value, content = content01, None
 
             if self.fixed is not None and \
-                    (len(elem) > 0 or value is not None and self.fixed != value):
+                    (len(obj) > 0 or value is not None and self.fixed != value):
                 reason = "must have the fixed value %r" % self.fixed
-                yield self.validation_error(validation, reason, elem, **kwargs)
+                yield self.validation_error(validation, reason, obj, **kwargs)
 
         else:
-            if len(elem):
+            if len(obj):
                 reason = "a simple content element can't have child elements."
-                yield self.validation_error(validation, reason, elem, **kwargs)
+                yield self.validation_error(validation, reason, obj, **kwargs)
 
-            text = elem.text
+            text = obj.text
             if self.fixed is not None:
                 if text is None:
                     text = self.fixed
@@ -668,14 +744,14 @@
                 elif not strictly_equal(xsd_type.text_decode(text),
                                         xsd_type.text_decode(self.fixed)):
                     reason = "must have the fixed value %r" % self.fixed
-                    yield self.validation_error(validation, reason, elem, **kwargs)
+                    yield self.validation_error(validation, reason, obj, **kwargs)
 
             elif not text and self.default is not None and kwargs.get('use_defaults'):
                 text = self.default
 
-            if xsd_type.is_complex():
+            if not isinstance(xsd_type, XsdSimpleType):
                 for assertion in xsd_type.assertions:
-                    for error in assertion(elem, value=text, **kwargs):
+                    for error in assertion(obj, value=text, **kwargs):
                         yield self.validation_error(validation, error, **kwargs)
 
                 if text and content_decoder.is_list():
@@ -695,19 +771,21 @@
             if text is None:
                 for result in content_decoder.iter_decode('', validation, **kwargs):
                     if isinstance(result, XMLSchemaValidationError):
-                        yield self.validation_error(validation, result, elem, **kwargs)
+                        yield self.validation_error(validation, result, obj, **kwargs)
                         if 'filler' in kwargs:
                             value = kwargs'filler'(self)
             else:
                 for result in content_decoder.iter_decode(text, validation, **kwargs):
                     if isinstance(result, XMLSchemaValidationError):
-                        yield self.validation_error(validation, result, elem, **kwargs)
+                        yield self.validation_error(validation, result, obj, **kwargs)
                     elif result is None and 'filler' in kwargs:
                         value = kwargs'filler'(self)
                     else:
                         value = result
 
-            if isinstance(value, (int, float, list)) or value is None:
+            if 'value_hook' in kwargs:
+                value = kwargs'value_hook'(value, xsd_type)
+            elif isinstance(value, (int, float, list)) or value is None:
                 pass
             elif isinstance(value, str):
                 if value.startswith('{') and xsd_type.is_qname():
@@ -719,23 +797,23 @@
                     pass
             elif isinstance(value, (AbstractDateTime, Duration)):
                 if not kwargs.get('datetime_types'):
-                    value = elem.text
+                    value = str(value) if text is None else text.strip()
             elif isinstance(value, AbstractBinary):
                 if not kwargs.get('binary_types'):
-                    value = elem.text
+                    value = str(value)
 
         if converter is not None:
-            element_data = ElementData(elem.tag, value, content, attributes)
+            element_data = ElementData(obj.tag, value, content, attributes)
             yield converter.element_decode(element_data, self, xsd_type, level)
         elif not level:
-            yield ElementData(elem.tag, value, None, attributes)
+            yield ElementData(obj.tag, value, None, attributes)
 
         if content is not None:
             del content
 
         # Collects fields values for identities that refer to this element.
         for identity, counter in identities.items():
-            if not counter.enabled:
+            if not counter.enabled or not identity.elements:
                 continue
             elif self in identity.elements:
                 xsd_element = self
@@ -745,27 +823,40 @@
                 continue
 
             try:
+                xsd_fields: OptionalIdentityCounterType
                 if xsd_type is self.type:
                     xsd_fields = identity.elementsxsd_element
                     if xsd_fields is None:
                         xsd_fields = identity.get_fields(xsd_element)
                         identity.elementsxsd_element = xsd_fields
                 else:
-                    xsd_element = self.copy()
+                    xsd_element = cast(XsdElement, self.copy())
                     xsd_element.type = xsd_type
                     xsd_fields = identity.get_fields(xsd_element)
 
                 if all(x is None for x in xsd_fields):
                     continue
-                fields = identity.get_fields(elem, namespaces, decoders=xsd_fields)
+                decoders = cast(TupleXsdAttribute, ..., xsd_fields)
+                fields = identity.get_fields(obj, namespaces, decoders=decoders)
             except (XMLSchemaValueError, XMLSchemaTypeError) as err:
-                yield self.validation_error(validation, err, elem, **kwargs)
+                yield self.validation_error(validation, err, obj, **kwargs)
             else:
                 if any(x is not None for x in fields) or nilled:
                     try:
                         counter.increase(fields)
                     except ValueError as err:
-                        yield self.validation_error(validation, err, elem, **kwargs)
+                        yield self.validation_error(validation, err, obj, **kwargs)
+
+        # Apply non XSD optional validations
+        if 'extra_validator' in kwargs:
+            try:
+                result = kwargs'extra_validator'(obj, self)
+            except XMLSchemaValidationError as err:
+                yield self.validation_error(validation, err, obj, **kwargs)
+            else:
+                if isinstance(result, GeneratorType):
+                    for error in result:
+                        yield self.validation_error(validation, error, obj, **kwargs)
 
         # Disable collect for out of scope identities and check key references
         if 'max_depth' not in kwargs:
@@ -773,12 +864,30 @@
                 counter = identitiesidentity
                 counter.enabled = False
                 if isinstance(identity, XsdKeyref):
-                    for err in counter.iter_errors(identities):
-                        yield self.validation_error(validation, err, elem, **kwargs)
+                    for error in counter.iter_errors(identities):
+                        yield self.validation_error(validation, error, obj, **kwargs)
         elif level:
             self.stop_identities(identities)
 
-    def iter_encode(self, obj, validation='lax', **kwargs):
+    def to_objects(self, obj: ElementType, with_bindings: bool = False, **kwargs: Any) \
+            -> DecodeType'dataobjects.DataElement':
+        """
+        Decodes XML data to Python data objects.
+
+        :param obj: the XML data source.
+        :param with_bindings: if `True` is provided the decoding is done using \
+        :class:`DataBindingConverter` that used XML data binding classes. For \
+        default the objects are instances of :class:`DataElement` and uses the \
+        :class:`DataElementConverter`.
+        :param kwargs: other optional keyword arguments for the method \
+        :func:`iter_decode`, except the argument *converter*.
+        """
+        if with_bindings:
+            return self.decode(obj, converter=dataobjects.DataBindingConverter, **kwargs)
+        return self.decode(obj, converter=dataobjects.DataElementConverter, **kwargs)
+
+    def iter_encode(self, obj: Any, validation: str = 'lax', **kwargs: Any) \
+            -> IterEncodeTypeElementType:
         """
         Creates an iterator for encoding data to an Element.
 
@@ -788,7 +897,7 @@
         :return: yields an Element, eventually preceded by a sequence of \
         validation or encoding errors.
         """
-        errors = 
+        errors: ListUnionstr, Exception = 
 
         try:
             converter = kwargs'converter'
@@ -826,7 +935,7 @@
                 errors.append(err)
             else:
                 default_namespace = converter.get('')
-                if default_namespace and xsd_type.attributes:
+                if default_namespace and not isinstance(xsd_type, XsdSimpleType):
                     # Adjust attributes mapped into default namespace
 
                     ns_part = '{%s}' % default_namespace
@@ -842,6 +951,7 @@
                             del element_data.attributesk
 
         attribute_group = self.get_attributes(xsd_type)
+        result: Any
         for result in attribute_group.iter_encode(element_data.attributes, validation, **kwargs):
             if isinstance(result, XMLSchemaValidationError):
                 errors.append(result)
@@ -867,7 +977,7 @@
                 yield elem
                 return
 
-        if xsd_type.is_simple():
+        if isinstance(xsd_type, XsdSimpleType):
             if element_data.content:
                 errors.append("a simpleType element can't has child elements.")
 
@@ -912,8 +1022,11 @@
         yield elem
         del element_data
 
-    def is_matching(self, name, default_namespace=None, group=None):
-        if default_namespace and name0 != '{':
+    def is_matching(self, name: Optionalstr, default_namespace: Optionalstr = None,
+                    group: Optional'XsdGroup' = None, **kwargs: Any) -> bool:
+        if not name:
+            return False
+        elif default_namespace and name0 != '{':
             qname = '{%s}%s' % (default_namespace, name)
             if name == self.name or qname == self.name:
                 return True
@@ -923,8 +1036,11 @@
         else:
             return any(name == e.name for e in self.iter_substitutes())
 
-    def match(self, name, default_namespace=None, **kwargs):
-        if default_namespace and name0 != '{':
+    def match(self, name: Optionalstr, default_namespace: Optionalstr = None,
+              **kwargs: Any) -> Optional'XsdElement':
+        if not name:
+            return None
+        elif default_namespace and name0 != '{':
             qname = '{%s}%s' % (default_namespace, name)
             if name == self.name or qname == self.name:
                 return self
@@ -939,8 +1055,11 @@
             for xsd_element in self.iter_substitutes():
                 if name == xsd_element.name:
                     return xsd_element
+        return None
+
+    def is_restriction(self, other: ModelParticleType, check_occurs: bool = True) -> bool:
+        e: ModelParticleType
 
-    def is_restriction(self, other, check_occurs=True):
         if isinstance(other, XsdAnyElement):
             if self.min_occurs == self.max_occurs == 0:
                 return True
@@ -988,17 +1107,17 @@
                 return False
 
             check_group_items_occurs = self.xsd_version == '1.0'
-            counter = OccursCounter()
+            total_occurs = OccursCalculator()
             for e in other.iter_model():
                 if not isinstance(e, (XsdElement, XsdAnyElement)):
                     return False
                 elif not self.is_restriction(e, check_group_items_occurs):
                     continue
-                counter += e
-                counter *= other
-                if self.has_occurs_restriction(counter):
+                total_occurs += e
+                total_occurs *= other
+                if self.has_occurs_restriction(total_occurs):
                     return True
-                counter.reset()
+                total_occurs.reset()
             return False
         else:
             match_restriction = False
@@ -1012,7 +1131,7 @@
                     return False
             return True
 
-    def is_overlap(self, other):
+    def is_overlap(self, other: SchemaElementType) -> bool:
         if isinstance(other, XsdElement):
             if self.name == other.name:
                 return True
@@ -1026,7 +1145,7 @@
                     return True
         return False
 
-    def is_consistent(self, other):
+    def is_consistent(self, other: SchemaElementType, strict: bool = True) -> bool:
         """
         Element Declarations Consistent check between two element particles.
 
@@ -1036,18 +1155,17 @@
         """
         return self.name != other.name or self.type is other.type
 
-    def is_single(self):
-        try:
-            if self.max_occurs != 1:
-                return False
-            elif self.parent.max_occurs == 1:
-                return True
-            else:
-                return self.parent.model != 'choice' and len(self.parent) > 1
-        except AttributeError:
+    def is_single(self) -> bool:
+        if self.parent is None:
+            return True
+        elif self.max_occurs != 1:
+            return False
+        elif self.parent.max_occurs == 1:
             return True
+        else:
+            return self.parent.model != 'choice' and len(self.parent) > 1
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         return self.fixed == '' or self.type.is_empty()
 
 
@@ -1076,10 +1194,12 @@
           (unique | key | keyref)*))
         </element>
     """
-    _target_namespace = None
+    _target_namespace: Optionalstr = None
+
+    def _parse(self) -> None:
+        if not self._build:
+            return
 
-    def _parse(self):
-        XsdComponent._parse(self)
         self._parse_particle(self.elem)
         self._parse_attributes()
 
@@ -1095,9 +1215,13 @@
         self._parse_target_namespace()
 
         if any(v.inheritable for v in self.attributes.values()):
-            self.inheritable = {k: v for k, v in self.attributes.items() if v.inheritable}
+            self.inheritable = {}
+            for k, v in self.attributes.items():
+                if k is not None and isinstance(v, XsdAttribute):
+                    if v.inheritable:
+                        self.inheritablek = v
 
-    def _parse_alternatives(self):
+    def _parse_alternatives(self) -> None:
         alternatives = 
         has_test = True
         for child in self.elem:
@@ -1111,13 +1235,13 @@
             self.alternatives = alternatives
 
     @property
-    def built(self):
+    def built(self) -> bool:
         return (self.type.parent is None or self.type.built) and \
             all(c.built for c in self.identities.values()) and \
             all(a.built for a in self.alternatives)
 
     @property
-    def target_namespace(self):
+    def target_namespace(self) -> str:
         if self._target_namespace is not None:
             return self._target_namespace
         elif self.ref is not None:
@@ -1125,13 +1249,14 @@
         else:
             return self.schema.target_namespace
 
-    def iter_components(self, xsd_classes=None):
+    def iter_components(self, xsd_classes: ComponentClassType = None) -> IteratorXsdComponent:
         if xsd_classes is None:
             yield self
             yield from self.identities.values()
         else:
             if isinstance(self, xsd_classes):
                 yield self
+
             for obj in self.identities.values():
                 if isinstance(obj, xsd_classes):
                     yield obj
@@ -1142,19 +1267,25 @@
         if self.ref is None and self.type.parent is not None:
             yield from self.type.iter_components(xsd_classes)
 
-    def iter_substitutes(self):
+    def iter_substitutes(self) -> IteratorXsdElement:
         if self.parent is None or self.ref is not None:
             for xsd_element in self.maps.substitution_groups.get(self.name, ()):
                 yield xsd_element
                 yield from xsd_element.iter_substitutes()
 
-    def get_type(self, elem, inherited=None):
+    def get_type(self, elem: UnionElementType, ElementData,
+                 inherited: OptionalDictstr, Any = None) -> BaseXsdType:
         if not self.alternatives:
             return self._head_type or self.type
 
         if isinstance(elem, ElementData):
             if elem.attributes:
-                attrib = {k: raw_xml_encode(v) for k, v in elem.attributes.items()}
+                attrib: Dictstr, str = {}
+                for k, v in elem.attributes.items():
+                    value = raw_xml_encode(v)
+                    if value is not None:
+                        attribk = value
+
                 elem = etree_element(elem.tag, attrib=attrib)
             else:
                 elem = etree_element(elem.tag)
@@ -1163,17 +1294,19 @@
             dummy = etree_element('_dummy_element', attrib=inherited)
             dummy.attrib.update(elem.attrib)
 
-            for alt in filter(lambda x: x.type is not None, self.alternatives):
-                if alt.token is None or alt.test(elem) or alt.test(dummy):
-                    return alt.type
+            for alt in self.alternatives:
+                if alt.type is not None:
+                    if alt.token is None or alt.test(elem) or alt.test(dummy):
+                        return alt.type
         else:
-            for alt in filter(lambda x: x.type is not None, self.alternatives):
-                if alt.token is None or alt.test(elem):
-                    return alt.type
+            for alt in self.alternatives:
+                if alt.type is not None:
+                    if alt.token is None or alt.test(elem):
+                        return alt.type
 
         return self._head_type or self.type
 
-    def is_overlap(self, other):
+    def is_overlap(self, other: SchemaElementType) -> bool:
         if isinstance(other, XsdElement):
             if self.name == other.name:
                 return True
@@ -1192,14 +1325,15 @@
                     return True
         return False
 
-    def is_consistent(self, other, strict=True):
+    def is_consistent(self, other: SchemaElementType, strict: bool = True) -> bool:
         if isinstance(other, XsdAnyElement):
             if other.process_contents == 'skip':
                 return True
             xsd_element = other.match(self.name, self.default_namespace, resolve=True)
             return xsd_element is None or self.is_consistent(xsd_element, strict=False)
 
-        e1, e2 = self, other
+        e1: XsdElement = self
+        e2 = other
         if self.name != other.name:
             for e1 in self.iter_substitutes():
                 if e1.name == other.name:
@@ -1236,29 +1370,31 @@
           Content: (annotation?, (simpleType | complexType)?)
         </alternative>
     """
-    type = None
-    path = None
-    token = None
+    parent: XsdElement
+    type: BaseXsdType
+    path: Optionalstr = None
+    token: OptionalXPathToken = None
     _ADMITTED_TAGS = {XSD_ALTERNATIVE}
 
-    def __init__(self, elem, schema, parent):
+    def __init__(self, elem: ElementType, schema: SchemaType, parent: XsdElement) -> None:
         super(XsdAlternative, self).__init__(elem, schema, parent)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return '%s(type=%r, test=%r)' % (
             self.__class__.__name__, self.elem.get('type'), self.elem.get('test')
         )
 
-    def __eq__(self, other):
-        return self.path == other.path and self.type is other.type and \
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, XsdAlternative) and \
+            self.path == other.path and self.type is other.type and \
             self.xpath_default_namespace == other.xpath_default_namespace
 
-    def __ne__(self, other):
-        return self.path != other.path or self.type is not other.type or \
+    def __ne__(self, other: object) -> bool:
+        return not isinstance(other, XsdAlternative) or \
+            self.path != other.path or self.type is not other.type or \
             self.xpath_default_namespace != other.xpath_default_namespace
 
-    def _parse(self):
-        XsdComponent._parse(self)
+    def _parse(self) -> None:
         attrib = self.elem.attrib
 
         if 'xpathDefaultNamespace' in attrib:
@@ -1266,7 +1402,9 @@
         else:
             self.xpath_default_namespace = self.schema.xpath_default_namespace
         parser = XPath2Parser(
-            self.namespaces, strict=False, default_namespace=self.xpath_default_namespace
+            namespaces=self.namespaces,
+            strict=False,
+            default_namespace=self.xpath_default_namespace
         )
 
         try:
@@ -1293,9 +1431,9 @@
                     self.parse_error("missing 'type' attribute")
                     self.type = self.any_type
                 elif child.tag == XSD_COMPLEX_TYPE:
-                    self.type = self.schema.BUILDERS.complex_type_class(child, self.schema, self)
+                    self.type = self.schema.xsd_complex_type_class(child, self.schema, self)
                 else:
-                    self.type = self.schema.BUILDERS.simple_type_factory(child, self.schema, self)
+                    self.type = self.schema.simple_type_factory(child, self.schema, self)
 
                 if not self.type.is_derived(self.parent.type):
                     msg = "declared type is not derived from {!r}"
@@ -1305,6 +1443,7 @@
                 self.type = self.maps.lookup_type(type_qname)
             except KeyError:
                 self.parse_error("unknown type %r" % attrib'type')
+                self.type = self.any_type
             else:
                 if self.type.name != XSD_ERROR and not self.type.is_derived(self.parent.type):
                     msg = "type {!r} is not derived from {!r}"
@@ -1316,21 +1455,32 @@
                                      "are mutually exclusive" % child.tag.split('}')-1)
 
     @property
-    def built(self):
+    def built(self) -> bool:
+        if not hasattr(self, 'type'):
+            return False
         return self.type.parent is None or self.type.built
 
     @property
-    def validation_attempted(self):
-        return 'full' if self.built else self.type.validation_attempted
+    def validation_attempted(self) -> str:
+        if self.built:
+            return 'full'
+        elif not hasattr(self, 'type'):
+            return 'none'
+        else:
+            return self.type.validation_attempted
 
-    def iter_components(self, xsd_classes=None):
+    def iter_components(self, xsd_classes: ComponentClassType = None) -> IteratorXsdComponent:
         if xsd_classes is None or isinstance(self, xsd_classes):
             yield self
         if self.type is not None and self.type.parent is not None:
             yield from self.type.iter_components(xsd_classes)
 
-    def test(self, elem):
+    def test(self, elem: ElementType) -> bool:
+        if self.token is None:
+            return False
+
         try:
-            return self.token.boolean_value(list(self.token.select(context=XPathContext(elem))))
+            result = list(self.token.select(context=XPathContext(elem)))
+            return self.token.boolean_value(result)
         except (TypeError, ValueError):
             return False

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/validators/exceptions.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/validators/exceptions.py Changed

@@ -7,46 +7,55 @@
 #
 # @author Davide Brunato <brunato@sissa.it>
 #
+from typing import TYPE_CHECKING, Any, Optional, cast, Iterable, Union, Callable
 from ..exceptions import XMLSchemaException, XMLSchemaWarning, XMLSchemaValueError
 from ..etree import etree_tostring
+from ..aliases import ElementType, NamespacesType, SchemaElementType, ModelParticleType
 from ..helpers import get_prefixed_qname, etree_getpath, is_etree_element
 
+if TYPE_CHECKING:
+    from ..resources import XMLResource
+    from .xsdbase import XsdValidator
+    from .groups import XsdGroup
+
+ValidatorType = Union'XsdValidator', CallableAny, None
+
 
 class XMLSchemaValidatorError(XMLSchemaException):
     """
     Base class for XSD validator errors.
 
     :param validator: the XSD validator.
-    :type validator: XsdValidator or function
     :param message: the error message.
-    :type message: str or unicode
     :param elem: the element that contains the error.
-    :type elem: Element
     :param source: the XML resource that contains the error.
-    :type source: XMLResource
     :param namespaces: is an optional mapping from namespace prefix to URI.
-    :type namespaces: dict
-    :ivar path: the XPath of the element, calculated when the element is set \
-    or the XML resource is set.
     """
-    def __init__(self, validator, message, elem=None, source=None, namespaces=None):
-        self.path = None
+    _path: Optionalstr
+
+    def __init__(self, validator: ValidatorType,
+                 message: str,
+                 elem: OptionalElementType = None,
+                 source: Optional'XMLResource' = None,
+                 namespaces: OptionalNamespacesType = None) -> None:
+        self._path = None
         self.validator = validator
         self.message = message:-1 if message-1 in ('.', ':') else message
         self.namespaces = namespaces
         self.source = source
         self.elem = elem
 
-    def __str__(self):
+    def __str__(self) -> str:
         if self.elem is None:
             return self.message
 
         msg = '%s:\n' % self.message
-        elem_as_string = etree_tostring(self.elem, self.namespaces, '  ', 20)
+        elem_as_string = cast(str, etree_tostring(self.elem, self.namespaces, '  ', 20))
         msg.append("Schema:\n\n%s\n" % elem_as_string)
 
-        if self.path is not None:
-            msg.append("Path: %s\n" % self.path)
+        path = self.path
+        if path is not None:
+            msg.append("Path: %s\n" % path)
         if self.schema_url is not None:
             msg.append("Schema URL: %s\n" % self.schema_url)
             if self.origin_url not in (None, self.schema_url):
@@ -54,46 +63,75 @@
         return '\n'.join(msg)
 
     @property
-    def msg(self):
+    def msg(self) -> str:
         return self.__str__()
 
-    def __setattr__(self, name, value):
+    def __setattr__(self, name: str, value: Any) -> None:
         if name == 'elem' and value is not None:
             if not is_etree_element(value):
                 raise XMLSchemaValueError(
                     "'elem' attribute requires an Element, not %r." % type(value)
                 )
             if self.source is not None:
-                self.path = etree_getpath(value, self.root, self.namespaces,
-                                          relative=False, add_position=True)
+                self._path = etree_getpath(
+                    elem=value,
+                    root=self.source.root,
+                    namespaces=self.namespaces,
+                    relative=False,
+                    add_position=True
+                )
                 if self.source.is_lazy():
                     value = None  # Don't save the element of a lazy resource
         super(XMLSchemaValidatorError, self).__setattr__(name, value)
 
     @property
-    def sourceline(self):
+    def sourceline(self) -> Any:
+        """XML element *sourceline* if available (lxml Element) and *elem* is set."""
         return getattr(self.elem, 'sourceline', None)
 
     @property
-    def root(self):
+    def root(self) -> OptionalElementType:
+        """The XML resource root element if *source* is set."""
         try:
-            return self.source.root
+            return self.source.root  # type: ignoreunion-attr
         except AttributeError:
-            return
+            return None
 
     @property
-    def schema_url(self):
+    def schema_url(self) -> Optionalstr:
+        """The schema URL, if available and the *validator* is an XSD component."""
+        url: Optionalstr
         try:
-            return self.validator.schema.source.url
+            url = self.validator.schema.source.url  # type: ignoreunion-attr
         except AttributeError:
-            return
+            return None
+        else:
+            return url
 
     @property
-    def origin_url(self):
+    def origin_url(self) -> Optionalstr:
+        """The origin schema URL, if available and the *validator* is an XSD component."""
+        url: Optionalstr
         try:
-            return self.validator.maps.validator.source.url
+            url = self.validator.maps.validator.source.url  # type: ignoreunion-attr
         except AttributeError:
-            return
+            return None
+        else:
+            return url
+
+    @property
+    def path(self) -> Optionalstr:
+        """The XPath of the element, if it's not `None` and the XML resource is set."""
+        if self.elem is None or self.source is None:
+            return self._path
+
+        return etree_getpath(
+            elem=self.elem,
+            root=self.source.root,
+            namespaces=self.namespaces,
+            relative=False,
+            add_position=True
+        )
 
 
 class XMLSchemaNotBuiltError(XMLSchemaValidatorError, RuntimeError):
@@ -101,11 +139,9 @@
     Raised when there is an improper usage attempt of a not built XSD validator.
 
     :param validator: the XSD validator.
-    :type validator: XsdValidator
     :param message: the error message.
-    :type message: str or unicode
     """
-    def __init__(self, validator, message):
+    def __init__(self, validator: 'XsdValidator', message: str) -> None:
         super(XMLSchemaNotBuiltError, self).__init__(
             validator=validator,
             message=message,
@@ -115,18 +151,16 @@
         )
 
 
-class XMLSchemaParseError(XMLSchemaValidatorError, SyntaxError):
+class XMLSchemaParseError(XMLSchemaValidatorError, SyntaxError):  # type: ignoremisc
     """
     Raised when an error is found during the building of an XSD validator.
 
     :param validator: the XSD validator.
-    :type validator: XsdValidator or function
     :param message: the error message.
-    :type message: str or unicode
     :param elem: the element that contains the error.
-    :type elem: Element
     """
-    def __init__(self, validator, message, elem=None):
+    def __init__(self, validator: 'XsdValidator', message: str,
+                 elem: OptionalElementType = None) -> None:
         super(XMLSchemaParseError, self).__init__(
             validator=validator,
             message=message,
@@ -141,11 +175,9 @@
     Raised when a model error is found during the checking of a model group.
 
     :param group: the XSD model group.
-    :type group: XsdGroup
     :param message: the error message.
-    :type message: str or unicode
     """
-    def __init__(self, group, message):
+    def __init__(self, group: 'XsdGroup', message: str) -> None:
         super(XMLSchemaModelError, self).__init__(
             validator=group,
             message=message,
@@ -157,7 +189,7 @@
 
 class XMLSchemaModelDepthError(XMLSchemaModelError):
     """Raised when recursion depth is exceeded while iterating a model group."""
-    def __init__(self, group):
+    def __init__(self, group: 'XsdGroup') -> None:
         msg = "maximum model recursion depth exceeded while iterating {!r}".format(group)
         super(XMLSchemaModelDepthError, self).__init__(group, message=msg)
 
@@ -170,17 +202,17 @@
     containing object representation and a reason.
 
     :param validator: the XSD validator.
-    :type validator: XsdValidator or function
     :param obj: the not validated XML data.
-    :type obj: Element or tuple or str or list or int or float or bool
     :param reason: the detailed reason of failed validation.
-    :type reason: str or unicode
     :param source: the XML resource that contains the error.
-    :type source: XMLResource
     :param namespaces: is an optional mapping from namespace prefix to URI.
-    :type namespaces: dict
     """
-    def __init__(self, validator, obj, reason=None, source=None, namespaces=None):
+    def __init__(self,
+                 validator: ValidatorType,
+                 obj: Any,
+                 reason: Optionalstr = None,
+                 source: Optional'XMLResource' = None,
+                 namespaces: OptionalNamespacesType = None) -> None:
         if not isinstance(obj, str):
             _obj = obj
         else:
@@ -196,29 +228,37 @@
         self.obj = obj
         self.reason = reason
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return '%s(reason=%r)' % (self.__class__.__name__, self.reason)
 
-    def __str__(self):
+    def __str__(self) -> str:
         msg = '%s:\n' % self.message
+
         if self.reason is not None:
             msg.append('Reason: %s\n' % self.reason)
+
         if hasattr(self.validator, 'tostring'):
-            msg.append("Schema:\n\n%s\n" % self.validator.tostring('  ', 20))
-        if is_etree_element(self.elem):
+            chunk = self.validator.tostring('  ', 20)  # type: ignoreunion-attr
+            msg.append("Schema:\n\n%s\n" % chunk)
+
+        if self.elem is not None and is_etree_element(self.elem):
             try:
-                elem_as_string = etree_tostring(self.elem, self.namespaces, '  ', 20)
+                elem_as_string = cast(str, etree_tostring(self.elem, self.namespaces, '  ', 20))
             except (ValueError, TypeError):        # pragma: no cover
                 elem_as_string = repr(self.elem)   # pragma: no cover
 
             if hasattr(self.elem, 'sourceline'):
-                msg.append("Instance (line %r):\n\n%s\n" % (self.elem.sourceline, elem_as_string))
+                line = getattr(self.elem, 'sourceline')
+                msg.append("Instance (line %r):\n\n%s\n" % (line, elem_as_string))
             else:
                 msg.append("Instance:\n\n%s\n" % elem_as_string)
+
         if self.path is not None:
             msg.append("Path: %s\n" % self.path)
+
         if len(msg) == 1:
             return msg0:-2
+
         return '\n'.join(msg)
 
 
@@ -227,21 +267,20 @@
     Raised when an XML data string is not decodable to a Python object.
 
     :param validator: the XSD validator.
-    :type validator: XsdValidator or function
     :param obj: the not validated XML data.
-    :type obj: Element or tuple or str or list or int or float or bool
     :param decoder: the XML data decoder.
-    :type decoder: type or function
     :param reason: the detailed reason of failed validation.
-    :type reason: str or unicode
     :param source: the XML resource that contains the error.
-    :type source: XMLResource
     :param namespaces: is an optional mapping from namespace prefix to URI.
-    :type namespaces: dict
     """
     message = "failed decoding {!r} with {!r}.\n"
 
-    def __init__(self, validator, obj, decoder, reason=None, source=None, namespaces=None):
+    def __init__(self, validator: Union'XsdValidator', CallableAny, None,
+                 obj: Any,
+                 decoder: Any,
+                 reason: Optionalstr = None,
+                 source: Optional'XMLResource' = None,
+                 namespaces: OptionalNamespacesType = None) -> None:
         super(XMLSchemaDecodeError, self).__init__(validator, obj, reason, source, namespaces)
         self.decoder = decoder
 
@@ -251,21 +290,20 @@
     Raised when an object is not encodable to an XML data string.
 
     :param validator: the XSD validator.
-    :type validator: XsdValidator or function
     :param obj: the not validated XML data.
-    :type obj: Element or tuple or str or list or int or float or bool
     :param encoder: the XML encoder.
-    :type encoder: type or function
     :param reason: the detailed reason of failed validation.
-    :type reason: str or unicode
     :param source: the XML resource that contains the error.
-    :type source: XMLResource
     :param namespaces: is an optional mapping from namespace prefix to URI.
-    :type namespaces: dict
     """
     message = "failed encoding {!r} with {!r}.\n"
 
-    def __init__(self, validator, obj, encoder, reason=None, source=None, namespaces=None):
+    def __init__(self, validator: Union'XsdValidator', CallableAny, None,
+                 obj: Any,
+                 encoder: Any,
+                 reason: Optionalstr = None,
+                 source: Optional'XMLResource' = None,
+                 namespaces: OptionalNamespacesType = None) -> None:
         super(XMLSchemaEncodeError, self).__init__(validator, obj, reason, source, namespaces)
         self.encoder = encoder
 
@@ -275,24 +313,23 @@
     Raised when a child element is not validated.
 
     :param validator: the XSD validator.
-    :type validator: XsdValidator or function
     :param elem: the not validated XML element.
-    :type elem: Element or ElementData
     :param index: the child index.
-    :type index: int
-    :param particle: the validator particle that generated the error. Maybe the validator itself.
-    :type particle: ParticleMixin
+    :param particle: the model particle that generated the error. Maybe the validator itself.
     :param occurs: the particle occurrences.
-    :type occurs: int
     :param expected: the expected element tags/object names.
-    :type expected: str or list or tuple
     :param source: the XML resource that contains the error.
-    :type source: XMLResource
     :param namespaces: is an optional mapping from namespace prefix to URI.
-    :type namespaces: dict
     """
-    def __init__(self, validator, elem, index, particle, occurs=0,
-                 expected=None, source=None, namespaces=None):
+    def __init__(self, validator: 'XsdValidator',
+                 elem: ElementType,
+                 index: int,
+                 particle: ModelParticleType,
+                 occurs: int = 0,
+                 expected: OptionalIterableSchemaElementType = None,
+                 source: Optional'XMLResource' = None,
+                 namespaces: OptionalNamespacesType = None) -> None:
+
         self.index = index
         self.particle = particle
         self.occurs = occurs
@@ -310,7 +347,7 @@
                 particle, occurs, particle.min_occurs
             )
         elif particle.is_over(occurs):
-            reason += " The particle %r occurs %d times but the maximum is %d." % (
+            reason += " The particle %r occurs %r times but the maximum is %r." % (
                 particle, occurs, particle.max_occurs
             )
 
@@ -319,17 +356,22 @@
         else:
             expected_tags = 
             for xsd_element in expected:
-                if xsd_element.name is not None:
-                    expected_tags.append(xsd_element.prefixed_name)
-                elif xsd_element.process_contents == 'strict':
-                    expected_tags.append('from %r namespace/s' % xsd_element.namespace)
+                name = xsd_element.prefixed_name
+                if name is not None:
+                    expected_tags.append(name)
+                elif getattr(xsd_element, 'process_contents', '') == 'strict':
+                    expected_tags.append(
+                        'from %r namespace/s' % xsd_element.namespace  # type: ignoreunion-attr
+                    )
 
             if not expected_tags:
                 pass
-            elif len(expected_tags) == 1:
+            elif len(expected_tags) > 1:
+                reason += " Tag (%s) expected." % ' | '.join(repr(tag) for tag in expected_tags)
+            elif expected_tags0.startswith('from '):
                 reason += " Tag %s expected." % expected_tags0
             else:
-                reason += " Tag (%s) expected." % ' | '.join(expected_tags)
+                reason += " Tag %r expected." % expected_tags0
 
         super(XMLSchemaChildrenValidationError, self).\
             __init__(validator, elem, reason, source, namespaces)

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/validators/facets.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/validators/facets.py Changed

@@ -13,45 +13,60 @@
 import re
 import math
 import operator
-from collections.abc import MutableSequence
+from abc import abstractmethod
+from typing import TYPE_CHECKING, cast, Any, List, Optional, Pattern, Union, \
+    MutableSequence, overload, Tuple
 from elementpath import XPath2Parser, XPathContext, ElementPathError, \
     translate_pattern, RegexError
 
-from ..etree import etree_element
 from ..names import XSD_LENGTH, XSD_MIN_LENGTH, XSD_MAX_LENGTH, XSD_ENUMERATION, \
     XSD_INTEGER, XSD_WHITE_SPACE, XSD_PATTERN, XSD_MAX_INCLUSIVE, XSD_MAX_EXCLUSIVE, \
     XSD_MIN_INCLUSIVE, XSD_MIN_EXCLUSIVE, XSD_TOTAL_DIGITS, XSD_FRACTION_DIGITS, \
-    XSD_ASSERTION, XSD_DECIMAL, XSD_EXPLICIT_TIMEZONE, XSD_NOTATION_TYPE, XSD_QNAME
-from ..helpers import count_digits
+    XSD_ASSERTION, XSD_DECIMAL, XSD_EXPLICIT_TIMEZONE, XSD_NOTATION_TYPE, XSD_QNAME, \
+    XSD_ANNOTATION
+from ..etree import etree_element
+from ..aliases import ElementType, SchemaType, AtomicValueType, BaseXsdType
+from ..helpers import count_digits, local_name
 from .exceptions import XMLSchemaValidationError, XMLSchemaDecodeError
-from .xsdbase import XsdComponent
+from .xsdbase import XsdComponent, XsdAnnotation
+
+if TYPE_CHECKING:
+    from .simple_types import XsdList, XsdAtomicRestriction
+
+LaxDecodeType = TupleAny, ListXMLSchemaValidationError
 
 
 class XsdFacet(XsdComponent):
     """
     XML Schema constraining facets base class.
     """
+    value: OptionalAtomicValueType
+    base_type: OptionalBaseXsdType
+    base_value: OptionalAtomicValueType
     fixed = False
 
-    def __init__(self, elem, schema, parent, base_type):
+    def __init__(self, elem: ElementType,
+                 schema: SchemaType,
+                 parent: Union'XsdList', 'XsdAtomicRestriction',
+                 base_type: OptionalBaseXsdType) -> None:
         self.base_type = base_type
         super(XsdFacet, self).__init__(elem, schema, parent)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return '%s(value=%r, fixed=%r)' % (self.__class__.__name__, self.value, self.fixed)
 
-    def __call__(self, value):
+    def __call__(self, value: Any) -> None:
         try:
             self._validator(value)
-        except TypeError as err:
-            raise XMLSchemaValidationError(self, value, str(err)) from None
+        except TypeError:
+            reason = "invalid type {!r} provided".format(type(value))
+            raise XMLSchemaValidationError(self, value, reason) from None
 
     @staticmethod
-    def _validator(_):
+    def _validator(_: Any) -> None:
         return
 
-    def _parse(self):
-        super(XsdFacet, self)._parse()
+    def _parse(self) -> None:
         if 'fixed' in self.elem.attrib and self.elem.attrib'fixed' in ('true', '1'):
             self.fixed = True
         base_facet = self.base_facet
@@ -65,32 +80,34 @@
         else:
             if base_facet is not None and base_facet.fixed and \
                     base_facet.value is not None and self.value != base_facet.value:
-                self.parse_error(
-                    "%r facet value is fixed to %r" % (self.elem.tag, base_facet.value)
-                )
+                self.parse_error("{!r} facet value is fixed to {!r}"
+                                 .format(local_name(self.elem.tag), base_facet.value))
 
-    def _parse_value(self, elem):
-        self.value = elem.attrib'value'
+    def _parse_value(self, elem: ElementType) -> UnionNone, AtomicValueType, Patternstr:
+        self.value = elem.attrib'value'  # pragma: no cover
+        return None
 
     @property
-    def built(self):
-        return True
+    def built(self) -> bool:
+        return True  # pragma: no cover
 
     @property
-    def base_facet(self):
+    def base_facet(self) -> Optional'XsdFacet':
         """
         An object of the same type if the instance has a base facet, `None` otherwise.
         """
-        base_type = self.base_type
+        base_type: OptionalBaseXsdType = self.base_type
         tag = self.elem.tag
         while True:
+            if base_type is None:
+                return None
             try:
-                return base_type.facetstag
+                base_facet = base_type.facetstag  # type: ignoreunion-attr
             except (AttributeError, KeyError):
-                if hasattr(base_type, 'base_type'):
-                    base_type = base_type.base_type
-                else:
-                    return None
+                base_type = base_type.base_type
+            else:
+                assert isinstance(base_facet, self.__class__)
+                return base_facet
 
 
 class XsdWhiteSpaceFacet(XsdFacet):
@@ -105,29 +122,29 @@
           Content: (annotation?)
         </whiteSpace>
     """
+    value: str
     _ADMITTED_TAGS = XSD_WHITE_SPACE,
 
-    def _parse_value(self, elem):
-        self.value = value = elem.attrib'value'
-        if self.base_value == 'collapse' and value in ('preserve', 'replace'):
+    def _parse_value(self, elem: ElementType) -> None:
+        self.value = elem.attrib'value'
+        if self.value == 'collapse':
+            self._validator = self.collapse_white_space_validator  # type: ignoreassignment
+        elif self.value == 'replace':
+            if self.base_value == 'collapse':
+                self.parse_error("facet value can be only 'collapse'")
+            self._validator = self.replace_white_space_validator  # type: ignoreassignment
+        elif self.base_value == 'collapse':
             self.parse_error("facet value can be only 'collapse'")
-        elif self.base_value == 'replace' and value == 'preserve':
+        elif self.base_value == 'replace':
             self.parse_error("facet value can be only 'replace' or 'collapse'")
-        elif value == 'replace':
-            self._validator = self.replace_white_space_validator
-        elif value == 'collapse':
-            self._validator = self.collapse_white_space_validator
-        elif value != 'preserve':
-            self.parse_error("attribute 'value' must be one of "
-                             "('preserve', 'replace', 'collapse').")
-
-    def replace_white_space_validator(self, value):
+
+    def replace_white_space_validator(self, value: str) -> None:
         if '\t' in value or '\n' in value:
             raise XMLSchemaValidationError(
                 self, value, "value contains tabs or newlines"
             )
 
-    def collapse_white_space_validator(self, value):
+    def collapse_white_space_validator(self, value: str) -> None:
         if '\t' in value or '\n' in value or '  ' in value:
             raise XMLSchemaValidationError(
                 self, value, "value contains non collapsed white spaces"
@@ -146,19 +163,22 @@
           Content: (annotation?)
         </length>
     """
+    value: int
+    base_type: BaseXsdType
+    base_value: Optionalint
     _ADMITTED_TAGS = XSD_LENGTH,
 
-    def _parse_value(self, elem):
+    def _parse_value(self, elem: ElementType) -> None:
         self.value = int(elem.attrib'value')
         if self.base_value is not None and self.value != self.base_value:
-            self.parse_error("base type has a different 'length': %r" % self.base_value)
+            self.parse_error("base facet has a different length ({})".format(self.base_value))
 
         primitive_type = getattr(self.base_type, 'primitive_type', None)
         if primitive_type is None or primitive_type.name not in {XSD_QNAME, XSD_NOTATION_TYPE}:
-            # See: https://www.w3.org/Bugs/Public/show_bug.cgi?id=4009 and id=4049
-            self._validator = self._length_validator
+            # See: https://www.w3.org/Bugs/Public/show_bug.cgi?id=4009
+            self._validator = self._length_validator  # type: ignoreassignment
 
-    def _length_validator(self, value):
+    def _length_validator(self, value: Any) -> None:
         if len(value) != self.value:
             reason = "length has to be {!r}".format(self.value)
             raise XMLSchemaValidationError(self, value, reason)
@@ -176,19 +196,22 @@
           Content: (annotation?)
         </minLength>
     """
+    value: int
+    base_type: BaseXsdType
+    base_value: Optionalint
     _ADMITTED_TAGS = XSD_MIN_LENGTH,
 
-    def _parse_value(self, elem):
+    def _parse_value(self, elem: ElementType) -> None:
         self.value = int(elem.attrib'value')
         if self.base_value is not None and self.value < self.base_value:
-            self.parse_error("base type has a greater 'minLength': %r" % self.base_value)
+            self.parse_error("base facet has a greater min length ({})".format(self.base_value))
 
         primitive_type = getattr(self.base_type, 'primitive_type', None)
         if primitive_type is None or primitive_type.name not in {XSD_QNAME, XSD_NOTATION_TYPE}:
-            # See: https://www.w3.org/Bugs/Public/show_bug.cgi?id=4009 and id=4049
-            self._validator = self._min_length_validator
+            # See: https://www.w3.org/Bugs/Public/show_bug.cgi?id=4009
+            self._validator = self._min_length_validator  # type: ignoreassignment
 
-    def _min_length_validator(self, value):
+    def _min_length_validator(self, value: Any) -> None:
         if len(value) < self.value:
             reason = "value length cannot be lesser than {!r}".format(self.value)
             raise XMLSchemaValidationError(self, value, reason)
@@ -206,19 +229,22 @@
           Content: (annotation?)
         </maxLength>
     """
+    value: int
+    base_type: BaseXsdType
+    base_value: Optionalint
     _ADMITTED_TAGS = XSD_MAX_LENGTH,
 
-    def _parse_value(self, elem):
+    def _parse_value(self, elem: ElementType) -> None:
         self.value = int(elem.attrib'value')
         if self.base_value is not None and self.value > self.base_value:
-            self.parse_error("base type has a lesser 'maxLength': %r" % self.base_value)
+            self.parse_error("base type has a lesser max length ({})".format(self.base_value))
 
         primitive_type = getattr(self.base_type, 'primitive_type', None)
         if primitive_type is None or primitive_type.name not in {XSD_QNAME, XSD_NOTATION_TYPE}:
-            # See: https://www.w3.org/Bugs/Public/show_bug.cgi?id=4009 and id=4049
-            self._validator = self._min_length_validator
+            # See: https://www.w3.org/Bugs/Public/show_bug.cgi?id=4009
+            self._validator = self._max_length_validator  # type: ignoreassignment
 
-    def _min_length_validator(self, value):
+    def _max_length_validator(self, value: Any) -> None:
         if len(value) > self.value:
             reason = "value length cannot be greater than {!r}".format(self.value)
             raise XMLSchemaValidationError(self, value, reason)
@@ -236,28 +262,16 @@
           Content: (annotation?)
         </minInclusive>
     """
+    base_type: BaseXsdType
     _ADMITTED_TAGS = XSD_MIN_INCLUSIVE,
 
-    def _parse_value(self, elem):
-        self.value, errors = self.base_type.decode(elem.attrib'value', validation='lax')
+    def _parse_value(self, elem: ElementType) -> None:
+        value = elem.attrib'value'
+        self.value, errors = cast(LaxDecodeType, self.base_type.decode(value, 'lax'))
         for e in errors:
-            if not isinstance(e.validator, self.__class__) or e.validator.value != self.value:
-                raise e
-
-        facet = self.base_type.get_facet(XSD_MIN_EXCLUSIVE)
-        if facet is not None and facet.value >= self.value:
-            self.parse_error("minimum value of base_type is greater")
-        facet = self.base_type.get_facet(XSD_MIN_INCLUSIVE)
-        if facet is not None and facet.value > self.value:
-            self.parse_error("minimum value of base_type is greater")
-        facet = self.base_type.get_facet(XSD_MAX_EXCLUSIVE)
-        if facet is not None and facet.value <= self.value:
-            self.parse_error("maximum value of base_type is lesser")
-        facet = self.base_type.get_facet(XSD_MAX_INCLUSIVE)
-        if facet is not None and facet.value < self.value:
-            self.parse_error("maximum value of base_type is lesser")
-
-    def __call__(self, value):
+            self.parse_error("invalid restriction: {}".format(e.reason))
+
+    def __call__(self, value: Any) -> None:
         try:
             if value < self.value:
                 reason = "value has to be greater or equal than {!r}".format(self.value)
@@ -278,28 +292,21 @@
           Content: (annotation?)
         </minExclusive>
     """
+    base_type: BaseXsdType
     _ADMITTED_TAGS = XSD_MIN_EXCLUSIVE,
 
-    def _parse_value(self, elem):
-        self.value, errors = self.base_type.decode(elem.attrib'value', validation='lax')
+    def _parse_value(self, elem: ElementType) -> None:
+        value = elem.attrib'value'
+        self.value, errors = cast(LaxDecodeType, self.base_type.decode(value, 'lax'))
         for e in errors:
             if not isinstance(e.validator, self.__class__) or e.validator.value != self.value:
-                raise e
-
-        facet = self.base_type.get_facet(XSD_MIN_EXCLUSIVE)
-        if facet is not None and facet.value > self.value:
-            self.parse_error("minimum value of base_type is greater")
-        facet = self.base_type.get_facet(XSD_MIN_INCLUSIVE)
-        if facet is not None and facet.value > self.value:
-            self.parse_error("minimum value of base_type is greater")
-        facet = self.base_type.get_facet(XSD_MAX_EXCLUSIVE)
-        if facet is not None and facet.value <= self.value:
-            self.parse_error("maximum value of base_type is lesser")
-        facet = self.base_type.get_facet(XSD_MAX_INCLUSIVE)
-        if facet is not None and facet.value <= self.value:
-            self.parse_error("maximum value of base_type is lesser")
-
-    def __call__(self, value):
+                self.parse_error("invalid restriction: {}".format(e.reason))
+
+        facet: Any = self.base_type.get_facet(XSD_MAX_INCLUSIVE)
+        if facet is not None and facet.value == self.value:
+            self.parse_error("invalid restriction: {} is also the maximum".format(self.value))
+
+    def __call__(self, value: Any) -> None:
         try:
             if value <= self.value:
                 reason = "value has to be greater than {!r}".format(self.value)
@@ -320,28 +327,16 @@
           Content: (annotation?)
         </maxInclusive>
     """
+    base_type: BaseXsdType
     _ADMITTED_TAGS = XSD_MAX_INCLUSIVE,
 
-    def _parse_value(self, elem):
-        self.value, errors = self.base_type.decode(elem.attrib'value', validation='lax')
+    def _parse_value(self, elem: ElementType) -> None:
+        value = elem.attrib'value'
+        self.value, errors = cast(LaxDecodeType, self.base_type.decode(value, 'lax'))
         for e in errors:
-            if not isinstance(e.validator, self.__class__) or e.validator.value != self.value:
-                raise e
-
-        facet = self.base_type.get_facet(XSD_MIN_EXCLUSIVE)
-        if facet is not None and facet.value >= self.value:
-            self.parse_error("minimum value of base_type is greater")
-        facet = self.base_type.get_facet(XSD_MIN_INCLUSIVE)
-        if facet is not None and facet.value > self.value:
-            self.parse_error("minimum value of base_type is greater")
-        facet = self.base_type.get_facet(XSD_MAX_EXCLUSIVE)
-        if facet is not None and facet.value <= self.value:
-            self.parse_error("maximum value of base_type is lesser")
-        facet = self.base_type.get_facet(XSD_MAX_INCLUSIVE)
-        if facet is not None and facet.value < self.value:
-            self.parse_error("maximum value of base_type is lesser")
-
-    def __call__(self, value):
+            self.parse_error("invalid restriction: {}".format(e.reason))
+
+    def __call__(self, value: Any) -> None:
         try:
             if value > self.value:
                 reason = "value has to be lesser or equal than {!r}".format(self.value)
@@ -362,28 +357,21 @@
           Content: (annotation?)
         </maxExclusive>
     """
+    base_type: BaseXsdType
     _ADMITTED_TAGS = XSD_MAX_EXCLUSIVE,
 
-    def _parse_value(self, elem):
-        self.value, errors = self.base_type.decode(elem.attrib'value', validation='lax')
+    def _parse_value(self, elem: ElementType) -> None:
+        value = elem.attrib'value'
+        self.value, errors = cast(LaxDecodeType, self.base_type.decode(value, 'lax'))
         for e in errors:
             if not isinstance(e.validator, self.__class__) or e.validator.value != self.value:
-                raise e
-
-        facet = self.base_type.get_facet(XSD_MIN_EXCLUSIVE)
-        if facet is not None and facet.value >= self.value:
-            self.parse_error("minimum value of base_type is greater")
-        facet = self.base_type.get_facet(XSD_MIN_INCLUSIVE)
-        if facet is not None and facet.value >= self.value:
-            self.parse_error("minimum value of base_type is greater")
-        facet = self.base_type.get_facet(XSD_MAX_EXCLUSIVE)
-        if facet is not None and facet.value < self.value:
-            self.parse_error("maximum value of base_type is lesser")
-        facet = self.base_type.get_facet(XSD_MAX_INCLUSIVE)
-        if facet is not None and facet.value < self.value:
-            self.parse_error("maximum value of base_type is lesser")
-
-    def __call__(self, value):
+                self.parse_error("invalid restriction: {}".format(e.reason))
+
+        facet: Any = self.base_type.get_facet(XSD_MIN_INCLUSIVE)
+        if facet is not None and facet.value == self.value:
+            self.parse_error("invalid restriction: {} is also the minimum".format(self.value))
+
+    def __call__(self, value: Any) -> None:
         try:
             if value >= self.value:
                 reason = "value has to be lesser than {!r}".format(self.value)
@@ -404,21 +392,37 @@
           Content: (annotation?)
         </totalDigits>
     """
+    value: int
+    base_type: BaseXsdType
     _ADMITTED_TAGS = XSD_TOTAL_DIGITS,
 
-    def _parse_value(self, elem):
-        self.value = int(elem.attrib'value')
-        if self.value < 1:
-            raise ValueError("'value' must be greater or equal than 1")
+    def _parse_value(self, elem: ElementType) -> None:
+        # Errors are detected by meta-schema validation. For schemas with
+        # 'lax' validation mode use 9999 in case of an invalid value.
+        try:
+            self.value = int(elem.attrib'value')
+        except (ValueError, KeyError):
+            self.value = 9999
+        else:
+            if self.value < 1:
+                self.value = 9999
+
+            facet: Any = self.base_type.get_facet(XSD_TOTAL_DIGITS)
+            if facet is not None and facet.value < self.value:
+                self.parse_error(
+                    "invalid restriction: base value is lower ({})".format(facet.value)
+                )
 
-    def __call__(self, value):
+    def __call__(self, value: Any) -> None:
         try:
-            if operator.add(*count_digits(value)) > self.value:
-                reason = "the number of digits has to be lesser or equal " \
-                         "than {!r}".format(self.value)
-                raise XMLSchemaValidationError(self, value, reason)
-        except (TypeError, ArithmeticError) as err:
+            if operator.add(*count_digits(value)) <= self.value:
+                return
+        except (TypeError, ValueError, ArithmeticError) as err:
             raise XMLSchemaValidationError(self, value, str(err)) from None
+        else:
+            reason = "the number of digits has to be lesser or equal " \
+                     "than {!r}".format(self.value)
+            raise XMLSchemaValidationError(self, value, reason)
 
 
 class XsdFractionDigitsFacet(XsdFacet):
@@ -433,31 +437,51 @@
           Content: (annotation?)
         </fractionDigits>
     """
+    value: int
+    base_type: BaseXsdType
     _ADMITTED_TAGS = XSD_FRACTION_DIGITS,
 
-    def __init__(self, elem, schema, parent, base_type):
+    def __init__(self, elem: ElementType,
+                 schema: SchemaType,
+                 parent: 'XsdAtomicRestriction',
+                 base_type: BaseXsdType) -> None:
+
         super(XsdFractionDigitsFacet, self).__init__(elem, schema, parent, base_type)
         if not base_type.is_derived(self.maps.typesXSD_DECIMAL):
             self.parse_error(
                 "fractionDigits facet can be applied only to types derived from xs:decimal"
             )
 
-    def _parse_value(self, elem):
-        self.value = int(elem.attrib'value')
-        if self.value < 0:
-            raise ValueError("'value' must be greater or equal than 0")
-        elif self.value > 0 and self.base_type.is_derived(self.maps.typesXSD_INTEGER):
-            raise ValueError("fractionDigits facet value has to be 0 "
-                             "for types derived from xs:integer.")
+    def _parse_value(self, elem: ElementType) -> None:
+        # Errors are detected by meta-schema validation. For schemas with
+        # 'lax' validation mode use 9999 in case of an invalid value.
+        try:
+            self.value = int(elem.attrib'value')
+        except (ValueError, KeyError):
+            self.value = 9999
+        else:
+            if self.value < 0:
+                self.value = 9999
+            elif self.value > 0 and self.base_type.is_derived(self.maps.typesXSD_INTEGER):
+                raise ValueError("fractionDigits facet value has to be 0 "
+                                 "for types derived from xs:integer.")
+
+            facet: Any = self.base_type.get_facet(XSD_FRACTION_DIGITS)
+            if facet is not None and facet.value < self.value:
+                self.parse_error(
+                    "invalid restriction: base value is lower ({})".format(facet.value)
+                )
 
-    def __call__(self, value):
+    def __call__(self, value: Any) -> None:
         try:
-            if count_digits(value)1 > self.value:
-                reason = "the number of fraction digits has to be lesser " \
-                         "or equal than {!r}".format(self.value)
-                raise XMLSchemaValidationError(self, value, reason)
-        except (TypeError, ArithmeticError) as err:
+            if count_digits(value)1 <= self.value:
+                return
+        except (TypeError, ValueError, ArithmeticError) as err:
             raise XMLSchemaValidationError(self, value, str(err)) from None
+        else:
+            reason = "the number of fraction digits has to be lesser " \
+                     "or equal than {!r}".format(self.value)
+            raise XMLSchemaValidationError(self, value, reason)
 
 
 class XsdExplicitTimezoneFacet(XsdFacet):
@@ -472,33 +496,37 @@
           Content: (annotation?)
         </explicitTimezone>
     """
+    value: str
+    base_type: BaseXsdType
     _ADMITTED_TAGS = XSD_EXPLICIT_TIMEZONE,
 
-    def _parse_value(self, elem):
-        self.value = value = elem.attrib'value'
-        if value == 'prohibited':
-            self._validator = self._prohibited_timezone_validator
-        elif value == 'required':
-            self._validator = self._required_timezone_validator
-        elif value != 'optional':
-            self.parse_error(
-                "attribute 'value' must be one of ('required', 'prohibited', 'optional')."
-            )
-
-    def _required_timezone_validator(self, value):
+    def _parse_value(self, elem: ElementType) -> None:
+        self.value = elem.attrib'value'
+        if self.value == 'prohibited':
+            self._validator = self._prohibited_timezone_validator  # type: ignoreassignment
+        elif self.value == 'required':
+            self._validator = self._required_timezone_validator  # type: ignoreassignment
+        elif self.value != 'optional':
+            self.value = 'optional'  # Error already detected by meta-schema validation
+
+        facet: Any = self.base_type.get_facet(XSD_EXPLICIT_TIMEZONE)
+        if facet is not None and facet.value != self.value and facet.value != 'optional':
+            self.parse_error("invalid restriction from {!r}".format(facet.value))
+
+    def _required_timezone_validator(self, value: Any) -> None:
         if value.tzinfo is None:
             raise XMLSchemaValidationError(
                 self, value, "time zone required for value {!r}".format(self.value)
             )
 
-    def _prohibited_timezone_validator(self, value):
+    def _prohibited_timezone_validator(self, value: Any) -> None:
         if value.tzinfo is not None:
             raise XMLSchemaValidationError(
                 self, value, "time zone prohibited for value {!r}".format(self.value)
             )
 
 
-class XsdEnumerationFacets(MutableSequence, XsdFacet):
+class XsdEnumerationFacets(MutableSequenceElementType, XsdFacet):
     """
     Sequence of XSD *enumeration* facets. Values are validates if match any of enumeration values.
 
@@ -509,27 +537,29 @@
           Content: (annotation?)
         </enumeration>
     """
+    base_type: BaseXsdType
     _ADMITTED_TAGS = {XSD_ENUMERATION}
 
-    def __init__(self, elem, schema, parent, base_type):
+    def __init__(self, elem: ElementType,
+                 schema: SchemaType,
+                 parent: 'XsdAtomicRestriction',
+                 base_type: BaseXsdType) -> None:
         XsdFacet.__init__(self, elem, schema, parent, base_type)
 
-    def _parse(self):
-        super(XsdFacet, self)._parse()
+    def _parse(self) -> None:
         self._elements = self.elem
         self.enumeration = self._parse_value(self.elem)
 
-    def _parse_value(self, elem):
+    def _parse_value(self, elem: ElementType) -> OptionalAtomicValueType:
         try:
             value = self.base_type.decode(elem.attrib'value', namespaces=self.schema.namespaces)
         except KeyError:
-            self.parse_error("missing 'value' attribute", elem)
-        except XMLSchemaDecodeError as err:
-            self.parse_error(err, elem)
+            pass  # pragma: no cover (already detected by meta-schema validation)
         except XMLSchemaValidationError as err:
-            self.base_type.parse_error(err, elem)  # FIXME
+            self.parse_error(err, elem)
         else:
             if self.base_type.name == XSD_NOTATION_TYPE:
+                assert isinstance(value, str)
                 try:
                     notation_qname = self.schema.resolve_qname(value)
                 except (KeyError, ValueError, RuntimeError) as err:
@@ -538,51 +568,79 @@
                     if notation_qname not in self.maps.notations:
                         msg = "value {!r} must match a notation declaration"
                         self.parse_error(msg.format(value), elem)
-            return value
+            return cast(AtomicValueType, value)
+        return None
+
+    @overload
+    @abstractmethod
+    def __getitem__(self, i: int) -> ElementType: ...
 
-    # Implements the abstract methods of MutableSequence
-    def __getitem__(self, i):
+    @overload
+    @abstractmethod
+    def __getitem__(self, s: slice) -> MutableSequenceElementType: ...
+
+    def __getitem__(self, i: Unionint, slice) \
+            -> UnionElementType, MutableSequenceElementType:
         return self._elementsi
 
-    def __setitem__(self, i, elem):
-        self._elementsi = elem
-        self.enumerationi = self._parse_value(elem)
+    def __setitem__(self, i: Unionint, slice, o: Any) -> None:
+        self._elementsi = o
+        if isinstance(i, int):
+            self.enumerationi = self._parse_value(o)
+        else:
+            self.enumerationi = self._parse_value(e) for e in o
 
-    def __delitem__(self, i):
+    def __delitem__(self, i: Unionint, slice) -> None:
         del self._elementsi
         del self.enumerationi
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self._elements)
 
-    def insert(self, i, elem):
+    def insert(self, i: int, elem: ElementType) -> None:
         self._elements.insert(i, elem)
         self.enumeration.insert(i, self._parse_value(elem))
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         if len(self.enumeration) > 5:
-            return '%s(%r)' % (
+            return '%s(%s)' % (
                 self.__class__.__name__, '%s, ...' % ', '.join(map(repr, self.enumeration:5))
             )
         else:
             return '%s(%r)' % (self.__class__.__name__, self.enumeration)
 
-    def __call__(self, value):
+    def __call__(self, value: Any) -> None:
         if value in self.enumeration:
             return
+
         try:
-            if math.isnan(value) and any(math.isnan(x) for x in self.enumeration):
-                return
-            elif math.isinf(value) and any(math.isinf(x) for x in self.enumeration):
-                return
+            if math.isnan(value):
+                if any(math.isnan(x) for x in self.enumeration):  # type: ignorearg-type
+                    return
+            elif math.isinf(value):
+                if any(math.isinf(x) and str(value) == str(x)  # type: ignorearg-type
+                       for x in self.enumeration):  # pragma: no cover
+                    return
         except TypeError:
             pass
 
         reason = "value must be one of {!r}".format(self.enumeration)
         raise XMLSchemaValidationError(self, value, reason)
 
+    def get_annotation(self, i: int) -> OptionalXsdAnnotation:
+        """
+        Get the XSD annotation of the i-th enumeration facet.
+
+        :param i: an integer index.
+        :returns: an XsdAnnotation object or `None`.
+        """
+        for child in self._elementsi:
+            if child.tag == XSD_ANNOTATION:
+                return XsdAnnotation(child, self.schema, self)
+        return None
+
 
-class XsdPatternFacets(MutableSequence, XsdFacet):
+class XsdPatternFacets(MutableSequenceElementType, XsdFacet):
     """
     Sequence of XSD *pattern* facets. Values are validates if match any of patterns.
 
@@ -594,16 +652,19 @@
         </pattern>
     """
     _ADMITTED_TAGS = {XSD_PATTERN}
+    patterns: ListPatternstr
 
-    def __init__(self, elem, schema, parent, base_type):
+    def __init__(self, elem: ElementType,
+                 schema: SchemaType,
+                 parent: 'XsdAtomicRestriction',
+                 base_type: OptionalBaseXsdType) -> None:
         XsdFacet.__init__(self, elem, schema, parent, base_type)
 
-    def _parse(self):
-        super(XsdFacet, self)._parse()
+    def _parse(self) -> None:
         self._elements = self.elem
         self.patterns = self._parse_value(self.elem)
 
-    def _parse_value(self, elem):
+    def _parse_value(self, elem: ElementType) -> Patternstr:
         try:
             python_pattern = translate_pattern(
                 pattern=elem.attrib'value',
@@ -614,39 +675,49 @@
             )
             return re.compile(python_pattern)
         except KeyError:
-            self.parse_error("missing 'value' attribute", elem)
             return re.compile(r'^.*$')
         except (RegexError, re.error, XMLSchemaDecodeError) as err:
-            self.parse_error(err, elem)
+            self.parse_error(str(err), elem)
             return re.compile(r'^.*$')
 
-    # Implements the abstract methods of MutableSequence
-    def __getitem__(self, i):
+    @overload
+    @abstractmethod
+    def __getitem__(self, i: int) -> ElementType: ...
+
+    @overload
+    @abstractmethod
+    def __getitem__(self, s: slice) -> MutableSequenceElementType: ...
+
+    def __getitem__(self, i: Unionint, slice) \
+            -> UnionElementType, MutableSequenceElementType:
         return self._elementsi
 
-    def __setitem__(self, i, elem):
-        self._elementsi = elem
-        self.patternsi = self._parse_value(elem)
+    def __setitem__(self, i: Unionint, slice, o: Any) -> None:
+        self._elementsi = o
+        if isinstance(i, int):
+            self.patternsi = self._parse_value(o)
+        else:
+            self.patternsi = self._parse_value(e) for e in o
 
-    def __delitem__(self, i):
+    def __delitem__(self, i: Unionint, slice) -> None:
         del self._elementsi
         del self.patternsi
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self._elements)
 
-    def insert(self, i, elem):
+    def insert(self, i: int, elem: ElementType) -> None:
         self._elements.insert(i, elem)
         self.patterns.insert(i, self._parse_value(elem))
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         s = repr(self.regexps)
         if len(s) < 70:
             return '%s(%s)' % (self.__class__.__name__, s)
         else:
             return '%s(%s...\')' % (self.__class__.__name__, s:70)
 
-    def __call__(self, text):
+    def __call__(self, text: str) -> None:
         try:
             if all(pattern.match(text) is None for pattern in self.patterns):
                 reason = "value doesn't match any pattern of {!r}".format(self.regexps)
@@ -655,8 +726,20 @@
             raise XMLSchemaValidationError(self, text, str(err)) from None
 
     @property
-    def regexps(self):
-        return e.get('value', '') for e in self._elements
+    def regexps(self) -> Liststr:
+        return e.attrib.get('value', '') for e in self._elements
+
+    def get_annotation(self, i: int) -> OptionalXsdAnnotation:
+        """
+        Get the XSD annotation of the i-th pattern facet.
+
+        :param i: an integer index.
+        :returns: an XsdAnnotation object or `None`.
+        """
+        for child in self._elementsi:
+            if child.tag == XSD_ANNOTATION:
+                return XsdAnnotation(child, self.schema, self)
+        return None
 
 
 class XsdAssertionXPathParser(XPath2Parser):
@@ -669,14 +752,14 @@
 
 # noinspection PyUnusedLocal
 @XsdAssertionXPathParser.method(XsdAssertionXPathParser.function('last', nargs=0))
-def evaluate(self, context=None):
-    self.missing_context("Context item size is undefined")
+def evaluate_last(self, context=None):  # type: ignoreno-untyped-def
+    raise self.missing_context("context item size is undefined")
 
 
 # noinspection PyUnusedLocal
 @XsdAssertionXPathParser.method(XsdAssertionXPathParser.function('position', nargs=0))
-def evaluate(self, context=None):
-    self.missing_context("Context item position is undefined")
+def evaluate_position(self, context=None):  # type: ignoreno-untyped-def
+    raise self.missing_context("context item position is undefined")
 
 
 class XsdAssertionFacet(XsdFacet):
@@ -694,21 +777,20 @@
     _ADMITTED_TAGS = {XSD_ASSERTION}
     _root = etree_element('root')
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return '%s(test=%r)' % (self.__class__.__name__, self.path)
 
-    def _parse(self):
-        super(XsdFacet, self)._parse()
+    def _parse(self) -> None:
         try:
             self.path = self.elem.attrib'test'
-        except KeyError as err:
-            self.parse_error(err)
+        except KeyError:
+            self.parse_error("missing attribute 'test'")
             self.path = 'true()'
 
         try:
-            variable_types = {'value': self.base_type.primitive_type.prefixed_name}
+            value = self.base_type.primitive_type.prefixed_name  # type: ignoreunion-attr
         except AttributeError:
-            variable_types = {'value': self.any_simple_type.prefixed_name}
+            value = self.any_simple_type.prefixed_name
 
         if 'xpathDefaultNamespace' in self.elem.attrib:
             self.xpath_default_namespace = self._parse_xpath_default_namespace(self.elem)
@@ -716,7 +798,9 @@
             self.xpath_default_namespace = self.schema.xpath_default_namespace
 
         self.parser = XsdAssertionXPathParser(
-            self.namespaces, strict=False, variable_types=variable_types,
+            namespaces=self.namespaces,
+            strict=False,
+            variable_types={'value': value},
             default_namespace=self.xpath_default_namespace
         )
 
@@ -726,7 +810,7 @@
             self.parse_error(err)
             self.token = self.parser.parse('true()')
 
-    def __call__(self, value):
+    def __call__(self, value: AtomicValueType) -> None:
         context = XPathContext(self._root, variables={'value': value})
         try:
             if not self.token.evaluate(context):
@@ -766,3 +850,9 @@
 
 XSD_10_UNION_FACETS = {XSD_PATTERN, XSD_ENUMERATION}
 XSD_11_UNION_FACETS = MULTIPLE_FACETS = {XSD_PATTERN, XSD_ENUMERATION, XSD_ASSERTION}
+
+
+XsdFacetType = UnionXsdLengthFacet, XsdMinLengthFacet, XsdMaxLengthFacet,
+                     XsdMinInclusiveFacet, XsdMinExclusiveFacet, XsdMaxInclusiveFacet,
+                     XsdMaxExclusiveFacet, XsdTotalDigitsFacet, XsdFractionDigitsFacet,
+                     XsdEnumerationFacets, XsdPatternFacets

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/validators/global_maps.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/validators/global_maps.py Changed

@@ -13,26 +13,33 @@
 import warnings
 from collections import Counter
 from functools import lru_cache
-from typing import Union
+from typing import cast, Any, Callable, Dict, List, Iterable, Iterator, \
+    MutableMapping, Optional, Set, Union, Tuple, Type
 
 from ..exceptions import XMLSchemaKeyError, XMLSchemaTypeError, XMLSchemaValueError, \
-    XMLSchemaWarning
+    XMLSchemaRuntimeError, XMLSchemaWarning
 from ..names import XSD_NAMESPACE, XSD_REDEFINE, XSD_OVERRIDE, XSD_NOTATION, \
     XSD_ANY_TYPE, XSD_SIMPLE_TYPE, XSD_COMPLEX_TYPE, XSD_GROUP, \
     XSD_ATTRIBUTE, XSD_ATTRIBUTE_GROUP, XSD_ELEMENT, XSI_TYPE
+from ..aliases import ComponentClassType, ElementType, SchemaType, BaseXsdType, \
+    SchemaGlobalType
 from ..helpers import get_qname, local_name, get_extended_qname
 from ..namespaces import NamespaceResourcesMap
-from . import XMLSchemaNotBuiltError, XMLSchemaModelError, XMLSchemaModelDepthError, \
-    XsdValidator, XsdComponent, XsdAttribute, XsdSimpleType, XsdComplexType, \
-    XsdElement, XsdAttributeGroup, XsdGroup, XsdNotation, XsdIdentity, XsdAssert
+from .exceptions import XMLSchemaNotBuiltError, XMLSchemaModelError, XMLSchemaModelDepthError, \
+    XMLSchemaParseError
+from .xsdbase import XsdValidator, XsdComponent
 from .builtins import xsd_builtin_types_factory
+from . import XsdAttribute, XsdSimpleType, XsdComplexType, XsdElement, XsdAttributeGroup, \
+    XsdGroup, XsdNotation, XsdIdentity, XsdAssert, XsdUnion, XsdAtomicRestriction
 
 
 #
 # Defines the load functions for XML Schema structures
-def create_load_function(tag):
+def create_load_function(tag: str) \
+        -> CallableDictstr, Any, IterableSchemaType, None:
 
-    def load_xsd_globals(xsd_globals, schemas):
+    def load_xsd_globals(xsd_globals: Dictstr, Any,
+                         schemas: IterableSchemaType) -> None:
         redefinitions = 
         for schema in schemas:
             target_namespace = schema.target_namespace
@@ -68,13 +75,14 @@
                     msg = "global {} with name={!r} is already defined"
                     schema.parse_error(msg.format(local_name(tag), qname))
 
-        tags = Counter(x0 for x in redefinitions)
+        redefined_names = Counter(x0 for x in redefinitions)
         for qname, elem, child, schema, redefined_schema in reversed(redefinitions):
 
             # Checks multiple redefinitions
-            if tagsqname > 1:
-                tagsqname = 1
+            if redefined_namesqname > 1:
+                redefined_namesqname = 1
 
+                redefined_schemas: Any
                 redefined_schemas = x-1 for x in redefinitions if x0 == qname
                 if any(redefined_schemas.count(x) > 1 for x in redefined_schemas):
                     msg = "multiple redefinition for {} {!r}"
@@ -120,86 +128,6 @@
 load_xsd_notations = create_load_function(XSD_NOTATION)
 
 
-def create_lookup_function(xsd_classes):
-    if isinstance(xsd_classes, tuple):
-        types_desc = ' or '.join(c.__name__ for c in xsd_classes)
-    else:
-        types_desc = xsd_classes.__name__
-
-    def lookup(qname, global_map, tag_map):
-        try:
-            obj = global_mapqname
-        except KeyError:
-            if '{' in qname:
-                raise XMLSchemaKeyError("missing an %s component for %r!" % (types_desc, qname))
-            raise XMLSchemaKeyError(
-                "missing an %s component for %r! As the name has no namespace "
-                "maybe a missing default namespace declaration." % (types_desc, qname)
-            )
-        else:
-            if isinstance(obj, xsd_classes):
-                return obj
-
-            elif isinstance(obj, tuple):
-                # Not built XSD global component without redefinitions
-                try:
-                    elem, schema = obj
-                except ValueError:
-                    return obj0  # Circular build, simply return (elem, schema) couple
-
-                try:
-                    factory_or_class = tag_mapelem.tag
-                except KeyError:
-                    raise XMLSchemaKeyError("wrong element %r for map %r." % (elem, global_map))
-
-                global_mapqname = obj,  # Encapsulate into a tuple to catch circular builds
-                global_mapqname = factory_or_class(elem, schema, parent=None)
-                return global_mapqname
-
-            elif isinstance(obj, list):
-                # Not built XSD global component with redefinitions
-                try:
-                    elem, schema = obj0
-                except ValueError:
-                    return obj00  # Circular build, simply return (elem, schema) couple
-
-                try:
-                    factory_or_class = tag_mapelem.tag
-                except KeyError:
-                    raise XMLSchemaKeyError("wrong element %r for map %r." % (elem, global_map))
-
-                global_mapqname = obj0,  # To catch circular builds
-                global_mapqname = component = factory_or_class(elem, schema, parent=None)
-
-                # Apply redefinitions (changing elem involve a re-parsing of the component)
-                for elem, schema in obj1::
-                    if component.schema.target_namespace != schema.target_namespace:
-                        msg = "redefined schema {!r} has a different targetNamespace"
-                        raise XMLSchemaValueError(msg.format(schema))
-
-                    component.redefine = component.copy()
-                    component.redefine.parent = component
-                    component.schema = schema
-                    component.elem = elem
-
-                return global_mapqname
-
-            else:
-                raise XMLSchemaTypeError(
-                    "wrong instance %s for XSD global %r, a %s required." % (obj, qname, types_desc)
-                )
-
-    return lookup
-
-
-lookup_notation = create_lookup_function(XsdNotation)
-lookup_type = create_lookup_function((XsdSimpleType, XsdComplexType))
-lookup_attribute = create_lookup_function(XsdAttribute)
-lookup_attribute_group = create_lookup_function(XsdAttributeGroup)
-lookup_group = create_lookup_function(XsdGroup)
-lookup_element = create_lookup_function(XsdElement)
-
-
 class XsdGlobals(XsdValidator):
     """
     Mediator class for related XML schema instances. It stores the global
@@ -209,7 +137,20 @@
     :param validator: the origin schema class/instance used for creating the global maps.
     :param validation: the XSD validation mode to use, can be 'strict', 'lax' or 'skip'.
     """
-    _lookup_resolver = {
+    types: Dictstr, UnionBaseXsdType, TupleElementType, SchemaType
+    attributes: Dictstr, UnionXsdAttribute, TupleElementType, SchemaType
+    attribute_groups: Dictstr, UnionXsdAttributeGroup, TupleElementType, SchemaType
+    groups: Dictstr, UnionXsdGroup, TupleElementType, SchemaType
+    notations: Dictstr, UnionXsdNotation, TupleElementType, SchemaType
+    elements: Dictstr, UnionXsdElement, TupleElementType, SchemaType
+
+    substitution_groups: Dictstr, SetXsdElement
+    identities: Dictstr, XsdIdentity
+    global_maps: TupleDictstr, Any, ...
+
+    missing_locations: Liststr
+
+    _lookup_function_resolver = {
         XSD_SIMPLE_TYPE: 'lookup_type',
         XSD_COMPLEX_TYPE: 'lookup_type',
         XSD_ELEMENT: 'lookup_element',
@@ -219,12 +160,8 @@
         XSD_NOTATION: 'lookup_notation',
     }
 
-    def __init__(self, validator, validation='strict'):
+    def __init__(self, validator: SchemaType, validation: str = 'strict') -> None:
         super(XsdGlobals, self).__init__(validation)
-        if not all(hasattr(validator, a) for a in ('meta_schema', 'BUILDERS_MAP')):
-            raise XMLSchemaValueError(
-                "The argument {!r} is not an XSD schema validator".format(validator)
-            )
 
         self.validator = validator
         self.namespaces = NamespaceResourcesMap()  # Registered schemas by namespace URI
@@ -242,12 +179,23 @@
         self.global_maps = (self.notations, self.types, self.attributes,
                             self.attribute_groups, self.groups, self.elements)
 
-    def __repr__(self):
+        self._builders: Dictstr, CallableElementType, SchemaType, Any = {
+            XSD_NOTATION: validator.xsd_notation_class,
+            XSD_SIMPLE_TYPE: validator.simple_type_factory,
+            XSD_COMPLEX_TYPE: validator.xsd_complex_type_class,
+            XSD_ATTRIBUTE: validator.xsd_attribute_class,
+            XSD_ATTRIBUTE_GROUP: validator.xsd_attribute_group_class,
+            XSD_GROUP: validator.xsd_group_class,
+            XSD_ELEMENT: validator.xsd_element_class,
+        }
+
+    def __repr__(self) -> str:
         return '%s(validator=%r, validation=%r)' % (
             self.__class__.__name__, self.validator, self.validation
         )
 
-    def copy(self, validator=None, validation=None):
+    def copy(self, validator: OptionalSchemaType = None,
+             validation: Optionalstr = None) -> 'XsdGlobals':
         """Makes a copy of the object."""
         obj = self.__class__(self.validator if validator is None else validator,
                              validation or self.validation)
@@ -265,25 +213,7 @@
 
     __copy__ = copy
 
-    def lookup_notation(self, qname: str) -> XsdNotation:
-        return lookup_notation(qname, self.notations, self.validator.BUILDERS_MAP)
-
-    def lookup_type(self, qname: str) -> UnionXsdSimpleType, XsdComplexType:
-        return lookup_type(qname, self.types, self.validator.BUILDERS_MAP)
-
-    def lookup_attribute(self, qname: str) -> XsdAttribute:
-        return lookup_attribute(qname, self.attributes, self.validator.BUILDERS_MAP)
-
-    def lookup_attribute_group(self, qname: str) -> XsdAttributeGroup:
-        return lookup_attribute_group(qname, self.attribute_groups, self.validator.BUILDERS_MAP)
-
-    def lookup_group(self, qname: str) -> XsdGroup:
-        return lookup_group(qname, self.groups, self.validator.BUILDERS_MAP)
-
-    def lookup_element(self, qname: str) -> XsdElement:
-        return lookup_element(qname, self.elements, self.validator.BUILDERS_MAP)
-
-    def lookup(self, tag, qname):
+    def lookup(self, tag: str, qname: str) -> SchemaGlobalType:
         """
         General lookup method for XSD global components.
 
@@ -295,53 +225,169 @@
         :raises: an XMLSchemaValueError if the *tag* argument is not appropriate for a global \
         component, an XMLSchemaKeyError if the *qname* argument is not found in the global map.
         """
+        lookup_function: Callablestr, SchemaGlobalType
         try:
-            lookup_function = getattr(self, self._lookup_resolvertag)
+            lookup_function = getattr(self, self._lookup_function_resolvertag)
         except KeyError:
             msg = "wrong tag {!r} for an XSD global definition/declaration"
             raise XMLSchemaValueError(msg.format(tag)) from None
         else:
             return lookup_function(qname)
 
-    def get_instance_type(self, type_name, base_type, namespaces):
+    def lookup_notation(self, qname: str) -> XsdNotation:
+        try:
+            obj = self.notationsqname
+        except KeyError:
+            raise XMLSchemaKeyError(f'xs:notation {qname!r} not found')
+        else:
+            if isinstance(obj, XsdNotation):
+                return obj
+            return cast(XsdNotation, self._build_global(obj, qname, self.notations))
+
+    def lookup_type(self, qname: str) -> BaseXsdType:
+        try:
+            obj = self.typesqname
+        except KeyError:
+            raise XMLSchemaKeyError(f'global xs:simpleType/xs:complexType {qname!r} not found')
+        else:
+            if isinstance(obj, (XsdSimpleType, XsdComplexType)):
+                return obj
+            return cast(BaseXsdType, self._build_global(obj, qname, self.types))
+
+    def lookup_attribute(self, qname: str) -> XsdAttribute:
+        try:
+            obj = self.attributesqname
+        except KeyError:
+            raise XMLSchemaKeyError(f'global xs:attribute {qname!r} not found')
+        else:
+            if isinstance(obj, XsdAttribute):
+                return obj
+            return cast(XsdAttribute, self._build_global(obj, qname, self.attributes))
+
+    def lookup_attribute_group(self, qname: str) -> XsdAttributeGroup:
+        try:
+            obj = self.attribute_groupsqname
+        except KeyError:
+            raise XMLSchemaKeyError(f'global xs:attributeGroup {qname!r} not found')
+        else:
+            if isinstance(obj, XsdAttributeGroup):
+                return obj
+            return cast(XsdAttributeGroup, self._build_global(obj, qname, self.attribute_groups))
+
+    def lookup_group(self, qname: str) -> XsdGroup:
+        try:
+            obj = self.groupsqname
+        except KeyError:
+            raise XMLSchemaKeyError(f'global xs:group {qname!r} not found')
+        else:
+            if isinstance(obj, XsdGroup):
+                return obj
+            return cast(XsdGroup, self._build_global(obj, qname, self.groups))
+
+    def lookup_element(self, qname: str) -> XsdElement:
+        try:
+            obj = self.elementsqname
+        except KeyError:
+            raise XMLSchemaKeyError(f'global xs:element {qname!r} not found')
+        else:
+            if isinstance(obj, XsdElement):
+                return obj
+            return cast(XsdElement, self._build_global(obj, qname, self.elements))
+
+    def _build_global(self, obj: Any, qname: str,
+                      global_map: Dictstr, Any) -> Any:
+        factory_or_class: CallableElementType, SchemaType, Any
+
+        if isinstance(obj, tuple):
+            # Not built XSD global component without redefinitions
+            try:
+                elem, schema = obj
+            except ValueError:
+                return obj0  # Circular build, simply return (elem, schema) couple
+
+            try:
+                factory_or_class = self._builderselem.tag
+            except KeyError:
+                raise XMLSchemaKeyError("wrong element %r for map %r." % (elem, global_map))
+
+            global_mapqname = obj,  # Encapsulate into a tuple to catch circular builds
+            global_mapqname = factory_or_class(elem, schema)
+            return global_mapqname
+
+        elif isinstance(obj, list):
+            # Not built XSD global component with redefinitions
+            try:
+                elem, schema = obj0
+            except ValueError:
+                return obj00  # Circular build, simply return (elem, schema) couple
+
+            try:
+                factory_or_class = self._builderselem.tag
+            except KeyError:
+                raise XMLSchemaKeyError("wrong element %r for map %r." % (elem, global_map))
+
+            global_mapqname = obj0,  # To catch circular builds
+            global_mapqname = component = factory_or_class(elem, schema)
+
+            # Apply redefinitions (changing elem involve a re-parsing of the component)
+            for elem, schema in obj1::
+                if component.schema.target_namespace != schema.target_namespace:
+                    msg = "redefined schema {!r} has a different targetNamespace"
+                    raise XMLSchemaValueError(msg.format(schema))
+
+                component.redefine = component.copy()
+                component.redefine.parent = component
+                component.schema = schema
+                component.elem = elem
+
+            return global_mapqname
+
+        else:
+            raise XMLSchemaTypeError(f"unexpected instance {obj} in global map")
+
+    def get_instance_type(self, type_name: str, base_type: BaseXsdType,
+                          namespaces: MutableMappingstr, str) -> BaseXsdType:
         """
         Returns the instance XSI type from global maps, validating it with the reference base type.
 
         :param type_name: the XSI type attribute value, a QName in prefixed format.
         :param base_type: the XSD from which the instance type has to be derived.
-        :param namespaces: a map from prefixes to namespaces.
+        :param namespaces: a mapping from prefixes to namespaces.
         """
-        if base_type.is_complex() and XSI_TYPE in base_type.attributes:
-            base_type.attributesXSI_TYPE.validate(type_name)
+        if isinstance(base_type, XsdComplexType) and XSI_TYPE in base_type.attributes:
+            xsd_attribute = cast(XsdAttribute, base_type.attributesXSI_TYPE)
+            xsd_attribute.validate(type_name)
 
         extended_name = get_extended_qname(type_name, namespaces)
-        xsi_type = lookup_type(extended_name, self.types, self.validator.BUILDERS_MAP)
+        xsi_type = self.lookup_type(extended_name)
         if xsi_type.is_derived(base_type):
             return xsi_type
-        elif base_type.is_union() and not base_type.facets:
+        elif isinstance(base_type, XsdSimpleType) and \
+                base_type.is_union() and not base_type.facets:
             # Can be valid only if the union doesn't have facets, see:
             #   https://www.w3.org/Bugs/Public/show_bug.cgi?id=4065
-            try:
+            if isinstance(base_type, XsdAtomicRestriction) and \
+                    isinstance(base_type.primitive_type, XsdUnion):
                 if xsi_type in base_type.primitive_type.member_types:
                     return xsi_type
-            except AttributeError:
+            elif isinstance(base_type, XsdUnion):
                 if xsi_type in base_type.member_types:
                     return xsi_type
 
         raise XMLSchemaTypeError("%r cannot substitute %r" % (xsi_type, base_type))
 
     @property
-    def built(self):
+    def built(self) -> bool:
         return all(schema.built for schema in self.iter_schemas())
 
     @property
-    def unbuilt(self):
+    def unbuilt(self) -> ListUnionXsdComponent, SchemaType:
         """Property that returns a list with unbuilt components."""
         return c for s in self.iter_schemas() for c in s.iter_components()
                 if c is not s and not c.built
 
     @property
-    def validation_attempted(self):
+    def validation_attempted(self) -> str:
         if self.built:
             return 'full'
         elif any(schema.validation_attempted == 'partial' for schema in self.iter_schemas()):
@@ -350,9 +396,9 @@
             return 'none'
 
     @property
-    def validity(self):
+    def validity(self) -> str:
         if not self.namespaces:
-            return False
+            return 'notKnown'
         if all(schema.validity == 'valid' for schema in self.iter_schemas()):
             return 'valid'
         elif any(schema.validity == 'invalid' for schema in self.iter_schemas()):
@@ -361,48 +407,47 @@
             return 'notKnown'
 
     @property
-    def xsd_version(self):
+    def xsd_version(self) -> str:
         return self.validator.XSD_VERSION
 
     @property
-    def builders_map(self):
-        return self.validator.BUILDERS_MAP
-
-    @property
-    def all_errors(self):
+    def all_errors(self) -> ListXMLSchemaParseError:
         errors = 
         for schema in self.iter_schemas():
             errors.extend(schema.all_errors)
         return errors
 
-    def create_bindings(self, *bases, **attrs):
+    def create_bindings(self, *bases: TypeAny, **attrs: Any) -> None:
         """Creates data object bindings for the XSD elements of built schemas."""
         for xsd_element in self.iter_components(xsd_classes=XsdElement):
+            assert isinstance(xsd_element, XsdElement)
             if xsd_element.target_namespace != XSD_NAMESPACE:
                 xsd_element.get_binding(*bases, replace_existing=True, **attrs)
 
-    def clear_bindings(self):
+    def clear_bindings(self) -> None:
         for xsd_element in self.iter_components(xsd_classes=XsdElement):
+            assert isinstance(xsd_element, XsdElement)
             xsd_element.binding = None
 
-    def iter_components(self, xsd_classes=None):
+    def iter_components(self, xsd_classes: ComponentClassType = None) \
+            -> IteratorUnion'XsdGlobals', XsdComponent:
         """Creates an iterator for the XSD components of built schemas."""
         if xsd_classes is None or isinstance(self, xsd_classes):
             yield self
         for xsd_global in self.iter_globals():
             yield from xsd_global.iter_components(xsd_classes)
 
-    def iter_globals(self):
+    def iter_globals(self) -> IteratorSchemaGlobalType:
         """Creates an iterator for the XSD global components of built schemas."""
         for global_map in self.global_maps:
             yield from global_map.values()
 
-    def iter_schemas(self):
+    def iter_schemas(self) -> IteratorSchemaType:
         """Creates an iterator for the registered schemas."""
         for schemas in self.namespaces.values():
             yield from schemas
 
-    def register(self, schema):
+    def register(self, schema: SchemaType) -> None:
         """Registers an XMLSchema instance."""
         try:
             ns_schemas = self.namespacesschema.target_namespace
@@ -411,12 +456,15 @@
         else:
             if schema in ns_schemas:
                 return
-            elif not any(schema.url == obj.url and schema.__class__ == obj.__class__
+            elif schema.url is None:
+                # only by multi-source init or add_schema() by user initiative
+                ns_schemas.append(schema)
+            elif not any(schema.url == obj.url and schema.__class__ is obj.__class__
                          for obj in ns_schemas):
                 ns_schemas.append(schema)
 
     @lru_cache(maxsize=1000)
-    def load_namespace(self, namespace, build=True):
+    def load_namespace(self, namespace: str, build: bool = True) -> bool:
         """
         Load namespace from available location hints. Returns `True` if the namespace
         is already loaded or if the namespace can be loaded from one of the locations,
@@ -471,13 +519,14 @@
 
         return False
 
-    def clear(self, remove_schemas=False, only_unbuilt=False):
+    def clear(self, remove_schemas: bool = False, only_unbuilt: bool = False) -> None:
         """
         Clears the instance maps and schemas.
 
         :param remove_schemas: removes also the schema instances.
         :param only_unbuilt: removes only not built objects/schemas.
         """
+        global_map: Dictstr, XsdComponent
         if only_unbuilt:
             not_built_schemas = {s for s in self.iter_schemas() if not s.built}
             if not not_built_schemas:
@@ -511,12 +560,11 @@
             if remove_schemas:
                 self.namespaces.clear()
 
-    def build(self):
+    def build(self) -> None:
         """
         Build the maps of XSD global definitions/declarations. The global maps are
         updated adding and building the globals of not built registered schemas.
         """
-
         try:
             meta_schema = self.namespacesXSD_NAMESPACE0
         except KeyError:
@@ -526,7 +574,13 @@
             meta_schema = None
 
         if meta_schema is None or meta_schema.meta_schema is not None:
-            # XSD namespace not imported: replace the meta-schema with a new one
+            # XSD namespace not imported or XSD namespace not managed by a meta-schema.
+            # Creates a new meta-schema instance from the XSD meta-schema source and
+            # replaces the default meta-schema instance in all registered schemas.
+            if self.validator.meta_schema is None:
+                msg = "missing default meta-schema instance {!r}"
+                raise XMLSchemaRuntimeError(msg.format(self.validator))
+
             url = self.validator.meta_schema.url
             base_schemas = {k: v for k, v in self.validator.meta_schema.BASE_SCHEMAS.items()
                             if k not in self.namespaces}
@@ -537,7 +591,7 @@
                     schema.meta_schema = meta_schema
         else:
             if not self.types and meta_schema.maps is not self:
-                for source_map, target_map in zip(meta_schema.global_maps, self.global_maps):
+                for source_map, target_map in zip(meta_schema.maps.global_maps, self.global_maps):
                     target_map.update(source_map)
 
         not_built_schemas = schema for schema in self.iter_schemas() if not schema.built
@@ -568,11 +622,12 @@
 
         for qname in self.attribute_groups:
             self.lookup_attribute_group(qname)
-        for schema in filter(
-                lambda x: isinstance(x.default_attributes, str),
-                not_built_schemas):
+        for schema in not_built_schemas:
+            if not isinstance(schema.default_attributes, str):
+                continue
+
             try:
-                schema.default_attributes = schema.maps.attribute_groupsschema.default_attributes
+                attributes = schema.maps.attribute_groupsschema.default_attributes
             except KeyError:
                 schema.default_attributes = None
                 msg = "defaultAttributes={!r} doesn't match an attribute group of {!r}"
@@ -581,6 +636,8 @@
                     elem=schema.root,
                     validation=schema.validation
                 )
+            else:
+                schema.default_attributes = cast(XsdAttributeGroup, attributes)
 
         for qname in self.types:
             self.lookup_type(qname)
@@ -601,7 +658,8 @@
 
         self.check(filter(lambda x: x.meta_schema is not None, not_built_schemas), self.validation)
 
-    def check(self, schemas=None, validation='strict'):
+    def check(self, schemas: OptionalIterableSchemaType = None,
+              validation: str = 'strict') -> None:
         """
         Checks the global maps. For default checks all schemas and raises an
         exception at first error.
@@ -610,11 +668,12 @@
         :param validation: overrides the default validation mode of the validator.
         :raise: XMLSchemaParseError
         """
-        schemas = set(schemas if schemas is not None else self.iter_schemas())
+        _schemas = set(schemas if schemas is not None else self.iter_schemas())
 
-        # Checks substitution groups circularities
+        # Checks substitution groups circularity
         for qname in self.substitution_groups:
             xsd_element = self.elementsqname
+            assert isinstance(xsd_element, XsdElement), "global element not built!"
             if any(e is xsd_element for e in xsd_element.iter_substitutes()):
                 msg = "circularity found for substitution group with head element %r"
                 xsd_element.parse_error(msg.format(xsd_element), validation=validation)
@@ -625,8 +684,11 @@
             )
 
         # Check redefined global groups restrictions
-        for group in filter(lambda x: x.schema in schemas and x.redefine is not None,
-                            self.groups.values()):
+        for group in self.groups.values():
+            assert isinstance(group, XsdGroup), "global group not built!"
+            if group.schema not in _schemas or group.redefine is None:
+                continue
+
             while group.redefine is not None:
                 if not any(isinstance(e, XsdGroup) and e.name == group.name for e in group) \
                         and not group.is_restriction(group.redefine):
@@ -636,7 +698,8 @@
                 group = group.redefine
 
         # Check complex content types models restrictions
-        for xsd_global in filter(lambda x: x.schema in schemas, self.iter_globals()):
+        for xsd_global in filter(lambda x: x.schema in _schemas, self.iter_globals()):
+            xsd_type: Any
             for xsd_type in xsd_global.iter_components(XsdComplexType):
                 if not isinstance(xsd_type.content, XsdGroup):
                     continue
@@ -650,13 +713,13 @@
 
                     if base_type.is_complex() and not base_type.open_content and \
                             xsd_type.open_content and xsd_type.open_content.mode != 'none':
-                        group = xsd_type.schema.create_any_content_group(
+                        _group = xsd_type.schema.create_any_content_group(
                             parent=xsd_type,
                             any_element=xsd_type.open_content.any_element
                         )
-                        if not group.is_restriction(base_type.content):
+                        if not _group.is_restriction(base_type.content):
                             msg = "restriction has an open content but base type has not"
-                            group.parse_error(msg, validation=validation)
+                            _group.parse_error(msg, validation=validation)
 
                 try:
                     xsd_type.content.check_model()

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/validators/groups.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/validators/groups.py Changed

@@ -11,24 +11,31 @@
 This module contains classes for XML Schema model groups.
 """
 import warnings
-from collections.abc import MutableMapping, MutableSequence
+from collections.abc import MutableMapping
+from typing import TYPE_CHECKING, overload, Any, Iterable, Iterator, List, \
+    MutableSequence, Optional, Tuple, Union
 
 from .. import limits
 from ..exceptions import XMLSchemaValueError
 from ..names import XSD_GROUP, XSD_SEQUENCE, XSD_ALL, XSD_CHOICE, XSD_ELEMENT, \
     XSD_ANY, XSI_TYPE, XSD_ANY_TYPE, XSD_ANNOTATION
-from ..etree import etree_element
-from ..helpers import get_qname, local_name, not_whitespace, raw_xml_encode
+from ..etree import etree_element, ElementData
+from ..aliases import ElementType, NamespacesType, SchemaType, IterDecodeType, \
+    IterEncodeType, ModelParticleType, SchemaElementType, ComponentClassType
+from ..helpers import get_qname, local_name, raw_xml_encode
 
 from .exceptions import XMLSchemaModelError, XMLSchemaModelDepthError, \
     XMLSchemaValidationError, XMLSchemaChildrenValidationError, \
     XMLSchemaTypeTableWarning
 from .xsdbase import ValidationMixin, XsdComponent, XsdType
-from .particles import ParticleMixin, ModelGroup
-from .elements import XsdElement
+from .particles import ParticleMixin, OccursCalculator
+from .elements import XsdElement, XsdAlternative
 from .wildcards import XsdAnyElement, Xsd11AnyElement
 from .models import ModelVisitor, distinguishable_paths
 
+if TYPE_CHECKING:
+    from .complex_types import XsdComplexType
+
 ANY_ELEMENT = etree_element(
     XSD_ANY,
     attrib={
@@ -38,8 +45,12 @@
         'maxOccurs': 'unbounded'
     })
 
+GroupDecodeType = ListTupleUnionstr, int, Any, OptionalSchemaElementType
+GroupEncodeType = TupleOptionalstr, ListElementType
+
 
-class XsdGroup(XsdComponent, ModelGroup, ValidationMixin):
+class XsdGroup(XsdComponent, MutableSequenceModelParticleType,
+               ParticleMixin, ValidationMixinElementType, GroupDecodeType):
     """
     Class for XSD 1.0 *model group* definitions.
 
@@ -77,33 +88,313 @@
           Content: (annotation?, (element | group | choice | sequence | any)*)
         </sequence>
     """
-    mixed = False
-    restriction = None
-    interleave = None  # an Xsd11AnyElement in case of XSD 1.1 openContent with mode='interleave'
-    suffix = None  # an Xsd11AnyElement in case of openContent with mode='suffix' or 'interleave'
+    parent: OptionalUnion'XsdComplexType', 'XsdGroup'
+    model: str
+    mixed: bool = False
+    ref: Optional'XsdGroup'
+    restriction: Optional'XsdGroup' = None
+
+    # For XSD 1.1 openContent processing
+    interleave: OptionalXsd11AnyElement = None  # if openContent with mode='interleave'
+    suffix: OptionalXsd11AnyElement = None  # if openContent with mode='suffix'/'interleave'
 
     _ADMITTED_TAGS = {XSD_GROUP, XSD_SEQUENCE, XSD_ALL, XSD_CHOICE}
 
-    def __init__(self, elem, schema, parent):
-        self._group = 
+    def __init__(self, elem: ElementType,
+                 schema: SchemaType,
+                 parent: OptionalUnion'XsdComplexType', 'XsdGroup' = None) -> None:
+
+        self._group: ListModelParticleType = 
         if parent is not None and parent.mixed:
             self.mixed = parent.mixed
         super(XsdGroup, self).__init__(elem, schema, parent)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         if self.name is None:
-            return '%s(model=%r, occurs=%r)' % (self.__class__.__name__, self.model, self.occurs)
+            return '%s(model=%r, occurs=%r)' % (
+                self.__class__.__name__, self.model, list(self.occurs)
+            )
         elif self.ref is None:
             return '%s(name=%r, model=%r, occurs=%r)' % (
-                self.__class__.__name__, self.prefixed_name, self.model, self.occurs
+                self.__class__.__name__, self.prefixed_name, self.model, list(self.occurs)
             )
         else:
             return '%s(ref=%r, model=%r, occurs=%r)' % (
-                self.__class__.__name__, self.prefixed_name, self.model, self.occurs
+                self.__class__.__name__, self.prefixed_name, self.model, list(self.occurs)
             )
 
-    def copy(self):
-        group = object.__new__(self.__class__)
+    @overload
+    def __getitem__(self, i: int) -> ModelParticleType: ...
+
+    @overload
+    def __getitem__(self, s: slice) -> MutableSequenceModelParticleType: ...
+
+    def __getitem__(self, i: Unionint, slice) \
+            -> UnionModelParticleType, MutableSequenceModelParticleType:
+        return self._groupi
+
+    def __setitem__(self, i: Unionint, slice, o: Any) -> None:
+        self._groupi = o
+
+    def __delitem__(self, i: Unionint, slice) -> None:
+        del self._groupi
+
+    def __len__(self) -> int:
+        return len(self._group)
+
+    def insert(self, i: int, item: ModelParticleType) -> None:
+        self._group.insert(i, item)
+
+    def clear(self) -> None:
+        del self._group:
+
+    def is_emptiable(self) -> bool:
+        if self.model == 'choice':
+            return self.min_occurs == 0 or not self or any(item.is_emptiable() for item in self)
+        else:
+            return self.min_occurs == 0 or not self or all(item.is_emptiable() for item in self)
+
+    def is_single(self) -> bool:
+        if self.max_occurs != 1 or not self:
+            return False
+        elif len(self) > 1 or not isinstance(self0, XsdGroup):
+            return True
+        else:
+            return self0.is_single()
+
+    def is_pointless(self, parent: 'XsdGroup') -> bool:
+        """
+        Returns `True` if the group may be eliminated without affecting the model,
+        `False` otherwise. A group is pointless if one of those conditions is verified:
+
+         - the group is empty
+         - minOccurs == maxOccurs == 1 and the group has one child
+         - minOccurs == maxOccurs == 1 and the group and its parent have a sequence model
+         - minOccurs == maxOccurs == 1 and the group and its parent have a choice model
+
+        Ref: https://www.w3.org/TR/2004/REC-xmlschema-1-20041028/#coss-particle
+
+        :param parent: effective parent of the model group.
+        """
+        if not self:
+            return True
+        elif self.min_occurs != 1 or self.max_occurs != 1:
+            return False
+        elif len(self) == 1:
+            return True
+        elif self.model == 'sequence' and parent.model != 'sequence':
+            return False
+        elif self.model == 'choice' and parent.model != 'choice':
+            return False
+        else:
+            return True
+
+    @property
+    def effective_min_occurs(self) -> int:
+        if not self.min_occurs or not self:
+            return 0
+        elif self.model == 'choice':
+            if any(not e.effective_min_occurs for e in self.iter_model()):
+                return 0
+        else:
+            if all(not e.effective_min_occurs for e in self.iter_model()):
+                return 0
+        return self.min_occurs
+
+    @property
+    def effective_max_occurs(self) -> Optionalint:
+        if self.max_occurs == 0 or not self:
+            return 0
+
+        effective_items: ListAny
+        value: int
+
+        effective_items = e for e in self.iter_model() if e.effective_max_occurs != 0
+        if not effective_items:
+            return 0
+        elif self.max_occurs is None:
+            return None
+        elif self.model == 'choice':
+            try:
+                value = max(e.effective_max_occurs for e in effective_items)
+            except TypeError:
+                return None
+            else:
+                return self.max_occurs * value
+
+        not_emptiable_items = e for e in effective_items if e.effective_min_occurs
+        if not not_emptiable_items:
+            try:
+                value = max(e.effective_max_occurs for e in effective_items)
+            except TypeError:
+                return None
+            else:
+                return self.max_occurs * value
+
+        elif len(not_emptiable_items) > 1:
+            return self.max_occurs
+
+        value = not_emptiable_items0.effective_max_occurs
+        return None if value is None else self.max_occurs * value
+
+    def has_occurs_restriction(
+            self, other: UnionModelParticleType, ParticleMixin, 'OccursCalculator') -> bool:
+
+        if not self:
+            return True
+        elif isinstance(other, XsdGroup):
+            return super(XsdGroup, self).has_occurs_restriction(other)
+
+        # Group particle compared to element particle
+        if self.max_occurs is None or any(e.max_occurs is None for e in self):
+            if other.max_occurs is not None:
+                return False
+            elif self.model == 'choice':
+                return self.min_occurs * min(e.min_occurs for e in self) >= other.min_occurs
+            else:
+                return self.min_occurs * sum(e.min_occurs for e in self) >= other.min_occurs
+
+        elif self.model == 'choice':
+            if self.min_occurs * min(e.min_occurs for e in self) < other.min_occurs:
+                return False
+            elif other.max_occurs is None:
+                return True
+            else:
+                value: int
+                try:
+                    value = max(e.max_occurs for e in self)  # type: ignoretype-var, assignment
+                except TypeError:
+                    return False
+                else:
+                    return self.max_occurs * value <= other.max_occurs
+
+        else:
+            if self.min_occurs * sum(e.min_occurs for e in self) < other.min_occurs:
+                return False
+            elif other.max_occurs is None:
+                return True
+            else:
+                try:
+                    value = sum(e.max_occurs for e in self)  # type: ignoremisc
+                except TypeError:
+                    return False
+                else:
+                    return self.max_occurs * value <= other.max_occurs
+
+    def iter_model(self) -> IteratorModelParticleType:
+        """
+        A generator function iterating elements and groups of a model group.
+        Skips pointless groups, iterating deeper through them.
+        Raises `XMLSchemaModelDepthError` if the *depth* of the model is over
+        `limits.MAX_MODEL_DEPTH` value.
+        """
+        iterators: ListIteratorModelParticleType = 
+        particles = iter(self)
+
+        while True:
+            try:
+                item = next(particles)
+            except StopIteration:
+                try:
+                    particles = iterators.pop()
+                except IndexError:
+                    return
+            else:
+                if isinstance(item, XsdGroup) and item.is_pointless(parent=self):
+                    iterators.append(particles)
+                    particles = iter(item)
+                    if len(iterators) > limits.MAX_MODEL_DEPTH:
+                        raise XMLSchemaModelDepthError(self)
+                else:
+                    yield item
+
+    def iter_elements(self) -> IteratorSchemaElementType:
+        """
+        A generator function iterating model's elements. Raises `XMLSchemaModelDepthError`
+        if the overall depth of the model groups is over `limits.MAX_MODEL_DEPTH`.
+        """
+        if self.max_occurs == 0:
+            return
+
+        iterators: ListIteratorModelParticleType = 
+        particles = iter(self)
+
+        while True:
+            try:
+                item = next(particles)
+            except StopIteration:
+                try:
+                    particles = iterators.pop()
+                except IndexError:
+                    return
+            else:
+                if isinstance(item, XsdGroup):
+                    iterators.append(particles)
+                    particles = iter(item)
+                    if len(iterators) > limits.MAX_MODEL_DEPTH:
+                        raise XMLSchemaModelDepthError(self)
+                else:
+                    yield item
+
+    def get_subgroups(self, item: ModelParticleType) -> List'XsdGroup':
+        """
+        Returns a list of the groups that represent the path to the enclosed particle.
+        Raises an `XMLSchemaModelError` if *item* is not a particle of the model group.
+        """
+        subgroups: ListTupleXsdGroup, IteratorModelParticleType = 
+        group, children = self, iter(self)
+
+        while True:
+            try:
+                child = next(children)
+            except StopIteration:
+                try:
+                    group, children = subgroups.pop()
+                except IndexError:
+                    msg = '{!r} is not a particle of the model group'
+                    raise XMLSchemaModelError(self, msg.format(item)) from None
+                else:
+                    continue
+
+            if child is item:
+                _subgroups = x0 for x in subgroups
+                _subgroups.append(group)
+                return _subgroups
+            elif isinstance(child, XsdGroup):
+                if len(subgroups) > limits.MAX_MODEL_DEPTH:
+                    raise XMLSchemaModelDepthError(self)
+                subgroups.append((group, children))
+                group, children = child, iter(child)
+
+    def overall_min_occurs(self, item: ModelParticleType) -> int:
+        """Returns the overall min occurs of a particle in the model."""
+        min_occurs = item.min_occurs
+
+        for group in self.get_subgroups(item):
+            if group.model == 'choice' and len(group) > 1:
+                return 0
+            min_occurs *= group.min_occurs
+
+        return min_occurs
+
+    def overall_max_occurs(self, item: ModelParticleType) -> Optionalint:
+        """Returns the overall max occurs of a particle in the model."""
+        max_occurs = item.max_occurs
+
+        for group in self.get_subgroups(item):
+            if max_occurs == 0:
+                return 0
+            elif max_occurs is None:
+                continue
+            elif group.max_occurs is None:
+                max_occurs = None
+            else:
+                max_occurs *= group.max_occurs
+
+        return max_occurs
+
+    def copy(self) -> 'XsdGroup':
+        group: XsdGroup = object.__new__(self.__class__)
         group.__dict__.update(self.__dict__)
         group.errors = self.errors:
         group._group = self._group:
@@ -111,8 +402,7 @@
 
     __copy__ = copy
 
-    def _parse(self):
-        super(XsdGroup, self)._parse()
+    def _parse(self) -> None:
         self.clear()
         self._parse_particle(self.elem)
 
@@ -123,20 +413,14 @@
             self._parse_content_model(self.elem)
 
         elif self._parse_reference():
+            assert self.name is not None
             try:
                 xsd_group = self.maps.lookup_group(self.name)
             except KeyError:
                 self.parse_error("missing group %r" % self.prefixed_name)
-                xsd_group = self.schema.create_any_content_group(self, self.name)
+                xsd_group = self.schema.create_any_content_group(parent=self)
 
-            if isinstance(xsd_group, tuple):
-                # Disallowed circular definition, substitute with any content group.
-                self.parse_error("Circular definitions detected for group %r:" % self.name,
-                                 xsd_group0)
-                self.model = 'sequence'
-                self.mixed = True
-                self.append(self.schema.BUILDERS.any_element_class(ANY_ELEMENT, self.schema, self))
-            else:
+            if isinstance(xsd_group, XsdGroup):
                 self.model = xsd_group.model
                 if self.model == 'all':
                     if self.max_occurs != 1:
@@ -145,8 +429,15 @@
                         self.parse_error("minOccurs must be (0 | 1) for 'all' model groups")
                     if self.xsd_version == '1.0' and isinstance(self.parent, XsdGroup):
                         self.parse_error("in XSD 1.0 the 'all' model group cannot be nested")
-                self.append(xsd_group)
+                self._group.append(xsd_group)
                 self.ref = xsd_group
+            else:
+                # Disallowed circular definition, substitute with any content group.
+                self.parse_error("Circular definitions detected for group %r:" % self.name,
+                                 xsd_group0)
+                self.model = 'sequence'
+                self.mixed = True
+                self._group.append(self.schema.xsd_any_class(ANY_ELEMENT, self.schema, self))
 
         else:
             attrib = self.elem.attrib
@@ -155,7 +446,6 @@
             except KeyError:
                 pass
             else:
-                content_model = self._parse_child_component(self.elem, strict=True)
                 if self.parent is not None:
                     self.parse_error("attribute 'name' not allowed for a local group")
                 else:
@@ -163,19 +453,23 @@
                         self.parse_error("attribute 'minOccurs' not allowed for a global group")
                     if 'maxOccurs' in attrib:
                         self.parse_error("attribute 'maxOccurs' not allowed for a global group")
-                    if 'minOccurs' in content_model.attrib:
-                        self.parse_error("attribute 'minOccurs' not allowed for the model "
-                                         "of a global group", content_model)
-                    if 'maxOccurs' in content_model.attrib:
-                        self.parse_error("attribute 'maxOccurs' not allowed for the model "
-                                         "of a global group", content_model)
-
-                if content_model.tag in {XSD_SEQUENCE, XSD_ALL, XSD_CHOICE}:
-                    self._parse_content_model(content_model)
-                else:
-                    self.parse_error('unexpected tag %r' % content_model.tag, content_model)
 
-    def _parse_content_model(self, content_model):
+                content_model = self._parse_child_component(self.elem, strict=True)
+                if content_model is not None:
+                    if self.parent is None:
+                        if 'minOccurs' in content_model.attrib:
+                            self.parse_error("attribute 'minOccurs' not allowed for the model "
+                                             "of a global group", content_model)
+                        if 'maxOccurs' in content_model.attrib:
+                            self.parse_error("attribute 'maxOccurs' not allowed for the model "
+                                             "of a global group", content_model)
+
+                    if content_model.tag in {XSD_SEQUENCE, XSD_ALL, XSD_CHOICE}:
+                        self._parse_content_model(content_model)
+                    else:
+                        self.parse_error('unexpected tag %r' % content_model.tag, content_model)
+
+    def _parse_content_model(self, content_model: ElementType) -> None:
         self.model = local_name(content_model.tag)
         if self.model == 'all':
             if self.max_occurs != 1:
@@ -183,18 +477,19 @@
             if self.min_occurs not in (0, 1):
                 self.parse_error("minOccurs must be (0 | 1) for 'all' model groups")
 
+        child: ElementType
         for child in content_model:
             if child.tag == XSD_ANNOTATION or callable(child.tag):
                 continue
             elif child.tag == XSD_ELEMENT:
-                # Builds inner elements and reference groups later, for avoids circularity.
-                self.append((child, self.schema))
+                # Builds inner elements later, for avoid circularity.
+                self.append(self.schema.xsd_element_class(child, self.schema, self, False))
             elif content_model.tag == XSD_ALL:
                 self.parse_error("'all' model can contains only elements.")
             elif child.tag == XSD_ANY:
-                self.append(XsdAnyElement(child, self.schema, self))
+                self._group.append(XsdAnyElement(child, self.schema, self))
             elif child.tag in (XSD_SEQUENCE, XSD_CHOICE):
-                self.append(XsdGroup(child, self.schema, self))
+                self._group.append(XsdGroup(child, self.schema, self))
             elif child.tag == XSD_GROUP:
                 try:
                     ref = self.schema.resolve_qname(child.attrib'ref')
@@ -211,53 +506,30 @@
                         self.parse_error("'all' model can appears only at 1st level "
                                          "of a model group")
                     else:
-                        self.append(xsd_group)
+                        self._group.append(xsd_group)
                 elif self.redefine is None:
                     self.parse_error("Circular definition detected for group %r:" % self.name)
                 else:
                     if child.get('minOccurs', '1') != '1' or child.get('maxOccurs', '1') != '1':
                         self.parse_error("Redefined group reference cannot have "
                                          "minOccurs/maxOccurs other than 1:")
-                    self.append(self.redefine)
+                    self._group.append(self.redefine)
 
-    def children_validation_error(self, validation, elem, index, particle, occurs=0, expected=None,
-                                  source=None, namespaces=None, **_kwargs):
-        """
-        Helper method for generating model validation errors. If validation mode
-        is 'lax' or 'skip' returns the error, otherwise raise the error.
-
-        :param validation: the validation mode. Can be 'lax' or 'strict'.
-        :param elem: the instance Element.
-        :param index: the child index.
-        :param particle: the XSD component (subgroup or element) associated to the child.
-        :param occurs: the child tag occurs.
-        :param expected: the expected element tags/object names.
-        :param source: the XML resource related to the validation process.
-        :param namespaces: is an optional mapping from namespace prefix to URI.
-        :param _kwargs: keyword arguments of the validation process that are not used.
-        """
-        error = XMLSchemaChildrenValidationError(self, elem, index, particle, occurs,
-                                                 expected, source, namespaces)
-        if validation == 'strict':
-            raise error
-        return error
-
-    def build(self):
-        element_class = self.schema.BUILDERS.element_class
-        for k in range(len(self._group)):
-            if isinstance(self._groupk, tuple):
-                elem, schema = self._groupk
-                self._groupk = element_class(elem, schema, self)
+    def build(self) -> None:
+        for item in self._group:
+            if isinstance(item, XsdElement):
+                item.build()
 
         if self.redefine is not None:
             for group in self.redefine.iter_components(XsdGroup):
                 group.build()
 
     @property
-    def built(self):
+    def built(self) -> bool:
         for item in self:
-            if not isinstance(item, ParticleMixin):
-                return False
+            if isinstance(item, XsdElement):
+                if not item.built:
+                    return False
             elif isinstance(item, XsdAnyElement):
                 continue
             elif item.parent is None:
@@ -271,7 +543,7 @@
         return True if self.model else False
 
     @property
-    def validation_attempted(self):
+    def validation_attempted(self) -> str:
         if self.built:
             return 'full'
         elif any(item.validation_attempted == 'partial' for item in self):
@@ -280,10 +552,11 @@
             return 'none'
 
     @property
-    def schema_elem(self):
-        return self.elem if self.name else self.parent.elem
+    def schema_elem(self) -> ElementType:
+        return self.parent.elem if self.parent is not None else self.elem
 
-    def iter_components(self, xsd_classes=None):
+    def iter_components(self, xsd_classes: OptionalComponentClassType = None) \
+            -> IteratorXsdComponent:
         if xsd_classes is None or isinstance(self, xsd_classes):
             yield self
         for item in self:
@@ -297,7 +570,7 @@
         if self.redefine is not None and self.redefine not in self:
             yield from self.redefine.iter_components(xsd_classes)
 
-    def admits_restriction(self, model):
+    def admits_restriction(self, model: str) -> bool:
         if self.model == model:
             return True
         elif self.model == 'all':
@@ -307,14 +580,14 @@
         else:
             return model == 'choice' or len(self.ref or self) <= 1
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         return not self.mixed and (not self._group or self.max_occurs == 0)
 
-    def is_restriction(self, other, check_occurs=True):
+    def is_restriction(self, other: ModelParticleType, check_occurs: bool = True) -> bool:
         if not self._group:
             return True
         elif not isinstance(other, ParticleMixin):
-            raise XMLSchemaValueError("the argument 'base' must be a %r instance" % ParticleMixin)
+            raise XMLSchemaValueError("the argument 'other' must be an XSD particle")
         elif not isinstance(other, XsdGroup):
             return self.is_element_restriction(other)
         elif not other:
@@ -334,10 +607,10 @@
             return self.is_sequence_restriction(other)
         elif other.model == 'all':
             return self.is_all_restriction(other)
-        elif other.model == 'choice':
+        else:  # other.model == 'choice':
             return self.is_choice_restriction(other)
 
-    def is_element_restriction(self, other):
+    def is_element_restriction(self, other: ModelParticleType) -> bool:
         if self.xsd_version == '1.0' and isinstance(other, XsdElement) and \
                 not other.ref and other.name not in self.schema.substitution_groups:
             return False
@@ -350,7 +623,8 @@
                 return True
             return any(e.is_restriction(other, False) for e in self)
         else:
-            min_occurs = max_occurs = 0
+            min_occurs = 0
+            max_occurs: Optionalint = 0
             for item in self.iter_model():
                 if isinstance(item, XsdGroup):
                     return False
@@ -373,7 +647,7 @@
             else:
                 return max_occurs <= other.max_occurs
 
-    def is_sequence_restriction(self, other):
+    def is_sequence_restriction(self, other: 'XsdGroup') -> bool:
         if not self.has_occurs_restriction(other):
             return False
 
@@ -413,12 +687,15 @@
                 if not other_item.is_emptiable():
                     return False
 
-    def is_all_restriction(self, other):
+    def is_all_restriction(self, other: 'XsdGroup') -> bool:
         if not self.has_occurs_restriction(other):
             return False
 
         check_occurs = other.max_occurs != 0
-        restriction_items = list(self) if self.ref is None else list(self0)
+        if self.ref is None:
+            restriction_items = x for x in self
+        else:
+            restriction_items = x for x in self0
 
         for other_item in other.iter_model():
             for item in restriction_items:
@@ -432,19 +709,19 @@
 
         return not bool(restriction_items)
 
-    def is_choice_restriction(self, other):
+    def is_choice_restriction(self, other: 'XsdGroup') -> bool:
         if self.ref is None:
             if self.parent is None and other.parent is not None:
                 return False  # not allowed restriction in XSD 1.0
-            restriction_items = list(self)
+            restriction_items = x for x in self
         elif other.parent is None:
-            restriction_items = list(self0)
+            restriction_items = x for x in self0
         else:
             return False  # not allowed restriction in XSD 1.0
 
         check_occurs = other.max_occurs != 0
-        max_occurs = 0
-        other_max_occurs = 0
+        max_occurs: Optionalint = 0
+        other_max_occurs: Optionalint = 0
 
         for other_item in other.iter_model():
             for item in restriction_items:
@@ -485,31 +762,45 @@
         else:
             return other_max_occurs >= max_occurs * self.max_occurs
 
-    def check_model(self):
+    def check_model(self) -> None:
         """
         Checks if the model group is deterministic. Element Declarations Consistent and
         Unique Particle Attribution constraints are checked.
         :raises: an `XMLSchemaModelError` at first violated constraint.
         """
-        def safe_iter_path(group, depth):
-            if not depth:
-                raise XMLSchemaModelDepthError(group)
-            for item in group:
-                if isinstance(item, ModelGroup):
-                    current_path.append(item)
-                    yield from safe_iter_path(item, depth - 1)
-                    current_path.pop()
+        def safe_iter_path() -> IteratorSchemaElementType:
+            iterators: ListIteratorModelParticleType = 
+            particles = iter(self)
+
+            while True:
+                try:
+                    item = next(particles)
+                except StopIteration:
+                    try:
+                        current_path.pop()
+                        particles = iterators.pop()
+                    except IndexError:
+                        return
                 else:
-                    yield item
+                    if isinstance(item, XsdGroup):
+                        current_path.append(item)
+                        iterators.append(particles)
+                        particles = iter(item)
+                        if len(iterators) > limits.MAX_MODEL_DEPTH:
+                            raise XMLSchemaModelDepthError(self)
+                    else:
+                        yield item
 
-        paths = {}
-        current_path = self
+        paths: Any = {}
+        current_path: ListModelParticleType = self
         try:
-            any_element = self.parent.open_content.any_element
+            any_element = self.parent.open_content.any_element  # type: ignoreunion-attr
         except AttributeError:
             any_element = None
 
-        for e in safe_iter_path(self, limits.MAX_MODEL_DEPTH):
+        for e in safe_iter_path():
+
+            previous_path: ListModelParticleType
             for pe, previous_path in paths.values():
                 # EDC check
                 if not e.is_consistent(pe) or any_element and not any_element.is_consistent(pe):
@@ -544,15 +835,19 @@
 
             pathse.name = e, current_path:
 
-    def check_dynamic_context(self, elem, xsd_element, model_element, namespaces):
-        if model_element is not xsd_element:
+    def check_dynamic_context(self, elem: ElementType,
+                              xsd_element: SchemaElementType,
+                              model_element: SchemaElementType,
+                              namespaces: NamespacesType) -> None:
+
+        if model_element is not xsd_element and isinstance(model_element, XsdElement):
             if 'substitution' in model_element.block \
-                    or xsd_element.type.is_blocked(model_element):
+                    or xsd_element.type and xsd_element.type.is_blocked(model_element):
                 raise XMLSchemaValidationError(
                     model_element, elem, "substitution of %r is blocked" % model_element
                 )
 
-        alternatives = ()
+        alternatives: UnionTuple(), ListXsdAlternative = 
         if isinstance(xsd_element, XsdAnyElement):
             if xsd_element.process_contents == 'skip':
                 return
@@ -593,7 +888,8 @@
                         type_name, xsd_element.type, namespaces
                     )
 
-            if model_element is not xsd_element and model_element.block:
+            if model_element is not xsd_element and \
+                    isinstance(model_element, XsdElement) and model_element.block:
                 for derivation in model_element.block.split():
                     if xsd_type is not model_element.type and \
                             xsd_type.is_derived(model_element.type, derivation):
@@ -609,8 +905,10 @@
         group = self.restriction if self.restriction is not None else self
 
         # Dynamic EDC check of matched element
-        for e in filter(lambda x: isinstance(x, XsdElement), group.iter_elements()):
-            if e.name == elem.tag:
+        for e in group.iter_elements():
+            if not isinstance(e, XsdElement):
+                continue
+            elif e.name == elem.tag:
                 other = e
             else:
                 for other in e.iter_substitutes():
@@ -623,12 +921,14 @@
                     not xsd_type.is_dynamic_consistent(other.type):
                 reason = "%r that matches %r is not consistent with local declaration %r"
                 raise XMLSchemaValidationError(self, reason % (elem, xsd_element, other))
-            elif not all(any(a == x for x in alternatives) for a in other.alternatives) or \
+
+            if not all(any(a == x for x in alternatives) for a in other.alternatives) or \
                     not all(any(a == x for x in other.alternatives) for a in alternatives):
                 msg = "Maybe a not equivalent type table between elements %r and %r."
                 warnings.warn(msg % (self, xsd_element), XMLSchemaTypeTableWarning, stacklevel=3)
 
-    def match_element(self, name, default_namespace=None):
+    def match_element(self, name: str, default_namespace: Optionalstr = None) \
+            -> OptionalSchemaElementType:
         """
         Try a model-less match of a child element. Returns the
         matched element, or `None` if there is no match.
@@ -636,38 +936,41 @@
         for xsd_element in self.iter_elements():
             if xsd_element.is_matching(name, default_namespace, group=self):
                 return xsd_element
+        return None
 
-    def iter_decode(self, elem, validation='lax', **kwargs):
+    def iter_decode(self, obj: ElementType, validation: str = 'lax', **kwargs: Any) \
+            -> IterDecodeTypeGroupDecodeType:
         """
         Creates an iterator for decoding an Element content.
 
-        :param elem: the Element that has to be decoded.
+        :param obj: an Element.
         :param validation: the validation mode, can be 'lax', 'strict' or 'skip'.
         :param kwargs: keyword arguments for the decoding process.
         :return: yields a list of 3-tuples (key, decoded data, decoder), \
         eventually preceded by a sequence of validation or decoding errors.
         """
-        result_list = 
+        result_list: GroupDecodeType = 
         cdata_index = 1  # keys for CDATA sections are positive integers
 
         if not self._group and self.model == 'choice' and self.min_occurs:
             reason = "an empty 'choice' group with minOccurs > 0 cannot validate any content"
-            yield self.validation_error(validation, reason, elem, **kwargs)
+            yield self.validation_error(validation, reason, obj, **kwargs)
             yield result_list
             return
 
         if not self.mixed:
             # Check element CDATA
-            if not_whitespace(elem.text) or any(not_whitespace(child.tail) for child in elem):
+            if obj.text and obj.text.strip() or \
+                    any(child.tail and child.tail.strip() for child in obj):
                 if len(self) == 1 and isinstance(self0, XsdAnyElement):
                     pass  # XsdAnyElement() equals to an empty complexType declaration
                 else:
                     reason = "character data between child elements not allowed"
-                    yield self.validation_error(validation, reason, elem, **kwargs)
+                    yield self.validation_error(validation, reason, obj, **kwargs)
                     cdata_index = 0  # Do not decode CDATA
 
-        if cdata_index and elem.text is not None:
-            text = str(elem.text.strip())
+        if cdata_index and obj.text is not None:
+            text = str(obj.text.strip())
             if text:
                 result_list.append((cdata_index, text, None))
                 cdata_index += 1
@@ -676,7 +979,7 @@
         over_max_depth = 'max_depth' in kwargs and kwargs'max_depth' <= level
         if level > limits.MAX_XML_DEPTH:
             reason = "XML data depth exceeded (MAX_XML_DEPTH=%r)" % limits.MAX_XML_DEPTH
-            self.validation_error('strict', reason, elem, **kwargs)
+            self.validation_error('strict', reason, obj, **kwargs)
 
         try:
             namespaces = kwargs'namespaces'
@@ -688,11 +991,15 @@
             except AttributeError:
                 default_namespace = None
 
+        errors: ListTupleint, ModelParticleType, int, OptionalListSchemaElementType
+        xsd_element: OptionalSchemaElementType
+        expected: OptionalListSchemaElementType
+
         model = ModelVisitor(self)
         errors = 
         broken_model = False
 
-        for index, child in enumerate(elem):
+        for index, child in enumerate(obj):
             if callable(child.tag):
                 continue  # child is a <class 'lxml.etree._Comment'>
 
@@ -719,7 +1026,7 @@
                 try:
                     self.check_dynamic_context(child, xsd_element, model.element, namespaces)
                 except XMLSchemaValidationError as err:
-                    yield self.validation_error(validation, err, elem, **kwargs)
+                    yield self.validation_error(validation, err, obj, **kwargs)
 
                 for particle, occurs, expected in model.advance(True):
                     errors.append((index, particle, occurs, expected))
@@ -750,8 +1057,8 @@
                 continue
             elif over_max_depth:
                 if 'depth_filler' in kwargs:
-                    obj = kwargs'depth_filler'
-                    result_list.append((child.tag, obj(xsd_element), xsd_element))
+                    func = kwargs'depth_filler'
+                    result_list.append((child.tag, func(xsd_element), xsd_element))
                 continue
 
             for result in xsd_element.iter_decode(child, validation, **kwargs):
@@ -771,31 +1078,37 @@
                         cdata_index += 1
 
         if model.element is not None:
-            index = len(elem)
+            index = len(obj)
             for particle, occurs, expected in model.stop():
                 errors.append((index, particle, occurs, expected))
 
         if errors:
-            for model_error in errors:
-                yield self.children_validation_error(validation, elem, *model_error, **kwargs)
+            source = kwargs.get('source')
+            for index, particle, occurs, expected in errors:
+                error = XMLSchemaChildrenValidationError(
+                    self, obj, index, particle, occurs, expected, source, namespaces
+                )
+                if validation == 'strict':
+                    raise error
+                yield error
 
         yield result_list
 
-    def iter_encode(self, element_data, validation='lax', **kwargs):
+    def iter_encode(self, obj: ElementData, validation: str = 'lax', **kwargs: Any) \
+            -> IterEncodeTypeGroupEncodeType:
         """
         Creates an iterator for encoding data to a list containing Element data.
 
-        :param element_data: an ElementData instance with unencoded data.
+        :param obj: an ElementData instance.
         :param validation: the validation mode: can be 'lax', 'strict' or 'skip'.
         :param kwargs: keyword arguments for the encoding process.
-        :return: yields a couple with the text of the Element and a list of 3-tuples \
-        (key, decoded data, decoder), eventually preceded by a sequence of validation \
-        or encoding errors.
+        :return: yields a couple with the text of the Element and a list of child \
+        elements, eventually preceded by a sequence of validation errors.
         """
         level = kwargs'level' = kwargs.get('level', 0) + 1
         errors = 
-        text = raw_xml_encode(element_data.text)
-        children = 
+        text = raw_xml_encode(obj.text)
+        children: ListElementType = 
         try:
             indent = kwargs'indent'
         except KeyError:
@@ -814,17 +1127,22 @@
         wrong_content_type = False
         over_max_depth = 'max_depth' in kwargs and kwargs'max_depth' <= level
 
-        if element_data.content is None:
+        content: IterableAny
+        if obj.content is None:
             content = 
-        elif isinstance(element_data.content, MutableMapping) or kwargs.get('unordered'):
-            content = ModelVisitor(self).iter_unordered_content(element_data.content)
-        elif not isinstance(element_data.content, MutableSequence):
+        elif isinstance(obj.content, MutableMapping) or kwargs.get('unordered'):
+            content = ModelVisitor(self).iter_unordered_content(
+                obj.content, default_namespace
+            )
+        elif not isinstance(obj.content, MutableSequence):
             wrong_content_type = True
             content = 
         elif converter.losslessly:
-            content = element_data.content
+            content = obj.content
         else:
-            content = ModelVisitor(self).iter_collapsed_content(element_data.content)
+            content = ModelVisitor(self).iter_collapsed_content(
+                obj.content, default_namespace
+            )
 
         for index, (name, value) in enumerate(content):
             if isinstance(name, int):
@@ -837,6 +1155,7 @@
                 cdata_index += 1
                 continue
 
+            xsd_element: OptionalSchemaElementType
             if self.interleave and self.interleave.is_matching(name, default_namespace, group=self):
                 xsd_element = self.interleave
                 value = get_qname(default_namespace, name), value
@@ -894,19 +1213,15 @@
             else:
                 children-1.tail = children-1.tail.strip() + (padding:-indent or '\n')
 
-        cdata_not_allowed = not self.mixed and not_whitespace(text) and self and \
+        cdata_not_allowed = not self.mixed and text and text.strip() and self and \
             (len(self) > 1 or not isinstance(self0, XsdAnyElement))
 
         if errors or cdata_not_allowed or wrong_content_type:
-            attrib = {k: str(v) for k, v in element_data.attributes.items()}
-            if validation != 'strict' and converter.etree_element_class is not etree_element:
-                child_tags = converter.etree_element(e.tag, attrib=e.attrib) for e in children
-                elem = converter.etree_element(element_data.tag, text, child_tags, attrib)
-            else:
-                elem = converter.etree_element(element_data.tag, text, children, attrib)
+            attrib = {k: raw_xml_encode(v) for k, v in obj.attributes.items()}
+            elem = converter.etree_element(obj.tag, text, children, attrib)
 
             if wrong_content_type:
-                reason = "wrong content type {!r}".format(type(element_data.content))
+                reason = "wrong content type {!r}".format(type(obj.content))
                 yield self.validation_error(validation, reason, elem, **kwargs)
 
             if cdata_not_allowed:
@@ -914,9 +1229,20 @@
                 yield self.validation_error(validation, reason, elem, **kwargs)
 
             for index, particle, occurs, expected in errors:
-                yield self.children_validation_error(
-                    validation, elem, index, particle, occurs, expected, **kwargs
+                error = XMLSchemaChildrenValidationError(
+                    validator=self,
+                    elem=elem,
+                    index=index,
+                    particle=particle,
+                    occurs=occurs,
+                    expected=expected,
+                    namespaces=converter.namespaces,
                 )
+                if validation == 'strict':
+                    raise error
+
+                error.elem = None  # replace with the element of the encoded tree
+                yield error
 
         yield text, children
 
@@ -935,7 +1261,7 @@
           Content: (annotation?, (element | any | group)*)
         </all>
     """
-    def _parse_content_model(self, content_model):
+    def _parse_content_model(self, content_model: ElementType) -> None:
         self.model = local_name(content_model.tag)
         if self.model == 'all':
             if self.max_occurs not in (0, 1):
@@ -945,12 +1271,12 @@
 
         for child in content_model:
             if child.tag == XSD_ELEMENT:
-                # Builds inner elements and reference groups later, for avoids circularity.
-                self.append((child, self.schema))
+                # Builds inner elements later, for avoid circularity.
+                self.append(self.schema.xsd_element_class(child, self.schema, self, False))
             elif child.tag == XSD_ANY:
-                self.append(Xsd11AnyElement(child, self.schema, self))
+                self._group.append(Xsd11AnyElement(child, self.schema, self))
             elif child.tag in (XSD_SEQUENCE, XSD_CHOICE, XSD_ALL):
-                self.append(Xsd11Group(child, self.schema, self))
+                self._group.append(Xsd11Group(child, self.schema, self))
             elif child.tag == XSD_GROUP:
                 try:
                     ref = self.schema.resolve_qname(child.attrib'ref')
@@ -962,10 +1288,11 @@
                     continue
 
                 if ref != self.name:
-                    self.append(Xsd11Group(child, self.schema, self))
-                    if (self.model != 'all') ^ (self-1.model != 'all'):
-                        msg = "an xs:%s group cannot include a reference to an x:%s group"
-                        self.parse_error(msg % (self.model, self-1.model))
+                    xsd_group = Xsd11Group(child, self.schema, self)
+                    self._group.append(xsd_group)
+                    if (self.model != 'all') ^ (xsd_group.model != 'all'):
+                        msg = "an xs:%s group cannot include a reference to an xs:%s group"
+                        self.parse_error(msg % (self.model, xsd_group.model))
                         self.pop()
 
                 elif self.redefine is None:
@@ -974,9 +1301,9 @@
                     if child.get('minOccurs', '1') != '1' or child.get('maxOccurs', '1') != '1':
                         self.parse_error("Redefined group reference cannot have "
                                          "minOccurs/maxOccurs other than 1:")
-                    self.append(self.redefine)
+                    self._group.append(self.redefine)
 
-    def admits_restriction(self, model):
+    def admits_restriction(self, model: str) -> bool:
         if self.model == model or self.model == 'all':
             return True
         elif self.model == 'choice':
@@ -984,7 +1311,7 @@
         else:
             return model == 'choice' or len(self.ref or self) <= 1
 
-    def is_restriction(self, other, check_occurs=True):
+    def is_restriction(self, other: ModelParticleType, check_occurs: bool = True) -> bool:
         if not self._group:
             return True
         elif not isinstance(other, ParticleMixin):
@@ -1004,10 +1331,10 @@
             return self.is_sequence_restriction(other)
         elif other.model == 'all':
             return self.is_all_restriction(other)
-        elif other.model == 'choice':
+        else:  # other.model == 'choice':
             return self.is_choice_restriction(other)
 
-    def is_sequence_restriction(self, other):
+    def is_sequence_restriction(self, other: XsdGroup) -> bool:
         if not self.has_occurs_restriction(other):
             return False
 
@@ -1036,24 +1363,25 @@
                 return False
         return item is None
 
-    def is_all_restriction(self, other):
+    def is_all_restriction(self, other: XsdGroup) -> bool:
         if not self.has_occurs_restriction(other):
             return False
-        restriction_items = list(self.iter_model())
+        restriction_items = x for x in self.iter_model()
 
-        base_items = list(other.iter_model())
+        base_items = x for x in other.iter_model()
 
         # If the base includes more wildcard, calculates and appends a
         # wildcard union for validating wildcard unions in restriction
-        wildcards = 
-        for w1 in filter(lambda x: isinstance(x, XsdAnyElement), base_items):
-            for w2 in wildcards:
-                if w1.process_contents == w2.process_contents and w1.occurs == w2.occurs:
-                    w2.union(w1)
-                    w2.extended = True
-                    break
-            else:
-                wildcards.append(w1.copy())
+        wildcards: ListXsdAnyElement = 
+        for w1 in base_items:
+            if isinstance(w1, XsdAnyElement):
+                for w2 in wildcards:
+                    if w1.process_contents == w2.process_contents and w1.occurs == w2.occurs:
+                        w2.union(w1)
+                        w2.extended = True
+                        break
+                else:
+                    wildcards.append(w1.copy())
 
         base_items.extend(w for w in wildcards if hasattr(w, 'extended'))
 
@@ -1080,13 +1408,12 @@
                             break
                 else:
                     if self.model == 'all' and restriction_wildcards:
-                        try:
-                            if other_item.type.name != XSD_ANY_TYPE:
-                                for w in restriction_wildcards:
-                                    if w.is_matching(other_item.name, self.target_namespace):
-                                        return False
-                        except AttributeError:
-                            pass
+                        if not isinstance(other_item, XsdGroup) and other_item.type \
+                                and other_item.type.name != XSD_ANY_TYPE:
+
+                            for w in restriction_wildcards:
+                                if w.is_matching(other_item.name, self.target_namespace):
+                                    return False
 
                 if min_occurs < other_item.min_occurs:
                     break
@@ -1150,13 +1477,14 @@
         else:
             return True
 
-    def is_choice_restriction(self, other):
-        restriction_items = list(self.iter_model())
+    def is_choice_restriction(self, other: XsdGroup) -> bool:
+        restriction_items = x for x in self.iter_model()
         has_not_empty_item = any(e.max_occurs != 0 for e in restriction_items)
 
         check_occurs = other.max_occurs != 0
-        max_occurs = 0
-        other_max_occurs = 0
+        max_occurs: Optionalint = 0
+        other_max_occurs: Optionalint = 0
+
         for other_item in other.iter_model():
             for item in restriction_items:
                 if other_item is item or item.is_restriction(other_item, check_occurs):

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/validators/helpers.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/validators/helpers.py Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/validators/identities.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/validators/identities.py Changed

@@ -12,26 +12,36 @@
 """
 import re
 import math
-from collections import Counter
-from typing import Dict, Union
-from elementpath import XPath2Parser, ElementPathError, XPathContext, translate_pattern
+from typing import TYPE_CHECKING, Any, Dict, Iterator, List, Optional, Pattern, \
+    Tuple, Union, Counter
+from elementpath import XPath2Parser, ElementPathError, XPathToken, XPathContext, \
+    translate_pattern, datatypes
 
 from ..exceptions import XMLSchemaTypeError, XMLSchemaValueError
 from ..names import XSD_QNAME, XSD_UNIQUE, XSD_KEY, XSD_KEYREF, XSD_SELECTOR, XSD_FIELD
 from ..helpers import get_qname, get_extended_qname
+from ..aliases import ElementType, SchemaType, NamespacesType, AtomicValueType
 from ..xpath import iter_schema_nodes
 from .xsdbase import XsdComponent
 from .attributes import XsdAttribute
 
+if TYPE_CHECKING:
+    from .elements import XsdElement
 
-XSD_IDENTITY_XPATH_SYMBOLS = {
+IdentityFieldItemType = UnionAtomicValueType, XsdAttribute, TupleAny, ..., None
+IdentityCounterType = TupleIdentityFieldItemType, ...
+IdentityMapType = DictUnion'XsdKey', 'XsdKeyref', str, None,
+                       Union'IdentityCounter', 'KeyrefCounter'
+
+XSD_IDENTITY_XPATH_SYMBOLS = frozenset((
     'processing-instruction', 'following-sibling', 'preceding-sibling',
     'ancestor-or-self', 'attribute', 'following', 'namespace', 'preceding',
     'ancestor', 'position', 'comment', 'parent', 'child', 'false', 'text', 'node',
-    'true', 'last', 'not', 'and', 'mod', 'div', 'or', '..', '//', '!=', '<=', '>=', '(', ')',
-    '', '', '.', '@', ',', '/', '|', '*', '-', '=', '+', '<', '>', ':', '(end)', '(name)',
-    '(string)', '(float)', '(decimal)', '(integer)', '::', '{', '}',
-}
+    'true', 'last', 'not', 'and', 'mod', 'div', 'or', '..', '//', '!=', '<=', '>=',
+    '(', ')', '', '', '.', '@', ',', '/', '|', '*', '-', '=', '+', '<', '>', ':',
+    '(end)', '(unknown)', '(invalid)', '(name)', '(string)', '(float)', '(decimal)',
+    '(integer)', '::', '{', '}',
+))
 
 
 # XSD identities use a restricted parser and a context for iterate element
@@ -43,7 +53,8 @@
 
 class IdentityXPathParser(XPath2Parser):
     symbol_table = {
-        k: v for k, v in XPath2Parser.symbol_table.items() if k in XSD_IDENTITY_XPATH_SYMBOLS
+        k: v for k, v in XPath2Parser.symbol_table.items()  # type: ignoremisc
+        if k in XSD_IDENTITY_XPATH_SYMBOLS
     }
     SYMBOLS = XSD_IDENTITY_XPATH_SYMBOLS
 
@@ -52,7 +63,7 @@
     """Class for defining an XPath selector for an XSD identity constraint."""
     _ADMITTED_TAGS = {XSD_SELECTOR}
     xpath_default_namespace = ''
-    pattern = translate_pattern(
+    pattern: Unionstr, Patternstr = translate_pattern(
         r"(\.//)?(((child::)?((\i\c*:)?(\i\c*|\*)))|\.)(/(((child::)?"
         r"((\i\c*:)?(\i\c*|\*)))|\.))*(\|(\.//)?(((child::)?((\i\c*:)?"
         r"(\i\c*|\*)))|\.)(/(((child::)?((\i\c*:)?(\i\c*|\*)))|\.))*)*",
@@ -60,28 +71,29 @@
         lazy_quantifiers=False,
         anchors=False
     )
-    token = None
-    parser = None
+    token = None   # type: XPathToken
+    parser = None  # type: IdentityXPathParser
 
-    def __init__(self, elem, schema, parent):
+    def __init__(self, elem: ElementType, schema: SchemaType,
+                 parent: Optional'XsdIdentity') -> None:
         super(XsdSelector, self).__init__(elem, schema, parent)
 
-    def _parse(self):
-        super(XsdSelector, self)._parse()
+    def _parse(self) -> None:
         try:
             self.path = self.elem.attrib'xpath'
         except KeyError:
             self.parse_error("'xpath' attribute required")
             self.path = '*'
         else:
+            path = self.path.replace(' ', '')
             try:
-                match = self.pattern.match(self.path.replace(' ', ''))
+                _match = self.pattern.match(path)  # type: ignoreunion-attr
             except AttributeError:
                 # Compile regex pattern
                 self.__class__.pattern = re.compile(self.pattern)
-                match = self.pattern.match(self.path.replace(' ', ''))
+                _match = self.pattern.match(path)  # type: ignoreunion-attr
 
-            if not match:
+            if not _match:
                 msg = "invalid XPath expression for an {}"
                 self.parse_error(msg.format(self.__class__.__name__))
 
@@ -105,15 +117,15 @@
             self.token = self.parser.parse('*')
             self.parse_error(err)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return '%s(path=%r)' % (self.__class__.__name__, self.path)
 
     @property
-    def built(self):
+    def built(self) -> bool:
         return self.token is not None
 
     @property
-    def target_namespace(self):
+    def target_namespace(self) -> str:
         # TODO: implement a property in elementpath for getting XPath token's namespace
         if self.token is None:
             pass  # xpathDefaultNamespace="##targetNamespace"
@@ -146,20 +158,28 @@
     :ivar selector: the XPath selector of the identity constraint.
     :ivar fields: a list containing the XPath field selectors of the identity constraint.
     """
-    selector = None
-    elements = None  # XSD elements bound by selector (for speed-up and lazy mode)
-    fields = ()
+    name: str
+    local_name: str
+    prefixed_name: str
+    parent: 'XsdElement'
+    ref: Optional'XsdIdentity'
+
+    selector = None  # type: XsdSelector
+    fields = ()      # type: UnionTuple(), ListXsdFieldSelector
+
+    # XSD elements bound by selector (for speed-up and for lazy mode)
+    elements: UnionTuple(), Dict'XsdElement', OptionalIdentityCounterType = ()
 
-    def __init__(self, elem, schema, parent):
+    def __init__(self, elem: ElementType, schema: SchemaType,
+                 parent: Optional'XsdElement') -> None:
         super(XsdIdentity, self).__init__(elem, schema, parent)
 
-    def _parse(self):
-        super(XsdIdentity, self)._parse()
+    def _parse(self) -> None:
         try:
             self.name = get_qname(self.target_namespace, self.elem.attrib'name')
         except KeyError:
             self.parse_error("missing required attribute 'name'")
-            self.name = None
+            self.name = ''
 
         for child in self.elem:
             if child.tag == XSD_SELECTOR:
@@ -173,8 +193,8 @@
             if child.tag == XSD_FIELD:
                 self.fields.append(XsdFieldSelector(child, self.schema, self))
 
-    def build(self):
-        if self.ref is True:
+    def build(self) -> None:
+        if self.ref is True:  # type: ignorecomparison-overlap
             try:
                 ref = self.maps.identitiesself.name
             except KeyError:
@@ -187,34 +207,40 @@
                 self.fields = ref.fields
                 self.ref = ref
 
-        context = IdentityXPathContext(self.schema, item=self.parent)
+        context = IdentityXPathContext(self.schema, item=self.parent)  # type: ignore
 
+        self.elements = {}
         try:
-            self.elements = {
-                e: None for e in self.selector.token.select_results(context) if e.name
-            }
+            for e in self.selector.token.select_results(context):
+                if not isinstance(e, XsdComponent) or isinstance(e, XsdAttribute):
+                    self.parse_error("selector xpath expression can only select elements")
+                elif e.name is not None:
+                    self.elementse = None  # type: ignoreindex
         except AttributeError:
-            self.elements = {}
+            pass
         else:
-            if any(isinstance(e, XsdAttribute) for e in self.elements):
-                self.parse_error("selector xpath cannot select attributes")
-            elif not self.elements:
+            if not self.elements:
                 # Try to detect target XSD elements extracting QNames
                 # of the leaf elements from the XPath expression and
                 # use them to match global elements.
 
+                qname: Any
                 for qname in self.selector.token.iter_leaf_elements():
                     xsd_element = self.maps.elements.get(
                         get_extended_qname(qname, self.namespaces)
                     )
-                    if xsd_element is not None and xsd_element not in self.elements:
+                    if xsd_element is not None and \
+                            not isinstance(xsd_element, tuple) and \
+                            xsd_element not in self.elements:
                         self.elementsxsd_element = None
 
     @property
-    def built(self):
-        return self.elements is not None
+    def built(self) -> bool:
+        return not isinstance(self.elements, tuple)
 
-    def get_fields(self, elem, namespaces=None, decoders=None):
+    def get_fields(self, elem: UnionElementType, 'XsdElement',
+                   namespaces: OptionalNamespacesType = None,
+                   decoders: OptionalTupleXsdAttribute, ... = None) -> IdentityCounterType:
         """
         Get fields for a schema or instance context element.
 
@@ -223,14 +249,18 @@
         :param decoders: context schema fields decoders.
         :return: a tuple with field values. An empty field is replaced by `None`.
         """
-        fields = 
-        if isinstance(elem, XsdComponent):
-            context_class = IdentityXPathContext
-        else:
+        fields: ListIdentityFieldItemType = 
+
+        if not isinstance(elem, XsdComponent):
             context_class = XPathContext
+        else:
+            context_class = IdentityXPathContext
 
+        result: Any
+        value: UnionAtomicValueType, None
         for k, field in enumerate(self.fields):
-            result = field.token.get_results(context_class(elem))
+            result = field.token.get_results(context_class(elem))  # type: ignore
+
             if not result:
                 if decoders is not None and decodersk is not None:
                     value = decodersk.value_constraint
@@ -269,7 +299,10 @@
 
                     value = decodersk.data_value(result0)
                     if decodersk.type.root_type.name == XSD_QNAME:
-                        value = get_extended_qname(value, namespaces)
+                        if isinstance(value, str):
+                            value = get_extended_qname(value, namespaces)
+                        elif isinstance(value, datatypes.QName):
+                            value = value.expanded_name
 
                     if isinstance(value, list):
                         fields.append(tuple(value))
@@ -286,7 +319,7 @@
 
         return tuple(fields)
 
-    def get_counter(self, enabled=True):
+    def get_counter(self, enabled: bool = True) -> 'IdentityCounter':
         return IdentityCounter(self, enabled)
 
 
@@ -306,10 +339,10 @@
     or in a descendant element.
     """
     _ADMITTED_TAGS = {XSD_KEYREF}
-    refer = None
+    refer: OptionalUnionstr, XsdKey = None
     refer_path = '.'
 
-    def _parse(self):
+    def _parse(self) -> None:
         super(XsdKeyref, self)._parse()
         try:
             self.refer = self.schema.resolve_qname(self.elem.attrib'refer')
@@ -319,7 +352,7 @@
             else:
                 self.parse_error(err)
 
-    def build(self):
+    def build(self) -> None:
         super(XsdKeyref, self).build()
 
         if isinstance(self.refer, (XsdKey, XsdUnique)):
@@ -332,10 +365,10 @@
         elif isinstance(self.refer, str):
             refer = self.parent.identities.get(self.refer)
             if refer is not None and refer.ref is None:
-                self.refer = refer
+                self.refer = refer  # type: ignoreassignment
             else:
                 try:
-                    self.refer = self.maps.identitiesself.refer
+                    self.refer = self.maps.identitiesself.refer  # type: ignoreassignment
                 except KeyError:
                     self.parse_error("key/unique identity constraint %r is missing" % self.refer)
                     return
@@ -355,64 +388,61 @@
                 # needs to propagate upwards, with conflict resolution."
                 refer_path = self.parent.get_path(ancestor=self.refer.parent, reverse=True)
                 if refer_path is None:
-                    refer_path = self.parent.get_path(reverse=True) + '/' + \
-                        self.refer.parent.get_path()
+                    path1 = self.parent.get_path(reverse=True)
+                    path2 = self.refer.parent.get_path()
+                    assert path1 is not None
+                    assert path2 is not None
+                    refer_path = f'{path1}/{path2}'
 
             self.refer_path = refer_path
 
     @property
-    def built(self):
-        return self.elements is not None and isinstance(self.refer, XsdIdentity)
+    def built(self) -> bool:
+        return not isinstance(self.elements, tuple) and isinstance(self.refer, XsdIdentity)
 
-    def get_counter(self, enabled=True):
+    def get_counter(self, enabled: bool = True) -> 'KeyrefCounter':
         return KeyrefCounter(self, enabled)
 
 
 class Xsd11Unique(XsdUnique):
-
-    def _parse(self):
+    def _parse(self) -> None:
         if self._parse_reference():
-            super(XsdIdentity, self)._parse()
-            self.ref = True
+            self.ref = True  # type: ignoreassignment
         else:
             super(Xsd11Unique, self)._parse()
 
 
 class Xsd11Key(XsdKey):
-
-    def _parse(self):
+    def _parse(self) -> None:
         if self._parse_reference():
-            super(XsdIdentity, self)._parse()
-            self.ref = True
+            self.ref = True  # type: ignoreassignment
         else:
             super(Xsd11Key, self)._parse()
 
 
 class Xsd11Keyref(XsdKeyref):
-
-    def _parse(self):
+    def _parse(self) -> None:
         if self._parse_reference():
-            super(XsdIdentity, self)._parse()
-            self.ref = True
+            self.ref = True  # type: ignoreassignment
         else:
             super(Xsd11Keyref, self)._parse()
 
 
 class IdentityCounter:
 
-    def __init__(self, identity: UnionXsdKey, XsdKeyref, enabled=True):
-        self.counter = Counter()
+    def __init__(self, identity: XsdIdentity, enabled: bool = True) -> None:
+        self.counter: CounterIdentityCounterType = CounterIdentityCounterType()
         self.identity = identity
         self.enabled = enabled
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "%s%r" % (self.__class__.__name__:-7, self.counter)
 
-    def clear(self):
+    def clear(self) -> None:
         self.counter.clear()
         self.enabled = True
 
-    def increase(self, fields: tuple):
+    def increase(self, fields: IdentityCounterType) -> None:
         self.counterfields += 1
         if self.counterfields == 2:
             msg = "duplicated value {!r} for {!r}"
@@ -420,12 +450,12 @@
 
 
 class KeyrefCounter(IdentityCounter):
+    identity: XsdKeyref
 
-    def increase(self, fields: tuple):
+    def increase(self, fields: IdentityCounterType) -> None:
         self.counterfields += 1
 
-    def iter_errors(self, identities: DictUnionXsdKey, XsdKeyref,
-                                           Union'IdentityCounter', 'KeyrefCounter'):
+    def iter_errors(self, identities: IdentityMapType) -> IteratorXMLSchemaValueError:
         refer_values = identitiesself.identity.refer.counter
 
         for v in filter(lambda x: x not in refer_values, self.counter):

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/validators/models.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/validators/models.py Changed

@@ -8,23 +8,30 @@
 # @author Davide Brunato <brunato@sissa.it>
 #
 """
-This module contains classes and functions for validating XSD content models.
+This module contains a function and a class for validating XSD content models.
 """
-from collections import defaultdict, deque, Counter
-from typing import List, Tuple, Union, Iterator
+from collections import defaultdict, deque
+from typing import Any, Counter, Dict, Iterable, Iterator, List, Optional, Tuple, Union
 
 from ..exceptions import XMLSchemaValueError
-from .particles import ParticleMixin, ModelGroup
+from ..aliases import ModelGroupType, ModelParticleType, SchemaElementType
+from . import groups
 
+AdvanceYieldedType = TupleModelParticleType, int, ListSchemaElementType
+EncodedContentType = UnionDictUnionint, str, ListAny,
+                           ListTupleUnionint, str, ListAny
+ContentItemType = TupleUnionint, str, Any
 
-def distinguishable_paths(path1: ListUnionParticleMixin, ModelGroup,
-                          path2: ListUnionParticleMixin, ModelGroup):
+
+def distinguishable_paths(path1: ListModelParticleType, path2: ListModelParticleType) -> bool:
     """
     Checks if two model paths are distinguishable in a deterministic way, without looking forward
     or backtracking. The arguments are lists containing paths from the base group of the model to
     a couple of leaf elements. Returns `True` if there is a deterministic separation between paths,
     `False` if the paths are ambiguous.
     """
+    e: ModelParticleType
+
     for k, e in enumerate(path1):
         if e not in path2:
             if not k:
@@ -38,7 +45,7 @@
         return True
 
     univocal1 = univocal2 = True
-    if path1depth.model == 'sequence':
+    if path1depth.model == 'sequence':  # type: ignoreunion-attr
         idx1 = path1depth.index(path1depth + 1)
         idx2 = path2depth.index(path2depth + 1)
         before1 = any(not e.is_emptiable() for e in path1depth:idx1)
@@ -50,7 +57,7 @@
     for k in range(depth + 1, len(path1) - 1):
         univocal1 &= path1k.is_univocal()
         idx = path1k.index(path1k + 1)
-        if path1k.model == 'sequence':
+        if path1k.model == 'sequence':  # type: ignoreunion-attr
             before1 |= any(not e.is_emptiable() for e in path1k:idx)
             after1 |= any(not e.is_emptiable() for e in path1kidx + 1:)
         elif any(e.is_emptiable() for e in path1k if e is not path1kidx):
@@ -59,13 +66,13 @@
     for k in range(depth + 1, len(path2) - 1):
         univocal2 &= path2k.is_univocal()
         idx = path2k.index(path2k + 1)
-        if path2k.model == 'sequence':
+        if path2k.model == 'sequence':  # type: ignoreunion-attr
             before2 |= any(not e.is_emptiable() for e in path2k:idx)
             after2 |= any(not e.is_emptiable() for e in path2kidx + 1:)
         elif any(e.is_emptiable() for e in path2k if e is not path2kidx):
             univocal2 = False
 
-    if path1depth.model != 'sequence':
+    if path1depth.model != 'sequence':  # type: ignoreunion-attr
         if before1 and before2:
             return True
         elif before1:
@@ -88,27 +95,30 @@
     counting the occurrences and yielding tuples in case of model's item occurrence errors.
     Ends setting the current element to `None`.
 
-    :param root: the root ModelGroup instance of the model.
+    :param root: the root model group.
     :ivar occurs: the Counter instance for keeping track of occurrences of XSD elements and groups.
     :ivar element: the current XSD element, initialized to the first element of the model.
     :ivar group: the current XSD model group, initialized to *root* argument.
     :ivar items: the current XSD group's items iterator.
     :ivar match: if the XSD group has an effective item match.
     """
-    def __init__(self, root: ModelGroup):
+    _groups: ListTupleModelGroupType, IteratorModelParticleType, bool
+    element: OptionalSchemaElementType
+
+    def __init__(self, root: ModelGroupType) -> None:
+        self._groups = 
         self.root = root
-        self.occurs = Counter()
-        self._groups: ListTupleModelGroup, int, bool = 
+        self.occurs = CounterUnionModelParticleType, TupleModelParticleType()
         self.element = None
         self.group = root
         self.items = self.iter_group()
         self.match = False
         self._start()
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return '%s(root=%r)' % (self.__class__.__name__, self.root)
 
-    def clear(self):
+    def clear(self) -> None:
         del self._groups:
         self.occurs.clear()
         self.element = None
@@ -116,14 +126,14 @@
         self.items = self.iter_group()
         self.match = False
 
-    def _start(self):
+    def _start(self) -> None:
         while True:
             item = next(self.items, None)
             if item is None:
                 if not self._groups:
                     break
                 self.group, self.items, self.match = self._groups.pop()
-            elif not isinstance(item, ModelGroup):
+            elif not isinstance(item, groups.XsdGroup):
                 self.element = item
                 break
             elif item:
@@ -133,11 +143,13 @@
                 self.match = False
 
     @property
-    def expected(self) -> ListParticleMixin:
+    def expected(self) -> ListSchemaElementType:
         """
         Returns the expected elements of the current and descendant groups.
         """
-        expected = 
+        expected: ListSchemaElementType = 
+        items: UnionModelGroupType, IteratorModelParticleType
+
         if self.group.model == 'choice':
             items = self.group
         elif self.group.model == 'all':
@@ -146,23 +158,23 @@
             items = (e for e in self.group if e.min_occurs > self.occurse)
 
         for e in items:
-            if isinstance(e, ModelGroup):
+            if isinstance(e, groups.XsdGroup):
                 expected.extend(e.iter_elements())
             else:
                 expected.append(e)
-                expected.extend(e.maps.substitution_groups.get(e.name, ()))
+                expected.extend(e.maps.substitution_groups.get(e.name or '', ()))
         return expected
 
-    def restart(self):
+    def restart(self) -> None:
         self.clear()
         self._start()
 
-    def stop(self):
+    def stop(self) -> IteratorAdvanceYieldedType:
         while self.element is not None:
             for e in self.advance():
                 yield e
 
-    def iter_group(self) -> IteratorParticleMixin:
+    def iter_group(self) -> IteratorModelParticleType:
         """Returns an iterator for the current model group."""
         if self.group.max_occurs == 0:
             return iter(())
@@ -171,21 +183,21 @@
         else:
             return (e for e in self.group.iter_elements() if not e.is_over(self.occurse))
 
-    def advance(self, match=False) -> IteratorTupleParticleMixin, int, list:
+    def advance(self, match: bool = False) -> IteratorAdvanceYieldedType:
         """
         Generator function for advance to the next element. Yields tuples with
         particles information when occurrence violation is found.
 
         :param match: provides current element match.
         """
-        def stop_item(item: ParticleMixin) -> bool:
+        def stop_item(item: ModelParticleType) -> bool:
             """
             Stops element or group matching, incrementing current group counter.
 
             :return: `True` if the item has violated the minimum occurrences for itself \
             or for the current group, `False` otherwise.
             """
-            if isinstance(item, ModelGroup):
+            if isinstance(item, groups.XsdGroup):
                 self.group, self.items, self.match = self._groups.pop()
 
             if self.group.model == 'choice':
@@ -271,7 +283,7 @@
                     stop_item(self.group)
 
                 obj = next(self.items, None)
-                if isinstance(obj, ModelGroup):
+                if isinstance(obj, groups.XsdGroup):
                     # inner 'sequence' or 'choice' XsdGroup
                     self._groups.append((self.group, self.items, self.match))
                     self.group = obj
@@ -321,12 +333,15 @@
             elif self.group.max_occurs is not None and self.group.max_occurs < occursself.group:
                 yield self.group, occursself.group, self.expected
 
-    def sort_content(self, content, restart=True):
+    def sort_content(self, content: EncodedContentType, restart: bool = True) \
+            -> ListContentItemType:
         if restart:
             self.restart()
         return (name, value) for name, value in self.iter_unordered_content(content)
 
-    def iter_unordered_content(self, content):
+    def iter_unordered_content(
+            self, content: EncodedContentType,
+            default_namespace: Optionalstr = None) -> IteratorContentItemType:
         """
         Takes an unordered content stored in a dictionary of lists and yields the
         content elements sorted with the ordering defined by the model. Character
@@ -341,8 +356,10 @@
         or an iterable composed of couples of name and value. In case of a \
         dictionary the values must be lists where each item is the content \
         of a single element.
-        :return: yields of a sequence of the Element being encoded's children.
+        :param default_namespace: the default namespace to apply for matching names.
         """
+        consumable_content: Dictstr, Any
+
         if isinstance(content, dict):
             cdata_content = sorted(
                 ((k, v) for k, v in content.items() if isinstance(k, int)), reverse=True
@@ -351,15 +368,16 @@
         else:
             cdata_content = sorted(((k, v) for k, v in content if isinstance(k, int)), reverse=True)
             consumable_content = defaultdict(deque)
-            for k, v in filter(lambda x: not isinstance(x0, int), content):
-                consumable_contentk.append(v)
+            for k, v in content:
+                if isinstance(k, str):
+                    consumable_contentk.append(v)
 
         if cdata_content:
             yield cdata_content.pop()
 
         while self.element is not None and consumable_content:  # pragma: no cover
             for name in consumable_content:
-                if self.element.is_matching(name):
+                if self.element.is_matching(name, default_namespace, group=self.group):
                     yield name, consumable_contentname.popleft()
                     if not consumable_contentname:
                         del consumable_contentname
@@ -383,7 +401,9 @@
         while cdata_content:
             yield cdata_content.pop()
 
-    def iter_collapsed_content(self, content):
+    def iter_collapsed_content(
+            self, content: IterableTupleUnionint, str, Any,
+            default_namespace: Optionalstr = None) -> IteratorContentItemType:
         """
         Iterates a content stored in a sequence of couples *(name, value)*, yielding
         items in the same order of the sequence, except for repetitions of the same
@@ -396,10 +416,10 @@
         collapses the children with the same tag into a list (eg. BadgerFish).
 
         :param content: an iterable containing couples of names and values.
-        :return: yields of a sequence of the Element being encoded's children.
+        :param default_namespace: the default namespace to apply for matching names.
         """
         prev_name = None
-        unordered_content = defaultdict(deque)
+        unordered_content: Dictstr, Any = defaultdict(deque)
 
         for name, value in content:
             if isinstance(name, int) or self.element is None:
@@ -407,7 +427,7 @@
                 continue
 
             while self.element is not None:
-                if self.element.is_matching(name):
+                if self.element.is_matching(name, default_namespace, group=self.group):
                     yield name, value
                     prev_name = name
                     for _ in self.advance(True):
@@ -415,7 +435,7 @@
                     break
 
                 for key in unordered_content:
-                    if self.element.is_matching(key):
+                    if self.element.is_matching(key, default_namespace, group=self.group):
                         break
                 else:
                     if prev_name == name:
@@ -441,38 +461,3 @@
         for name, values in unordered_content.items():
             for v in values:
                 yield name, v
-
-
-class OccursCounter:
-    """
-    An helper class for counting total min/max occurrences of XSD particles.
-    """
-    def __init__(self):
-        self.min_occurs = self.max_occurs = 0
-
-    def __repr__(self):
-        return '%s(%r, %r)' % (self.__class__.__name__, self.min_occurs, self.max_occurs)
-
-    def __add__(self, other: ParticleMixin):
-        self.min_occurs += other.min_occurs
-        if self.max_occurs is not None:
-            if other.max_occurs is None:
-                self.max_occurs = None
-            else:
-                self.max_occurs += other.max_occurs
-        return self
-
-    def __mul__(self, other: ParticleMixin):
-        self.min_occurs *= other.min_occurs
-        if self.max_occurs is None:
-            if other.max_occurs == 0:
-                self.max_occurs = 0
-        elif other.max_occurs is None:
-            if self.max_occurs != 0:
-                self.max_occurs = None
-        else:
-            self.max_occurs *= other.max_occurs
-        return self
-
-    def reset(self):
-        self.min_occurs = self.max_occurs = 0

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/validators/notations.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/validators/notations.py Changed

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/validators/particles.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/validators/particles.py Changed

@@ -1,5 +1,5 @@
 #
-# Copyright (c), 2016-2020, SISSA (International School for Advanced Studies).
+# Copyright (c), 2016-2021  , SISSA (International School for Advanced Studies).
 # All rights reserved.
 # This file is distributed under the terms of the MIT License.
 # See the file 'LICENSE' in the root directory of the present
@@ -7,13 +7,10 @@
 #
 # @author Davide Brunato <brunato@sissa.it>
 #
-from collections.abc import MutableSequence
-from typing import Optional, List, Union
-from xml.etree.ElementTree import Element
+from typing import Any, Optional, Tuple, Union
 
-from .. import limits
 from ..exceptions import XMLSchemaValueError
-from .exceptions import XMLSchemaParseError, XMLSchemaModelError, XMLSchemaModelDepthError
+from ..aliases import ElementType, ModelParticleType
 
 
 class ParticleMixin:
@@ -27,19 +24,22 @@
     :ivar max_occurs: the maxOccurs property of the XSD particle. Defaults to 1, \
     a `None` value means 'unbounded'.
     """
+    name: Any
+    maps: Any
+
     min_occurs: int = 1
     max_occurs: Optionalint = 1
 
-    def __init__(self, min_occurs=1, max_occurs: Optionalint = 1):
+    def __init__(self, min_occurs: int = 1, max_occurs: Optionalint = 1) -> None:
         self.min_occurs = min_occurs
         self.max_occurs = max_occurs
 
     @property
-    def occurs(self):
-        return self.min_occurs, self.max_occurs
+    def occurs(self) -> Tupleint, Optionalint:
+        return self.min_occurs, self.max_occurs
 
     @property
-    def effective_min_occurs(self):
+    def effective_min_occurs(self) -> int:
         """
         A property calculated from minOccurs, that is equal to minOccurs
         for elements and may vary for content model groups, in dependance
@@ -48,7 +48,7 @@
         return self.min_occurs
 
     @property
-    def effective_max_occurs(self):
+    def effective_max_occurs(self) -> Optionalint:
         """
         A property calculated from maxOccurs, that is equal to maxOccurs
         for elements and may vary for content model groups, in dependance
@@ -57,20 +57,20 @@
         """
         return self.max_occurs
 
-    def is_emptiable(self):
+    def is_emptiable(self) -> bool:
         """
         Tests if max_occurs == 0. A zero-length model group is considered emptiable.
         For model groups the test outcome depends also on nested particles.
         """
         return self.min_occurs == 0
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         """
         Tests if max_occurs == 0. A zero-length model group is considered empty.
         """
         return self.max_occurs == 0
 
-    def is_single(self):
+    def is_single(self) -> bool:
         """
         Tests if the particle has max_occurs == 1. For elements the test
         outcome depends also on parent group. For model groups the test
@@ -78,27 +78,27 @@
         """
         return self.max_occurs == 1
 
-    def is_multiple(self):
+    def is_multiple(self) -> bool:
         """Tests the particle can have multiple occurrences."""
         return not self.is_empty() and not self.is_single()
 
-    def is_ambiguous(self):
+    def is_ambiguous(self) -> bool:
         """Tests if min_occurs != max_occurs."""
         return self.min_occurs != self.max_occurs
 
-    def is_univocal(self):
+    def is_univocal(self) -> bool:
         """Tests if min_occurs == max_occurs."""
         return self.min_occurs == self.max_occurs
 
-    def is_missing(self, occurs: int):
+    def is_missing(self, occurs: int) -> bool:
         """Tests if provided occurrences are under the minimum."""
         return not self.is_emptiable() if occurs == 0 else self.min_occurs > occurs
 
-    def is_over(self, occurs: int):
+    def is_over(self, occurs: int) -> bool:
         """Tests if provided occurrences are over the maximum."""
         return self.max_occurs is not None and self.max_occurs <= occurs
 
-    def has_occurs_restriction(self, other):
+    def has_occurs_restriction(self, other: UnionModelParticleType, 'OccursCalculator') -> bool:
         if self.min_occurs < other.min_occurs:
             return False
         elif self.max_occurs == 0:
@@ -110,10 +110,10 @@
         else:
             return self.max_occurs <= other.max_occurs
 
-    def parse_error(self, message):
-        raise XMLSchemaParseError(self, message)  # pragma: no cover
+    def parse_error(self, message: Any) -> None:
+        raise XMLSchemaValueError(message)
 
-    def _parse_particle(self, elem: Element):
+    def _parse_particle(self, elem: ElementType) -> None:
         if 'minOccurs' in elem.attrib:
             try:
                 min_occurs = int(elem.attrib'minOccurs')
@@ -133,253 +133,48 @@
             self.max_occurs = None
         else:
             try:
-                max_occurs = int(max_occurs)
+                self.max_occurs = int(max_occurs)
             except ValueError:
                 self.parse_error("maxOccurs value must be a non negative integer or 'unbounded'")
             else:
-                if self.min_occurs > max_occurs:
+                if self.min_occurs > self.max_occurs:
                     self.parse_error("maxOccurs must be 'unbounded' or greater than minOccurs")
-                else:
-                    self.max_occurs = max_occurs
+                    self.max_occurs = None
 
 
-class ModelGroup(MutableSequence, ParticleMixin):
+class OccursCalculator:
     """
-    Class for XSD model group particles. This class implements only model related methods,
-    schema element parsing and validation methods are implemented in derived classes.
+    An helper class for adding and multiplying min/max occurrences of XSD particles.
     """
-    def __init__(self, model: str, min_occurs=1, max_occurs: Optionalint = 1):
-        super(ModelGroup, self).__init__(min_occurs, max_occurs)
-        if model not in {'sequence', 'choice', 'all'}:
-            raise XMLSchemaValueError("invalid model {!r} for a group".format(model))
-        self._group: ListUniontuple, ParticleMixin = 
-        self.model = model
-
-    def __repr__(self):
-        return '%s(model=%r, occurs=%r)' % (self.__class__.__name__, self.model, self.occurs)
-
-    # Implements the abstract methods of MutableSequence
-    def __getitem__(self, i: int):
-        return self._groupi
-
-    def __setitem__(self, i: int, item: Uniontuple, ParticleMixin):
-        self._groupi = item
-
-    def __delitem__(self, i: int):
-        del self._groupi
-
-    def __len__(self):
-        return len(self._group)
-
-    def insert(self, i: int, item: Uniontuple, ParticleMixin):
-        self._group.insert(i, item)
-
-    def clear(self):
-        del self._group:
-
-    def is_emptiable(self):
-        if self.model == 'choice':
-            return self.min_occurs == 0 or not self or any(item.is_emptiable() for item in self)
-        else:
-            return self.min_occurs == 0 or not self or all(item.is_emptiable() for item in self)
-
-    def is_empty(self):
-        return not self._group or self.max_occurs == 0
-
-    def is_single(self):
-        if self.max_occurs != 1 or not self:
-            return False
-        elif len(self) > 1 or not isinstance(self0, ModelGroup):
-            return True
-        else:
-            return self0.is_single()
-
-    def is_pointless(self, parent: 'ModelGroup'):
-        """
-        Returns `True` if the group may be eliminated without affecting the model,
-        `False` otherwise. A group is pointless if one of those conditions is verified:
+    min_occurs: int
+    max_occurs: Optionalint
 
-         - the group is empty
-         - minOccurs == maxOccurs == 1 and the group has one child
-         - minOccurs == maxOccurs == 1 and the group and its parent have a sequence model
-         - minOccurs == maxOccurs == 1 and the group and its parent have a choice model
+    def __init__(self) -> None:
+        self.min_occurs = self.max_occurs = 0
 
-        Ref: https://www.w3.org/TR/2004/REC-xmlschema-1-20041028/#coss-particle
+    def __repr__(self) -> str:
+        return '%s(%r, %r)' % (self.__class__.__name__, self.min_occurs, self.max_occurs)
 
-        :param parent: effective parent of the model group.
-        """
-        if not self:
-            return True
-        elif self.min_occurs != 1 or self.max_occurs != 1:
-            return False
-        elif len(self) == 1:
-            return True
-        elif self.model == 'sequence' and parent.model != 'sequence':
-            return False
-        elif self.model == 'choice' and parent.model != 'choice':
-            return False
-        else:
-            return True
-
-    @property
-    def effective_min_occurs(self):
-        if not self.min_occurs or not self:
-            return 0
-        elif self.model == 'choice':
-            if any(not e.effective_min_occurs for e in self.iter_model()):
-                return 0
-        else:
-            if all(not e.effective_min_occurs for e in self.iter_model()):
-                return 0
-        return self.min_occurs
-
-    @property
-    def effective_max_occurs(self):
-        if self.max_occurs == 0 or not self:
-            return 0
-
-        effective_items = list(e for e in self.iter_model() if e.effective_max_occurs != 0)
-        if not effective_items:
-            return 0
-        elif self.max_occurs is None:
-            return
-        elif self.model == 'choice':
-            if any(e.effective_max_occurs is None for e in effective_items):
-                return
-            return self.max_occurs * max(e.effective_max_occurs for e in effective_items)
-
-        not_emptiable_items = e for e in effective_items if e.effective_min_occurs
-        if not not_emptiable_items:
-            if any(e.effective_max_occurs is None for e in effective_items):
-                return
-            return self.max_occurs * max(e.effective_max_occurs for e in effective_items)
-        elif len(not_emptiable_items) > 1:
-            return self.max_occurs
-
-        try:
-            return self.max_occurs * not_emptiable_items0.effective_max_occurs
-        except TypeError:
-            return
-
-    def has_occurs_restriction(self, other: 'ModelGroup'):
-        if not self:
-            return True
-        elif isinstance(other, ModelGroup):
-            return super(ModelGroup, self).has_occurs_restriction(other)
-
-        # Group particle compared to element particle
-        if self.max_occurs is None or any(e.max_occurs is None for e in self):
-            if other.max_occurs is not None:
-                return False
-            elif self.model == 'choice':
-                return self.min_occurs * min(e.min_occurs for e in self) >= other.min_occurs
+    def __add__(self, other: ParticleMixin) -> 'OccursCalculator':
+        self.min_occurs += other.min_occurs
+        if self.max_occurs is not None:
+            if other.max_occurs is None:
+                self.max_occurs = None
             else:
-                return self.min_occurs * sum(e.min_occurs for e in self) >= other.min_occurs
-
-        elif self.model == 'choice':
-            if self.min_occurs * min(e.min_occurs for e in self) < other.min_occurs:
-                return False
-            elif other.max_occurs is None:
-                return True
-            else:
-                return self.max_occurs * max(e.max_occurs for e in self) <= other.max_occurs
-
+                self.max_occurs += other.max_occurs
+        return self
+
+    def __mul__(self, other: ParticleMixin) -> 'OccursCalculator':
+        self.min_occurs *= other.min_occurs
+        if self.max_occurs is None:
+            if other.max_occurs == 0:
+                self.max_occurs = 0
+        elif other.max_occurs is None:
+            if self.max_occurs != 0:
+                self.max_occurs = None
         else:
-            if self.min_occurs * sum(e.min_occurs for e in self) < other.min_occurs:
-                return False
-            elif other.max_occurs is None:
-                return True
-            else:
-                return self.max_occurs * sum(e.max_occurs for e in self) <= other.max_occurs
-
-    def iter_model(self, depth=0):
-        """
-        A generator function iterating elements and groups of a model group.
-        Skips pointless groups, iterating deeper through them.
-        Raises `XMLSchemaModelDepthError` if the argument *depth* is over
-        `limits.MAX_MODEL_DEPTH` value.
-
-        :param depth: guard for protect model nesting bombs, incremented at each deepest recursion.
-        """
-        if depth > limits.MAX_MODEL_DEPTH:
-            raise XMLSchemaModelDepthError(self)
-        for item in self:
-            if not isinstance(item, ModelGroup):
-                yield item
-            elif not item.is_pointless(parent=self):
-                yield item
-            else:
-                yield from item.iter_model(depth + 1)
-
-    def iter_elements(self, depth=0):
-        """
-        A generator function iterating model's elements. Raises `XMLSchemaModelDepthError`
-        if the argument *depth* is over `limits.MAX_MODEL_DEPTH` value.
-
-        :param depth: guard for protect model nesting bombs, incremented at each deepest recursion.
-        """
-        if depth > limits.MAX_MODEL_DEPTH:
-            raise XMLSchemaModelDepthError(self)
-        if self.max_occurs != 0:
-            for item in self:
-                if isinstance(item, ModelGroup):
-                    yield from item.iter_elements(depth + 1)
-                else:
-                    yield item
-
-    def get_subgroups(self, item: ParticleMixin) -> List'ModelGroup':
-        """
-        Returns a list of the groups that represent the path to the enclosed particle.
-        Raises an `XMLSchemaModelError` if *item* is not a particle of the model group.
-        """
-        subgroups = 
-        group, children = self, iter(self)
-
-        while True:
-            try:
-                child = next(children)
-            except StopIteration:
-                try:
-                    group, children = subgroups.pop()
-                except IndexError:
-                    msg = '{!r} is not a particle of the model group'
-                    raise XMLSchemaModelError(self, msg.format(item)) from None
-                else:
-                    continue
-
-            if child is item:
-                subgroups = x0 for x in subgroups
-                subgroups.append(group)
-                return subgroups
-            elif isinstance(child, ModelGroup):
-                if len(subgroups) > limits.MAX_MODEL_DEPTH:
-                    raise XMLSchemaModelDepthError(self)
-                subgroups.append((group, children))
-                group, children = child, iter(child)
-
-    def overall_min_occurs(self, item: ParticleMixin) -> int:
-        """Returns the overall min occurs of a particle in the model."""
-        min_occurs = item.min_occurs
-
-        for group in self.get_subgroups(item):
-            if group.model == 'choice' and len(group) > 1:
-                return 0
-            min_occurs *= group.min_occurs
-
-        return min_occurs
-
-    def overall_max_occurs(self, item: ParticleMixin) -> Optionalint:
-        """Returns the overall max occurs of a particle in the model."""
-        max_occurs = item.max_occurs
-
-        for group in self.get_subgroups(item):
-            if max_occurs == 0:
-                return 0
-            elif max_occurs is None:
-                continue
-            elif group.max_occurs is None:
-                max_occurs = None
-            else:
-                max_occurs *= group.max_occurs
+            self.max_occurs *= other.max_occurs
+        return self
 
-        return max_occurs
+    def reset(self) -> None:
+        self.min_occurs = self.max_occurs = 0

_service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/validators/schemas.py Added

@@ -0,0 +1,2221 @@
+#
+# Copyright (c), 2016-2020, SISSA (International School for Advanced Studies).
+# All rights reserved.
+# This file is distributed under the terms of the MIT License.
+# See the file 'LICENSE' in the root directory of the present
+# distribution, or http://opensource.org/licenses/MIT.
+#
+# @author Davide Brunato <brunato@sissa.it>
+#
+"""
+This module contains XMLSchema classes creator for xmlschema package.
+
+Two schema classes are created at the end of this module, XMLSchema10 for XSD 1.0 and
+XMLSchema11 for XSD 1.1. The latter class parses also XSD 1.0 schemas, as prescribed by
+the standard.
+"""
+import sys
+if sys.version_info < (3, 7):
+    from typing import GenericMeta as ABCMeta
+else:
+    from abc import ABCMeta
+
+import os
+import logging
+import threading
+import warnings
+import re
+import sys
+from copy import copy
+from itertools import chain
+from typing import cast, Callable, ItemsView, List, Optional, Dict, Any, \
+    Set, Union, Tuple, Type, Iterator, Counter
+
+from elementpath import XPathToken
+
+from ..exceptions import XMLSchemaTypeError, XMLSchemaKeyError, XMLSchemaRuntimeError, \
+    XMLSchemaValueError, XMLSchemaNamespaceError
+from ..names import VC_MIN_VERSION, VC_MAX_VERSION, VC_TYPE_AVAILABLE, \
+    VC_TYPE_UNAVAILABLE, VC_FACET_AVAILABLE, VC_FACET_UNAVAILABLE, XSD_NOTATION, \
+    XSD_ATTRIBUTE, XSD_ATTRIBUTE_GROUP, XSD_GROUP, XSD_SIMPLE_TYPE, XSI_TYPE, \
+    XSD_COMPLEX_TYPE, XSD_ELEMENT, XSD_SEQUENCE, XSD_CHOICE, XSD_ALL, XSD_ANY, \
+    XSD_ANY_ATTRIBUTE, XSD_ANY_TYPE, XSD_NAMESPACE, XML_NAMESPACE, XSI_NAMESPACE, \
+    VC_NAMESPACE, SCHEMAS_DIR, LOCATION_HINTS, XSD_ANNOTATION, XSD_INCLUDE, \
+    XSD_IMPORT, XSD_REDEFINE, XSD_OVERRIDE, XSD_DEFAULT_OPEN_CONTENT, \
+    XSD_ANY_SIMPLE_TYPE, XSD_UNION, XSD_LIST, XSD_RESTRICTION
+from ..etree import etree_element, ParseError
+from ..aliases import ElementType, XMLSourceType, NamespacesType, LocationsType, \
+    SchemaType, SchemaSourceType, ConverterType, ComponentClassType, DecodeType, \
+    EncodeType, BaseXsdType, AtomicValueType, ExtraValidatorType, SchemaGlobalType
+from ..helpers import prune_etree, get_namespace, get_qname
+from ..namespaces import NamespaceResourcesMap, NamespaceView
+from ..resources import is_local_url, is_remote_url, url_path_is_file, \
+    normalize_locations, fetch_resource, normalize_url, XMLResource
+from ..converters import XMLSchemaConverter
+from ..xpath import XMLSchemaProtocol, XMLSchemaProxy, ElementPathMixin
+from .. import dataobjects
+
+from .exceptions import XMLSchemaParseError, XMLSchemaValidationError, XMLSchemaEncodeError, \
+    XMLSchemaNotBuiltError, XMLSchemaIncludeWarning, XMLSchemaImportWarning
+from .helpers import get_xsd_derivation_attribute
+from .xsdbase import check_validation_mode, XsdValidator, XsdComponent, XsdAnnotation
+from .notations import XsdNotation
+from .identities import XsdIdentity, XsdKey, XsdKeyref, XsdUnique, \
+    Xsd11Key, Xsd11Unique, Xsd11Keyref, IdentityCounter, KeyrefCounter, IdentityMapType
+from .facets import XSD_10_FACETS, XSD_11_FACETS
+from .simple_types import XsdSimpleType, XsdList, XsdUnion, XsdAtomicRestriction, \
+    Xsd11AtomicRestriction, Xsd11Union
+from .attributes import XsdAttribute, XsdAttributeGroup, Xsd11Attribute
+from .complex_types import XsdComplexType, Xsd11ComplexType
+from .groups import XsdGroup, Xsd11Group
+from .elements import XsdElement, Xsd11Element
+from .wildcards import XsdAnyElement, XsdAnyAttribute, Xsd11AnyElement, \
+    Xsd11AnyAttribute, XsdDefaultOpenContent
+from .global_maps import XsdGlobals
+
+logger = logging.getLogger('xmlschema')
+
+XSD_VERSION_PATTERN = re.compile(r'^\d+\.\d+$')
+DRIVE_PATTERN = re.compile(r'^a-zA-Z:$')
+
+# Elements for building dummy groups
+ATTRIBUTE_GROUP_ELEMENT = etree_element(XSD_ATTRIBUTE_GROUP)
+ANY_ATTRIBUTE_ELEMENT = etree_element(
+    XSD_ANY_ATTRIBUTE, attrib={'namespace': '##any', 'processContents': 'lax'}
+)
+SEQUENCE_ELEMENT = etree_element(XSD_SEQUENCE)
+ANY_ELEMENT = etree_element(
+    XSD_ANY,
+    attrib={
+        'namespace': '##any',
+        'processContents': 'lax',
+        'minOccurs': '0',
+        'maxOccurs': 'unbounded'
+    })
+
+GLOBAL_TAGS = frozenset((XSD_NOTATION, XSD_SIMPLE_TYPE, XSD_COMPLEX_TYPE,
+                         XSD_ATTRIBUTE, XSD_ATTRIBUTE_GROUP, XSD_GROUP, XSD_ELEMENT))
+
+
+class XMLSchemaMeta(ABCMeta):
+    XSD_VERSION: str
+    create_meta_schema: Callable'XMLSchemaMeta', Optionalstr, SchemaType
+
+    def __new__(mcs, name: str, bases: TupleTypeAny, ..., dict_: Dictstr, Any) \
+            -> 'XMLSchemaMeta':
+        assert bases, "a base class is mandatory"
+        base_class = bases0
+
+        # For backward compatibility (will be removed in v2.0)
+        if 'BUILDERS' in dict_:
+            msg = "'BUILDERS' will be removed in v2.0, provide the appropriate " \
+                  "attributes instead (eg. xsd_element_class = Xsd11Element)"
+            warnings.warn(msg, DeprecationWarning, stacklevel=1)
+
+            for k, v in dict_'BUILDERS'.items():
+                if k == 'simple_type_factory':
+                    dict_'simple_type_factory' = staticmethod(v)
+                    continue
+
+                attr_name = 'xsd_{}'.format(k)
+                if not hasattr(base_class, attr_name):
+                    continue
+                elif getattr(base_class, attr_name) is not v:
+                    dict_attr_name = v
+
+        if isinstance(dict_.get('meta_schema'), str):
+            # Build a new meta-schema class and register it into module's globals
+            meta_schema_file: str = dict_.pop('meta_schema')
+            meta_schema_class_name = 'Meta' + name
+
+            meta_schema: OptionalSchemaType
+            meta_schema = getattr(base_class, 'meta_schema', None)
+            if meta_schema is None:
+                meta_bases = bases
+            else:
+                # Use base's meta_schema class as base for the new meta-schema
+                meta_bases = (meta_schema.__class__,)
+                if len(bases) > 1:
+                    meta_bases += bases1:
+
+            meta_schema_class = super(XMLSchemaMeta, mcs).__new__(
+                mcs, meta_schema_class_name, meta_bases, dict_
+            )
+            meta_schema_class.__qualname__ = meta_schema_class_name
+            module = sys.modulesdict_'__module__'
+            setattr(module, meta_schema_class_name, meta_schema_class)
+
+            meta_schema = meta_schema_class.create_meta_schema(meta_schema_file)
+            dict_'meta_schema' = meta_schema
+
+        # Create the class and check some basic attributes
+        cls = super(XMLSchemaMeta, mcs).__new__(mcs, name, bases, dict_)
+        if cls.XSD_VERSION not in ('1.0', '1.1'):
+            raise XMLSchemaValueError("XSD_VERSION must be '1.0' or '1.1'")
+        return cls
+
+
+class XMLSchemaBase(XsdValidator, ElementPathMixinUnionSchemaType, XsdElement,
+                    metaclass=XMLSchemaMeta):
+    """
+    Base class for an XML Schema instance.
+
+    :param source: an URI that reference to a resource or a file path or a file-like \
+    object or a string containing the schema or an Element or an ElementTree document \
+    or an :class:`XMLResource` instance. A multi source initialization is supported \
+    providing a not empty list of XSD sources.
+    :param namespace: is an optional argument that contains the URI of the namespace \
+    that has to used in case the schema has no namespace (chameleon schema). For other \
+    cases, when specified, it must be equal to the *targetNamespace* of the schema.
+    :param validation: the XSD validation mode to use for build the schema, \
+    that can be 'strict' (default), 'lax' or 'skip'.
+    :param global_maps: is an optional argument containing an :class:`XsdGlobals` \
+    instance, a mediator object for sharing declaration data between dependents \
+    schema instances.
+    :param converter: is an optional argument that can be an :class:`XMLSchemaConverter` \
+    subclass or instance, used for defining the default XML data converter for XML Schema instance.
+    :param locations: schema extra location hints, that can include custom resource locations \
+    (eg. local XSD file instead of remote resource) or additional namespaces to import after \
+    processing schema's import statements. Can be a dictionary or a sequence of couples \
+    (namespace URI, resource URL). Extra locations passed using a tuple container are not \
+    normalized.
+    :param base_url: is an optional base URL, used for the normalization of relative paths \
+    when the URL of the schema resource can't be obtained from the source argument.
+    :param allow: defines the security mode for accessing resource locations. Can be \
+    'all', 'remote', 'local' or 'sandbox'. Default is 'all' that means all types of \
+    URLs are allowed. With 'remote' only remote resource URLs are allowed. With 'local' \
+    only file paths and URLs are allowed. With 'sandbox' only file paths and URLs that \
+    are under the directory path identified by source or by the *base_url* argument \
+    are allowed.
+    :param defuse: defines when to defuse XML data using a `SafeXMLParser`. Can be \
+    'always', 'remote' or 'never'. For default defuses only remote XML data.
+    :param timeout: the timeout in seconds for fetching resources. Default is `300`.
+    :param build: defines whether build the schema maps. Default is `True`.
+    :param use_meta: if `True` the schema processor uses the validator meta-schema, \
+    otherwise a new meta-schema is added at the end. In the latter case the meta-schema \
+    is rebuilt if any base namespace has been overridden by an import. Ignored if the \
+    argument *global_maps* is provided.
+    :param use_fallback: if `True` the schema processor uses the validator fallback \
+    location hints to load well-known namespaces (eg. xhtml).
+    :param loglevel: for setting a different logging level for schema initialization \
+    and building. For default is WARNING (30). For INFO level set it with 20, for \
+    DEBUG level with 10. The default loglevel is restored after schema building, \
+    when exiting the initialization method.
+
+    :cvar XSD_VERSION: store the XSD version (1.0 or 1.1).
+    :cvar BASE_SCHEMAS: a dictionary from namespace to schema resource for meta-schema bases.
+    :cvar fallback_locations: fallback schema location hints for other standard namespaces.
+    :cvar meta_schema: the XSD meta-schema instance.
+    :cvar attribute_form_default: the schema's *attributeFormDefault* attribute. \
+    Default is 'unqualified'.
+    :cvar element_form_default: the schema's *elementFormDefault* attribute. \
+    Default is 'unqualified'.
+    :cvar block_default: the schema's *blockDefault* attribute. Default is ''.
+    :cvar final_default: the schema's *finalDefault* attribute. Default is ''.
+    :cvar default_attributes: the XSD 1.1 schema's *defaultAttributes* attribute. \
+    Default is ``None``.
+    :cvar xpath_tokens: symbol table for schema bound XPath 2.0 parsers. Initially set to \
+    ``None`` it's redefined at instance level with a dictionary at first use of the XPath \
+    selector. The parser symbol table is extended with schema types constructors.
+
+    :ivar target_namespace: is the *targetNamespace* of the schema, the namespace to which \
+    belong the declarations/definitions of the schema. If it's empty no namespace is associated \
+    with the schema. In this case the schema declarations can be reused from other namespaces as \
+    *chameleon* definitions.
+    :ivar validation: validation mode, can be 'strict', 'lax' or 'skip'.
+    :ivar maps: XSD global declarations/definitions maps. This is an instance of \
+    :class:`XsdGlobal`, that stores the *global_maps* argument or a new object \
+    when this argument is not provided.
+    :ivar converter: the default converter used for XML data decoding/encoding.
+    :ivar locations: schema location hints.
+    :ivar namespaces: a dictionary that maps from the prefixes used by the schema \
+    into namespace URI.
+    :ivar imports: a dictionary of namespace imports of the schema, that maps namespace \
+    URI to imported schema object, or `None` in case of unsuccessful import.
+    :ivar includes: a dictionary of included schemas, that maps a schema location to an \
+    included schema. It also comprehend schemas included by "xs:redefine" or \
+    "xs:override" statements.
+    :ivar warnings: warning messages about failure of import and include elements.
+
+    :ivar notations: `xsd:notation` declarations.
+    :vartype notations: NamespaceView
+    :ivar types: `xsd:simpleType` and `xsd:complexType` global declarations.
+    :vartype types: NamespaceView
+    :ivar attributes: `xsd:attribute` global declarations.
+    :vartype attributes: NamespaceView
+    :ivar attribute_groups: `xsd:attributeGroup` definitions.
+    :vartype attribute_groups: NamespaceView
+    :ivar groups: `xsd:group` global definitions.
+    :vartype groups: NamespaceView
+    :ivar elements: `xsd:element` global declarations.
+    :vartype elements: NamespaceView
+    """
+    # Instance attributes annotations
+    source: XMLResource
+    namespaces: NamespacesType
+    converter: UnionConverterType
+    locations: NamespaceResourcesMap
+    maps: XsdGlobals
+    imports: Dictstr, OptionalSchemaType
+    includes: Dictstr, SchemaType
+    warnings: Liststr
+
+    notations: NamespaceViewXsdNotation
+    types: NamespaceViewBaseXsdType
+    attributes: NamespaceViewXsdAttribute
+    attribute_groups: NamespaceViewXsdAttributeGroup
+    groups: NamespaceViewXsdGroup
+    elements: NamespaceViewXsdElement
+    substitution_groups: NamespaceViewListXsdElement
+    identities: NamespaceViewXsdIdentity
+
+    XSD_VERSION: str = '1.0'
+    meta_schema: Optional'XMLSchemaBase' = None
+    BASE_SCHEMAS: Dictstr, str = {}
+    fallback_locations: Dictstr, str = LOCATION_HINTS.copy()
+    _locations: TupleTuplestr, str, ... = ()
+    _annotations = None
+
+    # XSD components classes
+    xsd_notation_class = XsdNotation
+    xsd_complex_type_class = XsdComplexType
+    xsd_attribute_class = XsdAttribute
+    xsd_any_attribute_class = XsdAnyAttribute
+    xsd_attribute_group_class = XsdAttributeGroup
+    xsd_group_class = XsdGroup
+    xsd_element_class = XsdElement
+    xsd_any_class = XsdAnyElement
+    xsd_atomic_restriction_class = XsdAtomicRestriction
+    xsd_list_class = XsdList
+    xsd_union_class = XsdUnion
+    xsd_key_class = XsdKey
+    xsd_keyref_class = XsdKeyref
+    xsd_unique_class = XsdUnique
+
+    # Schema defaults
+    target_namespace = ''
+    attribute_form_default = 'unqualified'
+    element_form_default = 'unqualified'
+    block_default = ''
+    final_default = ''
+    redefine = None
+
+    # Additional defaults for XSD 1.1
+    default_attributes: OptionalUnionstr, XsdAttributeGroup = None
+    default_open_content = None
+    override = None
+
+    # Store XPath constructors tokens (for schema and its assertions)
+    xpath_tokens: OptionalDictstr, TypeXPathToken = None
+
+    def __init__(self, source: UnionSchemaSourceType, ListSchemaSourceType,
+                 namespace: Optionalstr = None,
+                 validation: str = 'strict',
+                 global_maps: OptionalXsdGlobals = None,
+                 converter: OptionalConverterType = None,
+                 locations: OptionalLocationsType = None,
+                 base_url: Optionalstr = None,
+                 allow: str = 'all',
+                 defuse: str = 'remote',
+                 timeout: int = 300,
+                 build: bool = True,
+                 use_meta: bool = True,
+                 use_fallback: bool = True,
+                 loglevel: OptionalUnionstr, int = None) -> None:
+
+        super(XMLSchemaBase, self).__init__(validation)
+        self.lock = threading.Lock()  # Lock for build operations
+
+        if loglevel is not None:
+            if isinstance(loglevel, str):
+                level = loglevel.strip().upper()
+                if level not in {'DEBUG', 'INFO', 'WARN', 'WARNING', 'ERROR', 'CRITICAL'}:
+                    raise XMLSchemaValueError("{!r} is not a valid loglevel".format(loglevel))
+                logger.setLevel(getattr(logging, level))
+            else:
+                logger.setLevel(loglevel)
+        elif build and global_maps is None:
+            logger.setLevel(logging.WARNING)
+
+        if allow == 'sandbox' and base_url is None and is_local_url(source):
+            # Allow sandbox mode without a base_url using the initial schema URL as base
+            assert isinstance(source, str)
+            base_url = os.path.dirname(normalize_url(source))
+
+        other_sources: ListSchemaSourceType
+        if isinstance(source, list):
+            if not source:
+                raise XMLSchemaValueError("no XSD source provided!")
+            other_sources = source1:
+            source = source0
+        else:
+            other_sources = 
+
+        if isinstance(source, XMLResource):
+            self.source = source
+        else:
+            self.source = XMLResource(source, base_url, allow, defuse, timeout)
+
+        logger.debug("Read schema from %r", self.source.url or self.source.source)
+
+        self.imports = {}
+        self.includes = {}
+        self.warnings = 
+        self._root_elements = None  # type: OptionalSetstr
+
+        self.name = self.source.name
+        root = self.source.root
+
+        # Initialize schema's namespaces, the XML namespace is implicitly declared.
+        self.namespaces = self.source.get_namespaces({'xml': XML_NAMESPACE}, root_only=True)
+
+        if 'targetNamespace' in root.attrib:
+            self.target_namespace = root.attrib'targetNamespace'.strip()
+            if not self.target_namespace:
+                # https://www.w3.org/TR/2004/REC-xmlschema-1-20041028/structures.html#element-schema
+                self.parse_error("the attribute 'targetNamespace' cannot be an empty string", root)
+            elif namespace is not None and self.target_namespace != namespace:
+                msg = "wrong namespace (%r instead of %r) for XSD resource %s"
+                self.parse_error(msg % (self.target_namespace, namespace, self.url), root)
+
+        if not self.target_namespace and namespace is not None:
+            # Chameleon schema case
+            self.target_namespace = namespace
+            if '' not in self.namespaces:
+                self.namespaces'' = namespace
+
+        elif '' not in self.namespaces:
+            # If not declared map the default namespace to no namespace
+            self.namespaces'' = ''
+
+        logger.debug("Schema targetNamespace is %r", self.target_namespace)
+        logger.debug("Declared namespaces: %r", self.namespaces)
+
+        # Parses the schema defaults
+        if 'attributeFormDefault' in root.attrib:
+            self.attribute_form_default = root.attrib'attributeFormDefault'
+
+        if 'elementFormDefault' in root.attrib:
+            self.element_form_default = root.attrib'elementFormDefault'
+
+        if 'blockDefault' in root.attrib:
+            if self.meta_schema is None:
+                pass  # Skip for XSD 1.0 meta-schema that has blockDefault="#all"
+            else:
+                try:
+                    self.block_default = get_xsd_derivation_attribute(
+                        root, 'blockDefault', {'extension', 'restriction', 'substitution'}
+                    )
+                except ValueError as err:
+                    self.parse_error(err, root)
+
+        if 'finalDefault' in root.attrib:
+            try:
+                self.final_default = get_xsd_derivation_attribute(root, 'finalDefault')
+            except ValueError as err:
+                self.parse_error(err, root)
+
+        if converter is None:
+            self.converter = XMLSchemaConverter
+        else:
+            self.converter = self.get_converter(converter)
+
+        if self.meta_schema is None:
+            self.locations = NamespaceResourcesMap()
+
+            # Meta-schema maps creation (MetaXMLSchema10/11 classes)
+            self.maps = global_maps or XsdGlobals(self)
+            for child in self.source.root:
+                if child.tag == XSD_OVERRIDE:
+                    self.include_schema(child.attrib'schemaLocation', self.base_url)
+            return  # Meta-schemas don't need to be checked and don't process imports
+
+        # Completes the namespaces map with internal declarations, remapping same prefixes.
+        self.namespaces = self.source.get_namespaces(self.namespaces)
+
+        if locations:
+            if isinstance(locations, tuple):
+                self._locations = locations
+            else:
+                self._locations = tuple(normalize_locations(locations, self.base_url))
+
+        self.locations = NamespaceResourcesMap(self.source.get_locations(self._locations))
+        if not use_fallback:
+            self.fallback_locations = {}
+
+        with self.meta_schema.lock:
+            if not self.meta_schema.maps.types:
+                self.meta_schema.maps.build()
+
+        # Create or set the XSD global maps instance
+        if isinstance(global_maps, XsdGlobals):
+            self.maps = global_maps
+        elif global_maps is not None:
+            raise XMLSchemaTypeError("'global_maps' argument must be an %r instance" % XsdGlobals)
+        elif use_meta and self.target_namespace not in self.meta_schema.maps.namespaces:
+            self.maps = self.meta_schema.maps.copy(self, validation)
+        else:
+            self.maps = XsdGlobals(self, validation)
+
+        if any(ns == VC_NAMESPACE for ns in self.namespaces.values()):
+            # For XSD 1.1+ apply versioning filter to schema tree. See the paragraph
+            # 4.2.2 of XSD 1.1 (Part 1: Structures) definition for details.
+            # Ref: https://www.w3.org/TR/xmlschema11-1/#cip
+            if prune_etree(root, selector=lambda x: not self.version_check(x)):
+                for k in list(root.attrib):
+                    if k not in {'targetNamespace', VC_MIN_VERSION, VC_MAX_VERSION}:
+                        del root.attribk
+
+        # Validate the schema document (transforming validation errors to parse errors)
+        if validation != 'skip':
+            for e in self.meta_schema.iter_errors(root, namespaces=self.namespaces):
+                self.parse_error(e.reason or e, elem=e.elem)
+
+        self._parse_inclusions()
+        self._parse_imports()
+
+        # Imports by argument (usually from xsi:schemaLocation attribute).
+        for ns in self.locations:
+            if ns not in self.maps.namespaces:
+                self._import_namespace(ns, self.locationsns)
+
+        # XSD 1.1 default declarations (defaultAttributes, defaultOpenContent,
+        # xpathDefaultNamespace)
+        if self.XSD_VERSION > '1.0':
+            self.xpath_default_namespace = self._parse_xpath_default_namespace(root)
+            if 'defaultAttributes' in root.attrib:
+                try:
+                    self.default_attributes = self.resolve_qname(root.attrib'defaultAttributes')
+                except (ValueError, KeyError, RuntimeError) as err:
+                    self.parse_error(err, root)
+
+            for child in root:
+                if child.tag == XSD_DEFAULT_OPEN_CONTENT:
+                    self.default_open_content = XsdDefaultOpenContent(child, self)
+                    break
+
+        _source: UnionSchemaSourceType, XMLResource
+        for _source in other_sources:
+            if not isinstance(_source, XMLResource):
+                _source = XMLResource(_source, base_url, allow, defuse, timeout)
+
+            if not _source.root.get('targetNamespace') and self.target_namespace:
+                # Adding a chameleon schema: set the namespace with targetNamespace
+                self.add_schema(_source, namespace=self.target_namespace)
+            else:
+                self.add_schema(_source)
+
+        try:
+            if build:
+                self.maps.build()
+        finally:
+            if loglevel is not None:
+                logger.setLevel(logging.WARNING)  # Restore default logging
+
+    def __getstate__(self) -> Dictstr, Any:
+        state = self.__dict__.copy()
+        state.pop('lock', None)
+        state.pop('xpath_tokens', None)
+        return state
+
+    def __setstate__(self, state: Dictstr, Any) -> None:
+        self.__dict__.update(state)
+        self.lock = threading.Lock()
+
+    def __repr__(self) -> str:
+        if self.url:
+            return '%s(name=%r, namespace=%r)' % (
+                self.__class__.__name__, self.name, self.target_namespace
+            )
+        return '%s(namespace=%r)' % (self.__class__.__name__, self.target_namespace)
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        if name == 'maps':
+            if self.meta_schema is None and hasattr(self, 'maps'):
+                msg = "cannot change the global maps instance of a meta-schema"
+                raise XMLSchemaValueError(msg)
+
+            super(XMLSchemaBase, self).__setattr__(name, value)
+            self.notations = NamespaceView(value.notations, self.target_namespace)
+            self.types = NamespaceView(value.types, self.target_namespace)
+            self.attributes = NamespaceView(value.attributes, self.target_namespace)
+            self.attribute_groups = NamespaceView(value.attribute_groups,
+                                                  self.target_namespace)
+            self.groups = NamespaceView(value.groups, self.target_namespace)
+            self.elements = NamespaceView(value.elements, self.target_namespace)
+            self.substitution_groups = NamespaceView(value.substitution_groups,
+                                                     self.target_namespace)
+            self.identities = NamespaceView(value.identities, self.target_namespace)
+            value.register(self)
+        else:
+            if name == 'validation':
+                check_validation_mode(value)
+            super(XMLSchemaBase, self).__setattr__(name, value)
+
+    def __iter__(self) -> IteratorXsdElement:
+        yield from sorted(self.elements.values(), key=lambda x: x.name)
+
+    def __reversed__(self) -> IteratorXsdElement:
+        yield from sorted(self.elements.values(), key=lambda x: x.name, reverse=True)
+
+    def __len__(self) -> int:
+        return len(self.elements)
+
+    @property
+    def xpath_proxy(self) -> XMLSchemaProxy:
+        return XMLSchemaProxy(cast(XMLSchemaProtocol, self))
+
+    @property
+    def xsd_version(self) -> str:
+        """Compatibility property that returns the class attribute XSD_VERSION."""
+        return self.XSD_VERSION
+
+    # XML resource attributes access
+    @property
+    def root(self) -> ElementType:
+        """Root element of the schema."""
+        return self.source.root
+
+    def get_text(self) -> str:
+        """Returns the source text of the XSD schema."""
+        return self.source.get_text()
+
+    @property
+    def url(self) -> Optionalstr:
+        """Schema resource URL, is `None` if the schema is built from an Element or a string."""
+        return self.source.url
+
+    @property
+    def base_url(self) -> Optionalstr:
+        """The base URL of the source of the schema."""
+        return self.source.base_url
+
+    @property
+    def filepath(self) -> Optionalstr:
+        """The filepath if the schema is loaded from a local XSD file, `None` otherwise."""
+        return self.source.filepath
+
+    @property
+    def allow(self) -> str:
+        """Defines the resource access security mode, can be 'all', 'local' or 'sandbox'."""
+        return self.source.allow
+
+    @property
+    def defuse(self) -> str:
+        """Defines when to defuse XML data, can be 'always', 'remote' or 'never'."""
+        return self.source.defuse
+
+    @property
+    def timeout(self) -> int:
+        """Timeout in seconds for fetching resources."""
+        return self.source.timeout
+
+    @property
+    def use_meta(self) -> bool:
+        """Returns `True` if the class meta-schema is used."""
+        return self.meta_schema is self.__class__.meta_schema
+
+    # Schema root attributes
+    @property
+    def tag(self) -> str:
+        """Schema root tag. For compatibility with the ElementTree API."""
+        return self.source.root.tag
+
+    @property
+    def id(self) -> Optionalstr:
+        """The schema's *id* attribute, defaults to ``None``."""
+        return self.source.root.get('id')
+
+    @property
+    def version(self) -> Optionalstr:
+        """The schema's *version* attribute, defaults to ``None``."""
+        return self.source.root.get('version')
+
+    @property
+    def schema_location(self) -> ListTuplestr, str:
+        """
+        A list of location hints extracted from the *xsi:schemaLocation* attribute of the schema.
+        """
+        return (k, v) for k, v in self.source.iter_location_hints() if k
+
+    @property
+    def no_namespace_schema_location(self) -> Optionalstr:
+        """
+        A location hint extracted from the *xsi:noNamespaceSchemaLocation* attribute of the schema.
+        """
+        for k, v in self.source.iter_location_hints():
+            if not k:
+                return v
+        return None
+
+    @property
+    def default_namespace(self) -> Optionalstr:
+        """The namespace associated to the empty prefix ''."""
+        return self.namespaces.get('')
+
+    @property
+    def target_prefix(self) -> str:
+        """The prefix associated to the *targetNamespace*."""
+        for prefix, namespace in self.namespaces.items():
+            if namespace == self.target_namespace:
+                return prefix
+        return ''
+
+    @classmethod
+    def builtin_types(cls) -> NamespaceViewBaseXsdType:
+        """Returns the XSD built-in types of the meta-schema."""
+        if cls.meta_schema is None:
+            raise XMLSchemaRuntimeError("meta-schema unavailable for %r" % cls)
+
+        try:
+            meta_schema: SchemaType = cls.meta_schema.maps.namespacesXSD_NAMESPACE0
+            builtin_types = meta_schema.types
+        except KeyError:
+            raise XMLSchemaNotBuiltError(cls.meta_schema, "missing XSD namespace in meta-schema")
+        else:
+            if not builtin_types:
+                cls.meta_schema.build()
+            return builtin_types
+
+    @property
+    def annotations(self) -> ListXsdAnnotation:
+        if self._annotations is None:
+            self._annotations = 
+                XsdAnnotation(child, self) for child in self.source.root
+                if child.tag == XSD_ANNOTATION
+            
+        return self._annotations
+
+    @property
+    def root_elements(self) -> ListXsdElement:
+        """
+        The list of global elements that are not used by reference in any model of the schema.
+        This is implemented as lazy property because it's computationally expensive to build
+        when the schema model is complex.
+        """
+        if not self.elements:
+            return 
+        elif len(self.elements) == 1:
+            return list(self.elements.values())
+        elif self._root_elements is None:
+            names = set(e.name for e in self.elements.values())
+            for xsd_element in self.elements.values():
+                for e in xsd_element.iter():
+                    if e is xsd_element or isinstance(e, XsdAnyElement):
+                        continue
+                    elif e.ref or e.parent is None:
+                        if e.name in names:
+                            names.discard(e.name)
+                            if not names:
+                                break
+            self._root_elements = set(names)
+
+        assert self._root_elements is not None
+        return e for e in self.elements.values() if e.name in self._root_elements
+
+    @property
+    def simple_types(self) -> ListXsdSimpleType:
+        """Returns a list containing the global simple types."""
+        return x for x in self.types.values() if isinstance(x, XsdSimpleType)
+
+    @property
+    def complex_types(self) -> ListXsdComplexType:
+        """Returns a list containing the global complex types."""
+        return x for x in self.types.values() if isinstance(x, XsdComplexType)
+
+    @classmethod
+    def create_meta_schema(cls, source: Optionalstr = None,
+                           base_schemas: UnionNone, Dictstr, str,
+                                               ListTuplestr, str = None,
+                           global_maps: OptionalXsdGlobals = None) -> SchemaType:
+        """
+        Creates a new meta-schema instance.
+
+        :param source: an optional argument referencing to or containing the XSD meta-schema \
+        resource. Required if the schema class doesn't already have a meta-schema.
+        :param base_schemas: an optional dictionary that contains namespace URIs and \
+        schema locations. If provided is used as substitute for class BASE_SCHEMAS. \
+        Also a sequence of (namespace, location) items can be provided if there are more \
+        schema documents for one or more namespaces.
+        :param global_maps: is an optional argument containing an :class:`XsdGlobals` \
+        instance for the new meta schema. If not provided a new map is created.
+        """
+        if source is None:
+            if cls.meta_schema is None or cls.meta_schema.url:
+                raise XMLSchemaValueError("Missing meta-schema source URL")
+            source = cast(str, cls.meta_schema.url)
+
+        _base_schemas: UnionItemsViewstr, str, ListTuplestr, str
+        if base_schemas is None:
+            _base_schemas = cls.BASE_SCHEMAS.items()
+        elif isinstance(base_schemas, dict):
+            _base_schemas = base_schemas.items()
+        else:
+            try:
+                _base_schemas = (n, l) for n, l in base_schemas
+            except ValueError:
+                raise ValueError(
+                    "The argument 'base_schemas' is not a dictionary nor a sequence of items"
+                )
+
+        meta_schema: SchemaType
+        meta_schema_class = cls if cls.meta_schema is None else cls.meta_schema.__class__
+        meta_schema = meta_schema_class(source, XSD_NAMESPACE, global_maps=global_maps,
+                                        defuse='never', build=False)
+        for ns, location in _base_schemas:
+            if ns == XSD_NAMESPACE:
+                meta_schema.include_schema(location=location)
+            else:
+                meta_schema.import_schema(namespace=ns, location=location)
+        return meta_schema
+
+    def simple_type_factory(self, elem: ElementType,
+                            schema: OptionalSchemaType = None,
+                            parent: OptionalXsdComponent = None) -> XsdSimpleType:
+        """
+        Factory function for XSD simple types. Parses the xs:simpleType element and its
+        child component, that can be a restriction, a list or an union. Annotations are
+        linked to simple type instance, omitting the inner annotation if both are given.
+        """
+        if schema is None:
+            schema = self
+
+        annotation = None
+        try:
+            child = elem0
+        except IndexError:
+            return cast(XsdSimpleType, self.maps.typesXSD_ANY_SIMPLE_TYPE)
+        else:
+            if child.tag == XSD_ANNOTATION:
+                annotation = XsdAnnotation(child, schema, parent)
+                try:
+                    child = elem1
+                except IndexError:
+                    schema.parse_error("(restriction | list | union) expected", elem)
+                    return cast(XsdSimpleType, self.maps.typesXSD_ANY_SIMPLE_TYPE)
+
+        xsd_type: XsdSimpleType
+        if child.tag == XSD_RESTRICTION:
+            xsd_type = self.xsd_atomic_restriction_class(child, schema, parent)
+        elif child.tag == XSD_LIST:
+            xsd_type = self.xsd_list_class(child, schema, parent)
+        elif child.tag == XSD_UNION:
+            xsd_type = self.xsd_union_class(child, schema, parent)
+        else:
+            schema.parse_error("(restriction | list | union) expected", elem)
+            return cast(XsdSimpleType, self.maps.typesXSD_ANY_SIMPLE_TYPE)
+
+        if annotation is not None:
+            xsd_type._annotation = annotation
+
+        try:
+            xsd_type.name = get_qname(schema.target_namespace, elem.attrib'name')
+        except KeyError:
+            if parent is None:
+                schema.parse_error("missing attribute 'name' in a global simpleType", elem)
+                xsd_type.name = 'nameless_%s' % str(id(xsd_type))
+        else:
+            if parent is not None:
+                schema.parse_error("attribute 'name' not allowed for a local simpleType", elem)
+                xsd_type.name = None
+
+        if 'final' in elem.attrib:
+            try:
+                xsd_type._final = get_xsd_derivation_attribute(elem, 'final')
+            except ValueError as err:
+                xsd_type.parse_error(err, elem)
+
+        return xsd_type
+
+    def create_any_content_group(self, parent: UnionXsdComplexType, XsdGroup,
+                                 any_element: OptionalXsdAnyElement = None) -> XsdGroup:
+        """
+        Creates a model group related to schema instance that accepts any content.
+
+        :param parent: the parent component to set for the any content group.
+        :param any_element: an optional any element to use for the content group. \
+        When provided it's copied, linked to the group and the minOccurs/maxOccurs \
+        are set to 0 and 'unbounded'.
+        """
+        group: XsdGroup = self.xsd_group_class(SEQUENCE_ELEMENT, self, parent)
+
+        if isinstance(any_element, XsdAnyElement):
+            particle = any_element.copy()
+            particle.min_occurs = 0
+            particle.max_occurs = None
+            particle.parent = group
+            group.append(particle)
+        else:
+            group.append(self.xsd_any_class(ANY_ELEMENT, self, group))
+
+        return group
+
+    def create_empty_content_group(self, parent: UnionXsdComplexType, XsdGroup,
+                                   model: str = 'sequence', **attrib: Any) -> XsdGroup:
+        if model == 'sequence':
+            group_elem = etree_element(XSD_SEQUENCE, **attrib)
+        elif model == 'choice':
+            group_elem = etree_element(XSD_CHOICE, **attrib)
+        elif model == 'all':
+            group_elem = etree_element(XSD_ALL, **attrib)
+        else:
+            raise XMLSchemaValueError("'model' argument must be (sequence | choice | all)")
+
+        group_elem.text = '\n    '
+        return self.xsd_group_class(group_elem, self, parent)
+
+    def create_any_attribute_group(self, parent: UnionXsdComplexType, XsdElement) \
+            -> XsdAttributeGroup:
+        """
+        Creates an attribute group related to schema instance that accepts any attribute.
+
+        :param parent: the parent component to set for the any attribute group.
+        """
+        attribute_group = self.xsd_attribute_group_class(
+            ATTRIBUTE_GROUP_ELEMENT, self, parent
+        )
+        attribute_groupNone = self.xsd_any_attribute_class(
+            ANY_ATTRIBUTE_ELEMENT, self, attribute_group
+        )
+        return attribute_group
+
+    def create_empty_attribute_group(self, parent: UnionXsdComplexType, XsdElement) \
+            -> XsdAttributeGroup:
+        """
+        Creates an empty attribute group related to schema instance.
+
+        :param parent: the parent component to set for the any attribute group.
+        """
+        return self.xsd_attribute_group_class(ATTRIBUTE_GROUP_ELEMENT, self, parent)
+
+    def create_any_type(self) -> XsdComplexType:
+        """
+        Creates an xs:anyType equivalent type related with the wildcards
+        connected to global maps of the schema instance in order to do a
+        correct namespace lookup during wildcards validation.
+        """
+        schema = self.meta_schema or self
+        any_type = self.xsd_complex_type_class(
+            elem=etree_element(XSD_COMPLEX_TYPE, name=XSD_ANY_TYPE),
+            schema=schema, parent=None, mixed=True, block='', final=''
+        )
+        assert isinstance(any_type.content, XsdGroup)
+        any_type.content.append(self.xsd_any_class(
+            ANY_ELEMENT, schema, any_type.content
+        ))
+        any_type.attributesNone = self.xsd_any_attribute_class(
+            ANY_ATTRIBUTE_ELEMENT, schema, any_type.attributes
+        )
+        any_type.maps = any_type.content.maps = any_type.content0.maps = \
+            any_type.attributesNone.maps = self.maps
+        return any_type
+
+    def create_element(self, name: str, parent: OptionalXsdComponent = None,
+                       text: Optionalstr = None, **attrib: Any) -> XsdElement:
+        """
+        Creates an xs:element instance related to schema component.
+        Used as dummy element for validation/decoding/encoding
+        operations of wildcards and complex types.
+        """
+        elem = etree_element(XSD_ELEMENT, name=name, **attrib)
+        if text is not None:
+            elem.text = text
+        return self.xsd_element_class(elem=elem, schema=self, parent=parent)
+
+    def copy(self) -> SchemaType:
+        """
+        Makes a copy of the schema instance. The new instance has independent maps
+        of shared XSD components.
+        """
+        schema: SchemaType = object.__new__(self.__class__)
+        schema.__dict__.update(self.__dict__)
+        schema.source = copy(self.source)
+        schema.errors = self.errors:
+        schema.warnings = self.warnings:
+        schema.namespaces = dict(self.namespaces)
+        schema.locations = NamespaceResourcesMap(self.locations)
+        schema.imports = self.imports.copy()
+        schema.includes = self.includes.copy()
+        schema.maps = self.maps.copy(validator=schema)
+        return schema
+
+    __copy__ = copy
+
+    @classmethod
+    def check_schema(cls, schema: SchemaType,
+                     namespaces: OptionalNamespacesType = None) -> None:
+        """
+        Validates the given schema against the XSD meta-schema (:attr:`meta_schema`).
+
+        :param schema: the schema instance that has to be validated.
+        :param namespaces: is an optional mapping from namespace prefix to URI.
+
+        :raises: :exc:`XMLSchemaValidationError` if the schema is invalid.
+        """
+        if cls.meta_schema is None:
+            raise XMLSchemaRuntimeError("meta-schema unavailable for %r" % cls)
+        elif not cls.meta_schema.maps.types:
+            cls.meta_schema.maps.build()
+
+        for error in cls.meta_schema.iter_errors(schema.source, namespaces=namespaces):
+            raise error
+
+    def check_validator(self, validation: str = 'strict') -> None:
+        """Checks the status of a schema validator against a validation mode."""
+        check_validation_mode(validation)
+
+        if self.built:
+            pass
+        elif self.meta_schema is None:
+            self.build()  # Meta-schema lazy build
+        elif validation == 'skip' and self.validation == 'skip' and \
+                any(isinstance(comp, tuple) or comp.validation_attempted == 'partial'
+                    for comp in self.iter_globals()):
+            pass
+        else:
+            raise XMLSchemaNotBuiltError(self, "schema %r is not built" % self)
+
+    def build(self) -> None:
+        """Builds the schema's XSD global maps."""
+        self.maps.build()
+
+    def clear(self) -> None:
+        """Clears the schema's XSD global maps."""
+        self.maps.clear()
+
+    @property
+    def built(self) -> bool:
+        if any(not isinstance(g, XsdComponent) or not g.built for g in self.iter_globals()):
+            return False
+        for _ in self.iter_globals():
+            return True
+        if self.meta_schema is None:
+            return False
+
+        # No XSD globals: check with a lookup of schema child elements.
+        prefix = '{%s}' % self.target_namespace if self.target_namespace else ''
+        for child in self.source.root:
+            if child.tag in {XSD_REDEFINE, XSD_OVERRIDE}:
+                for e in filter(lambda x: x.tag in GLOBAL_TAGS, child):
+                    name = e.get('name')
+                    if name is not None:
+                        try:
+                            if not self.maps.lookup(e.tag, prefix + name if prefix else name).built:
+                                return False
+                        except KeyError:
+                            return False
+            elif child.tag in GLOBAL_TAGS:
+                name = child.get('name')
+                if name is not None:
+                    try:
+                        if not self.maps.lookup(child.tag, prefix + name if prefix else name).built:
+                            return False
+                    except KeyError:
+                        return False
+        return True
+
+    @property
+    def validation_attempted(self) -> str:
+        if self.built:
+            return 'full'
+        elif any(isinstance(comp, tuple) or comp.validation_attempted == 'partial'
+                 for comp in self.iter_globals()):
+            return 'partial'
+        else:
+            return 'none'
+
+    def iter_globals(self, schema: OptionalSchemaType = None) \
+            -> IteratorUnionSchemaGlobalType, TupleAny, ...:
+        """
+        Creates an iterator for XSD global definitions/declarations related to schema namespace.
+
+        :param schema: Optional argument for filtering only globals related to a schema instance.
+        """
+        if schema is None:
+            yield from self.notations.values()
+            yield from self.types.values()
+            yield from self.attributes.values()
+            yield from self.attribute_groups.values()
+            yield from self.groups.values()
+            yield from self.elements.values()
+        else:
+            def schema_filter(x: UnionXsdComponent, TupleElementType, SchemaType) -> bool:
+                if isinstance(x, tuple):
+                    return x1 is schema
+                return x.schema is schema
+
+            yield from filter(schema_filter, self.notations.values())
+            yield from filter(schema_filter, self.types.values())
+            yield from filter(schema_filter, self.attributes.values())
+            yield from filter(schema_filter, self.attribute_groups.values())
+            yield from filter(schema_filter, self.groups.values())
+            yield from filter(schema_filter, self.elements.values())
+
+    def iter_components(self, xsd_classes: ComponentClassType = None) \
+            -> IteratorUnionXsdComponent, SchemaType:
+        """
+        Iterates yielding the schema and its components. For default
+        includes all the relevant components of the schema, excluding
+        only facets and empty attribute groups. The first returned
+        component is the schema itself.
+
+        :param xsd_classes: provide a class or a tuple of classes to \
+        restrict the range of component types yielded.
+        """
+        if xsd_classes is None or isinstance(self, xsd_classes):
+            yield self
+        for xsd_global in self.iter_globals(self):
+            if not isinstance(xsd_global, tuple):
+                yield from xsd_global.iter_components(xsd_classes)
+
+    def get_schema(self, namespace: str) -> SchemaType:
+        """
+        Returns the first schema loaded for a namespace. Raises a
+        `KeyError` if the requested namespace is not loaded.
+        """
+        try:
+            return cast(SchemaType, self.maps.namespacesnamespace0)
+        except KeyError:
+            if not namespace:
+                return self
+            raise XMLSchemaKeyError('the namespace {!r} is not loaded'.format(namespace)) from None
+
+    def get_converter(self, converter: OptionalConverterType = None,
+                      **kwargs: Any) -> XMLSchemaConverter:
+        """
+        Returns a new converter instance.
+
+        :param converter: can be a converter class or instance. If it's an instance \
+        the new instance is copied from it and configured with the provided arguments.
+        :param kwargs: optional arguments for initialize the converter instance.
+        :return: a converter instance.
+        """
+        if converter is None:
+            converter = self.converter
+
+        if isinstance(converter, XMLSchemaConverter):
+            return converter.copy(**kwargs)
+        elif issubclass(converter, XMLSchemaConverter):
+            # noinspection PyCallingNonCallable
+            return converter(**kwargs)
+        else:
+            msg = "'converter' argument must be a %r subclass or instance: %r"
+            raise XMLSchemaTypeError(msg % (XMLSchemaConverter, converter))
+
+    def get_locations(self, namespace: str) -> Liststr:
+        """Get a list of location hints for a namespace."""
+        try:
+            return list(self.locationsnamespace)
+        except KeyError:
+            return 
+
+    def get_element(self, tag: str, path: Optionalstr = None,
+                    namespaces: OptionalNamespacesType = None) -> OptionalXsdElement:
+        if not path:
+            xsd_element = self.find(tag)
+            return xsd_element if isinstance(xsd_element, XsdElement) else None
+        elif path-1 == '*':
+            xsd_element = self.find(path:-1 + tag, namespaces)
+            if isinstance(xsd_element, XsdElement):
+                return xsd_element
+
+            obj = self.maps.elements.get(tag)
+            return obj if isinstance(obj, XsdElement) else None
+        else:
+            xsd_element = self.find(path, namespaces)
+            return xsd_element if isinstance(xsd_element, XsdElement) else None
+
+    def create_bindings(self, *bases: type, **attrs: Any) -> None:
+        """
+        Creates data object bindings for XSD elements of the schema.
+
+        :param bases: base classes to use for creating the binding classes.
+        :param attrs: attribute and method definitions for the binding classes body.
+        """
+        for xsd_component in self.iter_components():
+            if isinstance(xsd_component, XsdElement):
+                xsd_component.get_binding(*bases, replace_existing=True, **attrs)
+
+    def _parse_inclusions(self) -> None:
+        """Processes schema document inclusions and redefinitions/overrides."""
+        for child in self.source.root:
+            if child.tag == XSD_INCLUDE:
+                try:
+                    location = child.attrib'schemaLocation'.strip()
+                    logger.info("Include schema from %r", location)
+                    self.include_schema(location, self.base_url)
+                except KeyError:
+                    # Attribute missing error already found by validation against meta-schema
+                    pass
+                except (OSError, IOError) as err:
+                    # It is not an error if the location fail to resolve:
+                    #   https://www.w3.org/TR/2012/REC-xmlschema11-1-20120405/#compound-schema
+                    #   https://www.w3.org/TR/2012/REC-xmlschema11-1-20120405/#src-include
+                    self.warnings.append("Include schema failed: %s." % str(err))
+                    warnings.warn(self.warnings-1, XMLSchemaIncludeWarning, stacklevel=3)
+                except (XMLSchemaParseError, XMLSchemaTypeError, ParseError) as err:
+                    msg = 'cannot include schema %r: %s' % (child.attrib'schemaLocation', err)
+                    if isinstance(err, (XMLSchemaParseError, ParseError)):
+                        self.parse_error(msg)
+                    else:
+                        raise type(err)(msg)
+
+            elif child.tag == XSD_REDEFINE:
+                try:
+                    location = child.attrib'schemaLocation'.strip()
+                    logger.info("Redefine schema %r", location)
+                    schema = self.include_schema(location, self.base_url)
+                except KeyError:
+                    # Attribute missing error already found by validation against meta-schema
+                    pass
+                except (OSError, IOError) as err:
+                    # If the redefine doesn't contain components (annotation excluded)
+                    # the statement is equivalent to an include, so no error is generated.
+                    # Otherwise fails.
+                    self.warnings.append("Redefine schema failed: %s." % str(err))
+                    warnings.warn(self.warnings-1, XMLSchemaIncludeWarning, stacklevel=3)
+                    if any(e.tag != XSD_ANNOTATION and not callable(e.tag) for e in child):
+                        self.parse_error(err, child)
+                except (XMLSchemaParseError, XMLSchemaTypeError, ParseError) as err:
+                    msg = 'cannot redefine schema %r: %s' % (child.attrib'schemaLocation', err)
+                    if isinstance(err, (XMLSchemaParseError, ParseError)):
+                        self.parse_error(msg, child)
+                    else:
+                        raise type(err)(msg)
+                else:
+                    schema.redefine = self
+
+            elif child.tag == XSD_OVERRIDE and self.XSD_VERSION != '1.0':
+                try:
+                    location = child.attrib'schemaLocation'.strip()
+                    logger.info("Override schema %r", location)
+                    schema = self.include_schema(location, self.base_url)
+                except KeyError:
+                    # Attribute missing error already found by validation against meta-schema
+                    pass
+                except (OSError, IOError) as err:
+                    # If the override doesn't contain components (annotation excluded)
+                    # the statement is equivalent to an include, so no error is generated.
+                    # Otherwise fails.
+                    self.warnings.append("Override schema failed: %s." % str(err))
+                    warnings.warn(self.warnings-1, XMLSchemaIncludeWarning, stacklevel=3)
+                    if any(e.tag != XSD_ANNOTATION and not callable(e.tag) for e in child):
+                        self.parse_error(str(err), child)
+                else:
+                    schema.override = self
+
+    def include_schema(self, location: str, base_url: Optionalstr = None,
+                       build: bool = False) -> SchemaType:
+        """
+        Includes a schema for the same namespace, from a specific URL.
+
+        :param location: is the URL of the schema.
+        :param base_url: is an optional base URL for fetching the schema resource.
+        :param build: defines when to build the imported schema, the default is to not build.
+        :return: the included :class:`XMLSchema` instance.
+        """
+        schema: SchemaType
+        schema_url = fetch_resource(location, base_url)
+        for schema in self.maps.namespacesself.target_namespace:
+            if schema_url == schema.url:
+                logger.info("Resource %r is already loaded", location)
+                break
+        else:
+            schema = type(self)(
+                source=schema_url,
+                namespace=self.target_namespace,
+                validation=self.validation,
+                global_maps=self.maps,
+                converter=self.converter,
+                locations=self._locations,
+                base_url=self.base_url,
+                allow=self.allow,
+                defuse=self.defuse,
+                timeout=self.timeout,
+                build=build,
+            )
+
+        if schema is self:
+            return self
+        elif location not in self.includes:
+            self.includeslocation = schema
+        elif self.includeslocation is not schema:
+            self.includesschema_url = schema
+        return schema
+
+    def _parse_imports(self) -> None:
+        """
+        Parse namespace import elements. Imports are done on namespace basis, not on
+        single resource. A warning is generated for a failure of a namespace import.
+        """
+        namespace_imports = NamespaceResourcesMap(map(
+            lambda x: (x.get('namespace'), x.get('schemaLocation')),
+            filter(lambda x: x.tag == XSD_IMPORT, self.source.root)
+        ))
+
+        for namespace, locations in namespace_imports.items():
+
+            # Checks the namespace against the targetNamespace of the schema
+            if namespace is None:
+                namespace = ''
+                if namespace == self.target_namespace:
+                    self.parse_error("if the 'namespace' attribute is not present on "
+                                     "the import statement then the importing schema "
+                                     "must have a 'targetNamespace'")
+                    continue
+            elif namespace == self.target_namespace:
+                self.parse_error("the attribute 'namespace' must be different from "
+                                 "schema's 'targetNamespace'")
+                continue
+
+            # Skip import of already imported namespaces
+            if self.imports.get(namespace) is not None:
+                continue
+            elif namespace in self.maps.namespaces:
+                self.importsnamespace = self.maps.namespacesnamespace0
+                continue
+
+            locations = url for url in locations if url
+            if not namespace:
+                pass
+            elif not locations:
+                locations = self.get_locations(namespace)
+            elif all(is_remote_url(url) for url in locations):
+                # If all import schema locations are remote URLs and there are local hints
+                # that match a local file path, try the local hints before schema locations.
+                # This is not the standard processing for XSD imports, but resolve the problem
+                # of local processing of schemas tested to work from a http server, providing
+                # explicit local hints.
+                local_hints = url for url in self.get_locations(namespace)
+                               if url and url_path_is_file(url)
+                if local_hints:
+                    locations = local_hints + locations
+
+            if namespace in self.fallback_locations:
+                locations.append(self.fallback_locationsnamespace)
+
+            self._import_namespace(namespace, locations)
+
+    def _import_namespace(self, namespace: str, locations: Liststr) -> None:
+        import_error = None
+        for url in locations:
+            try:
+                logger.debug("Import namespace %r from %r", namespace, url)
+                self.import_schema(namespace, url, self.base_url)
+            except (OSError, IOError) as err:
+                # It's not an error if the location access fails (ref. section 4.2.6.2):
+                #   https://www.w3.org/TR/2012/REC-xmlschema11-1-20120405/#composition-schemaImport
+                logger.debug('%s', err)
+                if import_error is None:
+                    import_error = err
+            except (XMLSchemaParseError, XMLSchemaTypeError, ParseError) as err:
+                if namespace:
+                    msg = "cannot import namespace %r: %s." % (namespace, err)
+                else:
+                    msg = "cannot import chameleon schema: %s." % err
+                if isinstance(err, (XMLSchemaParseError, ParseError)):
+                    self.parse_error(msg)
+                else:
+                    raise type(err)(msg)
+            except XMLSchemaValueError as err:
+                self.parse_error(err)
+            else:
+                logger.info("Namespace %r imported from %r", namespace, url)
+                break
+        else:
+            if import_error is not None:
+                msg = "Import of namespace {!r} from {!r} failed: {}."
+                self.warnings.append(msg.format(namespace, locations, str(import_error)))
+                warnings.warn(self.warnings-1, XMLSchemaImportWarning, stacklevel=4)
+            self.importsnamespace = None
+
+    def import_schema(self, namespace: str, location: str, base_url: Optionalstr = None,
+                      force: bool = False, build: bool = False) -> OptionalSchemaType:
+        """
+        Imports a schema for an external namespace, from a specific URL.
+
+        :param namespace: is the URI of the external namespace.
+        :param location: is the URL of the schema.
+        :param base_url: is an optional base URL for fetching the schema resource.
+        :param force: if set to `True` imports the schema also if the namespace is already imported.
+        :param build: defines when to build the imported schema, the default is to not build.
+        :return: the imported :class:`XMLSchema` instance.
+        """
+        if location == self.url:
+            return self
+
+        if not force:
+            if self.imports.get(namespace) is not None:
+                return self.importsnamespace
+            elif namespace in self.maps.namespaces:
+                self.importsnamespace = self.maps.namespacesnamespace0
+                return self.importsnamespace
+
+        schema: SchemaType
+        schema_url = fetch_resource(location, base_url)
+        imported_ns = self.imports.get(namespace)
+        if imported_ns is not None and imported_ns.url == schema_url:
+            return imported_ns
+        elif namespace in self.maps.namespaces:
+            for schema in self.maps.namespacesnamespace:
+                if schema_url == schema.url:
+                    self.importsnamespace = schema
+                    return schema
+
+        schema = type(self)(
+            source=schema_url,
+            validation=self.validation,
+            global_maps=self.maps,
+            converter=self.converter,
+            locations=self._locations,
+            base_url=self.base_url,
+            allow=self.allow,
+            defuse=self.defuse,
+            timeout=self.timeout,
+            build=build,
+        )
+        if schema.target_namespace != namespace:
+            raise XMLSchemaValueError(
+                'imported schema %r has an unmatched namespace %r' % (location, namespace)
+            )
+        self.importsnamespace = schema
+        return schema
+
+    def add_schema(self, source: SchemaSourceType,
+                   namespace: Optionalstr = None, build: bool = False) -> SchemaType:
+        """
+        Add another schema source to the maps of the instance.
+
+        :param source: an URI that reference to a resource or a file path or a file-like \
+        object or a string containing the schema or an Element or an ElementTree document.
+        :param namespace: is an optional argument that contains the URI of the namespace \
+        that has to used in case the schema has no namespace (chameleon schema). For other \
+        cases, when specified, it must be equal to the *targetNamespace* of the schema.
+        :param build: defines when to build the imported schema, the default is to not build.
+        :return: the added :class:`XMLSchema` instance.
+        """
+        return type(self)(
+            source=source,
+            namespace=namespace,
+            validation=self.validation,
+            global_maps=self.maps,
+            converter=self.converter,
+            locations=self._locations,
+            base_url=self.base_url,
+            allow=self.allow,
+            defuse=self.defuse,
+            timeout=self.timeout,
+            build=build,
+        )
+
+    def export(self, target: str, save_remote: bool = False) -> None:
+        """
+        Exports a schema instance. The schema instance is exported to a
+        directory with also the hierarchy of imported/included schemas.
+
+        :param target: a path to a local empty directory.
+        :param save_remote: if `True` is provided saves also remote schemas.
+        """
+        import pathlib
+        from urllib.parse import urlsplit
+
+        target_path = pathlib.Path(target)
+        if target_path.is_dir():
+            if list(target_path.iterdir()):
+                raise XMLSchemaValueError("target directory {!r} is not empty".format(target))
+        elif target_path.exists():
+            msg = "target {} is not a directory"
+            raise XMLSchemaValueError(msg.format(target_path.parent))
+        elif not target_path.parent.exists():
+            msg = "target parent directory {} does not exist"
+            raise XMLSchemaValueError(msg.format(target_path.parent))
+        elif not target_path.parent.is_dir():
+            msg = "target parent {} is not a directory"
+            raise XMLSchemaValueError(msg.format(target_path.parent))
+
+        url = self.url or 'schema.xsd'
+        basename = pathlib.Path(urlsplit(url).path).name
+        exports: Any = {self: target_path.joinpath(basename), self.get_text()}
+        path: Any
+
+        while True:
+            current_length = len(exports)
+
+            for schema in list(exports):
+                dir_path = exportsschema0.parent
+                imports_items = (x.url, x) for x in schema.imports.values() if x is not None
+
+                for location, ref_schema in chain(schema.includes.items(), imports_items):
+                    if ref_schema in exports:
+                        continue
+
+                    if is_remote_url(location):
+                        if not save_remote:
+                            continue
+                        url_parts = urlsplit(location)
+                        netloc, path = url_parts.netloc, url_parts.path
+                        path = pathlib.Path().joinpath(netloc).joinpath(path.lstrip('/'))
+                    else:
+                        if location.startswith('file:/'):
+                            location = urlsplit(location).path
+
+                        path = pathlib.Path(location)
+                        if path.is_absolute():
+                            location = '/'.join(path.parts-2:)
+                            try:
+                                schema_path = pathlib.Path(schema.filepath)
+                            except TypeError:
+                                pass
+                            else:
+                                try:
+                                    path = path.relative_to(schema_path.parent)
+                                except ValueError:
+                                    parts = path.parts
+                                    if parts:-2 == schema_path.parts:-2:
+                                        path = pathlib.Path(location)
+                                else:
+                                    path = dir_path.joinpath(path)
+                                    exportsref_schema = path, ref_schema.get_text()
+                                    continue
+
+                        elif not str(path).startswith('..'):
+                            path = dir_path.joinpath(path)
+                            exportsref_schema = path, ref_schema.get_text()
+                            continue
+
+                        if DRIVE_PATTERN.match(path.parts0):
+                            path = pathlib.Path().joinpath(path.parts1:)
+
+                        for strip_path in ('/', '\\', '..'):
+                            while True:
+                                try:
+                                    path = path.relative_to(strip_path)
+                                except ValueError:
+                                    break
+
+                    path = target_path.joinpath(path)
+                    repl = 'schemaLocation="{}"'.format(path.as_posix())
+                    schema_text = exportsschema1
+                    pattern = r'\bschemaLocation\s*=\s*\'\".*%s.*\'"' % re.escape(location)
+                    exportsschema1 = re.sub(pattern, repl, schema_text)
+                    exportsref_schema = path, ref_schema.get_text()
+
+            if current_length == len(exports):
+                break
+
+        for schema, (path, text) in exports.items():
+            if not path.parent.exists():
+                path.parent.mkdir(parents=True)
+
+            with path.open(mode='w') as fp:
+                fp.write(text)
+
+    def version_check(self, elem: ElementType) -> bool:
+        """
+        Checks if the element is compatible with the version of the validator and XSD
+        types/facets availability. Invalid vc attributes are not detected in XSD 1.0.
+
+        :param elem: an Element of the schema.
+        :return: `True` if the schema element is compatible with the validator, \
+        `False` otherwise.
+        """
+        if VC_MIN_VERSION in elem.attrib:
+            vc_min_version = elem.attribVC_MIN_VERSION
+            if not XSD_VERSION_PATTERN.match(vc_min_version):
+                if self.XSD_VERSION > '1.0':
+                    self.parse_error("invalid attribute vc:minVersion value", elem)
+            elif vc_min_version > self.XSD_VERSION:
+                return False
+
+        if VC_MAX_VERSION in elem.attrib:
+            vc_max_version = elem.attribVC_MAX_VERSION
+            if not XSD_VERSION_PATTERN.match(vc_max_version):
+                if self.XSD_VERSION > '1.0':
+                    self.parse_error("invalid attribute vc:maxVersion value", elem)
+            elif vc_max_version <= self.XSD_VERSION:
+                return False
+
+        if VC_TYPE_AVAILABLE in elem.attrib:
+            for qname in elem.attribVC_TYPE_AVAILABLE.split():
+                try:
+                    if self.resolve_qname(qname) not in self.maps.types:
+                        return False
+                except XMLSchemaNamespaceError:
+                    return False
+                except (KeyError, ValueError) as err:
+                    self.parse_error(str(err), elem)
+
+        if VC_TYPE_UNAVAILABLE in elem.attrib:
+            for qname in elem.attribVC_TYPE_UNAVAILABLE.split():
+                try:
+                    if self.resolve_qname(qname) not in self.maps.types:
+                        break
+                except XMLSchemaNamespaceError:
+                    break
+                except (KeyError, ValueError) as err:
+                    self.parse_error(err, elem)
+            else:
+                return False
+
+        if VC_FACET_AVAILABLE in elem.attrib:
+            for qname in elem.attribVC_FACET_AVAILABLE.split():
+                try:
+                    facet_name = self.resolve_qname(qname)
+                except XMLSchemaNamespaceError:
+                    pass
+                except (KeyError, ValueError) as err:
+                    self.parse_error(str(err), elem)
+                else:
+                    if self.XSD_VERSION == '1.0':
+                        if facet_name not in XSD_10_FACETS:
+                            return False
+                    elif facet_name not in XSD_11_FACETS:
+                        return False
+
+        if VC_FACET_UNAVAILABLE in elem.attrib:
+            for qname in elem.attribVC_FACET_UNAVAILABLE.split():
+                try:
+                    facet_name = self.resolve_qname(qname)
+                except XMLSchemaNamespaceError:
+                    break
+                except (KeyError, ValueError) as err:
+                    self.parse_error(err, elem)
+                else:
+                    if self.XSD_VERSION == '1.0':
+                        if facet_name not in XSD_10_FACETS:
+                            break
+                    elif facet_name not in XSD_11_FACETS:
+                        break
+            else:
+                return False
+
+        return True
+
+    def resolve_qname(self, qname: str, namespace_imported: bool = True) -> str:
+        """
+        QName resolution for a schema instance.
+
+        :param qname: a string in xs:QName format.
+        :param namespace_imported: if this argument is `True` raises an \
+        `XMLSchemaNamespaceError` if the namespace of the QName is not the \
+        *targetNamespace* and the namespace is not imported by the schema.
+        :returns: an expanded QName in the format "{*namespace-URI*}*local-name*".
+        :raises: `XMLSchemaValueError` for an invalid xs:QName is found, \
+        `XMLSchemaKeyError` if the namespace prefix is not declared in the \
+        schema instance.
+        """
+        qname = qname.strip()
+        if not qname or ' ' in qname or '\t' in qname or '\n' in qname:
+            raise XMLSchemaValueError("{!r} is not a valid value for xs:QName".format(qname))
+
+        if qname0 == '{':
+            try:
+                namespace, local_name = qname1:.split('}')
+            except ValueError:
+                raise XMLSchemaValueError("{!r} is not a valid value for xs:QName".format(qname))
+        elif ':' in qname:
+            try:
+                prefix, local_name = qname.split(':')
+            except ValueError:
+                raise XMLSchemaValueError("{!r} is not a valid value for xs:QName".format(qname))
+            else:
+                try:
+                    namespace = self.namespacesprefix
+                except KeyError:
+                    raise XMLSchemaKeyError("prefix %r not found in namespace map" % prefix)
+        else:
+            namespace, local_name = self.namespaces.get('', ''), qname
+
+        if not namespace:
+            if namespace_imported and self.target_namespace and '' not in self.imports:
+                raise XMLSchemaNamespaceError(
+                    "the QName {!r} is mapped to no namespace, but this requires "
+                    "that there is an xs:import statement in the schema without "
+                    "the 'namespace' attribute.".format(qname)
+                )
+            return local_name
+        elif namespace_imported and self.meta_schema is not None and \
+                namespace != self.target_namespace and \
+                namespace not in {XSD_NAMESPACE, XSI_NAMESPACE} and \
+                namespace not in self.imports:
+            raise XMLSchemaNamespaceError(
+                "the QName {!r} is mapped to the namespace {!r}, but this namespace has "
+                "not an xs:import statement in the schema.".format(qname, namespace)
+            )
+        return '{%s}%s' % (namespace, local_name)
+
+    def validate(self, source: UnionXMLSourceType, XMLResource,
+                 path: Optionalstr = None,
+                 schema_path: Optionalstr = None,
+                 use_defaults: bool = True,
+                 namespaces: OptionalNamespacesType = None,
+                 max_depth: Optionalint = None,
+                 extra_validator: OptionalExtraValidatorType = None) -> None:
+        """
+        Validates an XML data against the XSD schema/component instance.
+
+        :param source: the source of XML data. Can be an :class:`XMLResource` instance, a \
+        path to a file or an URI of a resource or an opened file-like object or an Element \
+        instance or an ElementTree instance or a string containing the XML data.
+        :param path: is an optional XPath expression that matches the elements of the XML \
+        data that have to be decoded. If not provided the XML root element is selected.
+        :param schema_path: an alternative XPath expression to select the XSD element \
+        to use for decoding. Useful if the root of the XML data doesn't match an XSD \
+        global element of the schema.
+        :param use_defaults: Use schema's default values for filling missing data.
+        :param namespaces: is an optional mapping from namespace prefix to URI.
+        :param max_depth: maximum level of validation, for default there is no limit. \
+        With lazy resources is set to `source.lazy_depth` for managing lazy validation.
+        :param extra_validator: an optional function for performing non-standard \
+        validations on XML data. The provided function is called for each traversed \
+        element, with the XML element as 1st argument and the corresponding XSD \
+        element as 2nd argument. It can be also a generator function and has to \
+        raise/yield :exc:`XMLSchemaValidationError` exceptions.
+        :raises: :exc:`XMLSchemaValidationError` if the XML data instance is invalid.
+        """
+        for error in self.iter_errors(source, path, schema_path, use_defaults,
+                                      namespaces, max_depth, extra_validator):
+            raise error
+
+    def is_valid(self, source: UnionXMLSourceType, XMLResource,
+                 path: Optionalstr = None,
+                 schema_path: Optionalstr = None,
+                 use_defaults: bool = True,
+                 namespaces: OptionalNamespacesType = None,
+                 max_depth: Optionalint = None,
+                 extra_validator: OptionalExtraValidatorType = None) -> bool:
+        """
+        Like :meth:`validate` except that does not raise an exception but returns
+        ``True`` if the XML data instance is valid, ``False`` if it is invalid.
+        """
+        error = next(self.iter_errors(source, path, schema_path, use_defaults,
+                                      namespaces, max_depth, extra_validator), None)
+        return error is None
+
+    def iter_errors(self, source: UnionXMLSourceType, XMLResource,
+                    path: Optionalstr = None,
+                    schema_path: Optionalstr = None,
+                    use_defaults: bool = True,
+                    namespaces: OptionalNamespacesType = None,
+                    max_depth: Optionalint = None,
+                    extra_validator: OptionalExtraValidatorType = None) \
+            -> IteratorXMLSchemaValidationError:
+        """
+        Creates an iterator for the errors generated by the validation of an XML data against
+        the XSD schema/component instance. Accepts the same arguments of :meth:`validate`.
+        """
+        self.check_validator(validation='lax')
+        if isinstance(source, XMLResource):
+            resource: XMLResource = source
+        else:
+            resource = XMLResource(source, defuse=self.defuse, timeout=self.timeout)
+
+        if not schema_path:
+            schema_path = resource.get_absolute_path(path)
+
+        namespaces = resource.get_namespaces(namespaces, root_only=True)
+        namespace = resource.namespace or namespaces.get('', '')
+
+        try:
+            schema = self.get_schema(namespace)
+        except KeyError:
+            schema = self
+
+        identities: DictXsdIdentity, IdentityCounter = {}
+        locations: ListAny = 
+        ancestors: ListElementType = 
+        prev_ancestors: ListElementType = 
+        kwargs: DictAny, Any = {
+            'level': resource.lazy_depth or bool(path),
+            'source': resource,
+            'namespaces': namespaces,
+            'converter': None,
+            'use_defaults': use_defaults,
+            'id_map': Counterstr(),
+            'identities': identities,
+            'inherited': {},
+            'locations': locations,  # TODO: lazy schemas load
+        }
+        if max_depth is not None:
+            kwargs'max_depth' = max_depth
+        if extra_validator is not None:
+            kwargs'extra_validator' = extra_validator
+
+        if path:
+            selector = resource.iterfind(path, namespaces, nsmap=namespaces, ancestors=ancestors)
+        else:
+            selector = resource.iter_depth(mode=3, nsmap=namespaces, ancestors=ancestors)
+
+        for elem in selector:
+            if elem is resource.root:
+                xsd_element = schema.get_element(elem.tag, namespaces=namespaces)
+                if resource.lazy_depth:
+                    kwargs'level' = 0
+                    kwargs'identities' = {}
+                    kwargs'max_depth' = resource.lazy_depth
+            else:
+                if prev_ancestors != ancestors:
+                    k = 0
+                    for k in range(min(len(ancestors), len(prev_ancestors))):
+                        if ancestorsk is not prev_ancestorsk:
+                            break
+
+                    path_ = '/'.join(e.tag for e in ancestors) + '/ancestor-or-self::node()'
+                    xsd_ancestors = cast(ListXsdElement, schema.findall(path_, namespaces)1:)
+
+                    for e in xsd_ancestorsk::
+                        e.stop_identities(identities)
+
+                    for e in xsd_ancestorsk::
+                        e.start_identities(identities)
+
+                    prev_ancestors = ancestors:
+
+                xsd_element = schema.get_element(elem.tag, schema_path, namespaces)
+
+            if xsd_element is None:
+                if XSI_TYPE in elem.attrib:
+                    xsd_element = self.create_element(name=elem.tag)
+                elif elem is not resource.root and ancestors:
+                    continue
+                else:
+                    reason = "{!r} is not an element of the schema".format(elem)
+                    yield schema.validation_error('lax', reason, elem, resource, namespaces)
+                    return
+
+            for result in xsd_element.iter_decode(elem, **kwargs):
+                if isinstance(result, XMLSchemaValidationError):
+                    yield result
+                else:
+                    del result
+
+        if kwargs'identities' is not identities:
+            identity: XsdIdentity
+            counter: IdentityCounter
+            for identity, counter in kwargs'identities'.items():
+                identitiesidentity.counter.update(counter.counter)
+            kwargs'identities' = identities
+
+        yield from self._validate_references(validation='lax', **kwargs)
+
+    def _validate_references(self, source: XMLResource,
+                             validation: str = 'lax',
+                             id_map: OptionalCounterstr = None,
+                             identities: OptionalIdentityMapType = None,
+                             **kwargs: Any) -> IteratorXMLSchemaValidationError:
+        # Check unresolved IDREF values
+        if id_map is not None:
+            for k, v in id_map.items():
+                if v == 0:
+                    msg = "IDREF %r not found in XML document" % k
+                    yield self.validation_error(validation, msg, source.root)
+
+        # Check still enabled key references (lazy validation cases)
+        if identities is not None:
+            for constraint, counter in identities.items():
+                if counter.enabled and isinstance(constraint, XsdKeyref):
+                    for error in cast(KeyrefCounter, counter).iter_errors(identities):
+                        yield self.validation_error(validation, error, source.root, **kwargs)
+
+    def raw_decoder(self, source: XMLResource, path: Optionalstr = None,
+                    schema_path: Optionalstr = None, validation: str = 'lax',
+                    namespaces: OptionalNamespacesType = None, **kwargs: Any) \
+            -> IteratorUnionAny, XMLSchemaValidationError:
+        """Returns a generator for decoding a resource."""
+        if path:
+            selector = source.iterfind(path, namespaces, nsmap=namespaces)
+        else:
+            selector = source.iter_depth(nsmap=namespaces)
+
+        for elem in selector:
+            xsd_element = self.get_element(elem.tag, schema_path, namespaces)
+            if xsd_element is None:
+                if XSI_TYPE in elem.attrib:
+                    xsd_element = self.create_element(name=elem.tag)
+                else:
+                    reason = "{!r} is not an element of the schema".format(elem)
+                    yield self.validation_error(validation, reason, elem, source, namespaces)
+                    continue
+
+            yield from xsd_element.iter_decode(elem, validation, **kwargs)
+
+        if 'max_depth' not in kwargs:
+            yield from self._validate_references(source, validation=validation, **kwargs)
+
+    def iter_decode(self, source: UnionXMLSourceType, XMLResource,
+                    path: Optionalstr = None,
+                    schema_path: Optionalstr = None,
+                    validation: str = 'lax',
+                    process_namespaces: bool = True,
+                    namespaces: OptionalNamespacesType = None,
+                    use_defaults: bool = True,
+                    decimal_type: OptionalTypeAny = None,
+                    datetime_types: bool = False,
+                    binary_types: bool = False,
+                    converter: OptionalConverterType = None,
+                    filler: OptionalCallableUnionXsdElement, XsdAttribute, Any = None,
+                    fill_missing: bool = False,
+                    keep_unknown: bool = False,
+                    process_skipped: bool = False,
+                    max_depth: Optionalint = None,
+                    depth_filler: OptionalCallableXsdElement, Any = None,
+                    value_hook: OptionalCallableAtomicValueType, BaseXsdType, Any = None,
+                    **kwargs: Any) -> IteratorUnionAny, XMLSchemaValidationError:
+        """
+        Creates an iterator for decoding an XML source to a data structure.
+
+        :param source: the source of XML data. Can be an :class:`XMLResource` instance, a \
+        path to a file or an URI of a resource or an opened file-like object or an Element \
+        instance or an ElementTree instance or a string containing the XML data.
+        :param path: is an optional XPath expression that matches the elements of the XML \
+        data that have to be decoded. If not provided the XML root element is selected.
+        :param schema_path: an alternative XPath expression to select the XSD element \
+        to use for decoding. Useful if the root of the XML data doesn't match an XSD \
+        global element of the schema.
+        :param validation: defines the XSD validation mode to use for decode, can be \
+        'strict', 'lax' or 'skip'.
+        :param process_namespaces: whether to use namespace information in the \
+        decoding process, using the map provided with the argument *namespaces* \
+        and the map extracted from the XML document.
+        :param namespaces: is an optional mapping from namespace prefix to URI.
+        :param use_defaults: whether to use default values for filling missing data.
+        :param decimal_type: conversion type for `Decimal` objects (generated by \
+        `xs:decimal` built-in and derived types), useful if you want to generate a \
+        JSON-compatible data structure.
+        :param datetime_types: if set to `True` the datetime and duration XSD types \
+        are kept decoded, otherwise their origin XML string is returned.
+        :param binary_types: if set to `True` xs:hexBinary and xs:base64Binary types \
+        are kept decoded, otherwise their origin XML string is returned.
+        :param converter: an :class:`XMLSchemaConverter` subclass or instance to use \
+        for decoding.
+        :param filler: an optional callback function to fill undecodable data with a \
+        typed value. The callback function must accept one positional argument, that \
+        can be an XSD Element or an attribute declaration. If not provided undecodable \
+        data is replaced by `None`.
+        :param fill_missing: if set to `True` the decoder fills also missing attributes. \
+        The filling value is `None` or a typed value if the *filler* callback is provided.
+        :param keep_unknown: if set to `True` unknown tags are kept and are decoded with \
+        *xs:anyType*. For default unknown tags not decoded by a wildcard are discarded.
+        :param process_skipped: process XML data that match a wildcard with \
+        `processContents='skip'`.
+        :param max_depth: maximum level of decoding, for default there is no limit. \
+        With lazy resources is set to `source.lazy_depth` for managing lazy decoding.
+        :param depth_filler: an optional callback function to replace data over the \
+        *max_depth* level. The callback function must accept one positional argument, that \
+        can be an XSD Element. If not provided deeper data are replaced with `None` values.
+        :param value_hook: an optional function that will be called with any decoded \
+        atomic value and the XSD type used for decoding. The return value will be used \
+        instead of the original value.
+        :param kwargs: keyword arguments with other options for converter and decoder.
+        :return: yields a decoded data object, eventually preceded by a sequence of \
+        validation or decoding errors.
+        """
+        self.check_validator(validation)
+        if isinstance(source, XMLResource):
+            resource: XMLResource = source
+        else:
+            resource = XMLResource(source, defuse=self.defuse, timeout=self.timeout)
+
+        if not schema_path and path:
+            schema_path = resource.get_absolute_path(path)
+
+        if process_namespaces:
+            namespaces = resource.get_namespaces(namespaces, root_only=True)
+            namespace = resource.namespace or namespaces.get('', '')
+        else:
+            namespace = resource.namespace
+
+        schema = self.get_schema(namespace)
+        converter = self.get_converter(converter, namespaces=namespaces, **kwargs)
+        kwargs.update(
+            converter=converter,
+            namespaces=namespaces,
+            source=resource,
+            use_defaults=use_defaults,
+            id_map=Counterstr(),
+            identities={},
+            inherited={},
+        )
+
+        if decimal_type is not None:
+            kwargs'decimal_type' = decimal_type
+        if datetime_types:
+            kwargs'datetime_types' = datetime_types
+        if binary_types:
+            kwargs'binary_types' = binary_types
+        if filler is not None:
+            kwargs'filler' = filler
+        if fill_missing:
+            kwargs'fill_missing' = fill_missing
+        if keep_unknown:
+            kwargs'keep_unknown' = keep_unknown
+        if process_skipped:
+            kwargs'process_skipped' = process_skipped
+        if max_depth is not None:
+            kwargs'max_depth' = max_depth
+        if depth_filler is not None:
+            kwargs'depth_filler' = depth_filler
+        if value_hook is not None:
+            kwargs'value_hook' = value_hook
+
+        if path:
+            selector = resource.iterfind(path, namespaces, nsmap=namespaces)
+        elif not resource.is_lazy():
+            selector = resource.iter_depth(nsmap=namespaces)
+        else:
+            decoder = self.raw_decoder(
+                schema_path=resource.get_absolute_path(),
+                validation=validation,
+                **kwargs
+            )
+            kwargs'depth_filler' = lambda x: decoder
+            kwargs'max_depth' = resource.lazy_depth
+            selector = resource.iter_depth(mode=2, nsmap=namespaces)
+
+        for elem in selector:
+            xsd_element = schema.get_element(elem.tag, schema_path, namespaces)
+            if xsd_element is None:
+                if XSI_TYPE in elem.attrib:
+                    xsd_element = self.create_element(name=elem.tag)
+                else:
+                    reason = "{!r} is not an element of the schema".format(elem)
+                    yield schema.validation_error(validation, reason, elem, resource, namespaces)
+                    return
+
+            yield from xsd_element.iter_decode(elem, validation, **kwargs)
+
+        if 'max_depth' not in kwargs:
+            yield from self._validate_references(validation=validation, **kwargs)
+
+    def decode(self, source: UnionXMLSourceType, XMLResource,
+               path: Optionalstr = None,
+               schema_path: Optionalstr = None,
+               validation: str = 'strict',
+               *args: Any, **kwargs: Any) -> DecodeTypeAny:
+        """
+        Decodes XML data. Takes the same arguments of the method :func:`XMLSchema.iter_decode`.
+        """
+        data, errors = , 
+        for result in self.iter_decode(source, path, schema_path, validation, *args, **kwargs):
+            if not isinstance(result, XMLSchemaValidationError):
+                data.append(result)
+            elif validation == 'lax':
+                errors.append(result)
+            elif validation == 'strict':
+                raise result
+
+        if not data:
+            return (None, errors) if validation == 'lax' else None
+        elif len(data) == 1:
+            return (data0, errors) if validation == 'lax' else data0
+        else:
+            return (data, errors) if validation == 'lax' else data
+
+    to_dict = decode
+
+    def to_objects(self, source: UnionXMLSourceType, XMLResource, with_bindings: bool = False,
+                   **kwargs: Any) -> DecodeType'dataobjects.DataElement':
+        """
+        Decodes XML data to Python data objects.
+
+        :param source: the XML data. Can be a string for an attribute or for a simple \
+        type components or a dictionary for an attribute group or an ElementTree's \
+        Element for other components.
+        :param with_bindings: if `True` is provided the decoding is done using \
+        :class:`DataBindingConverter` that used XML data binding classes. For \
+        default the objects are instances of :class:`DataElement` and uses the \
+        :class:`DataElementConverter`.
+        :param kwargs: other optional keyword arguments for the method \
+        :func:`iter_decode`, except the argument *converter*.
+        """
+        if with_bindings:
+            return self.decode(source, converter=dataobjects.DataBindingConverter, **kwargs)
+        return self.decode(source, converter=dataobjects.DataElementConverter, **kwargs)
+
+    def iter_encode(self, obj: Any, path: Optionalstr = None, validation: str = 'lax',
+                    namespaces: OptionalNamespacesType = None, use_defaults: bool = True,
+                    converter: OptionalConverterType = None, unordered: bool = False,
+                    **kwargs: Any) -> IteratorUnionElementType, XMLSchemaValidationError:
+        """
+        Creates an iterator for encoding a data structure to an ElementTree's Element.
+
+        :param obj: the data that has to be encoded to XML data.
+        :param path: is an optional XPath expression for selecting the element of \
+        the schema that matches the data that has to be encoded. For default the first \
+        global element of the schema is used.
+        :param validation: the XSD validation mode. Can be 'strict', 'lax' or 'skip'.
+        :param namespaces: is an optional mapping from namespace prefix to URI.
+        :param use_defaults: whether to use default values for filling missing data.
+        :param converter: an :class:`XMLSchemaConverter` subclass or instance to use for \
+        the encoding.
+        :param unordered: a flag for explicitly activating unordered encoding mode for \
+        content model data. This mode uses content models for a reordered-by-model \
+        iteration of the child elements.
+        :param kwargs: keyword arguments with other options for encoding and for \
+        building the converter instance.
+        :return: yields an Element instance/s or validation/encoding errors.
+        """
+        self.check_validator(validation)
+        if not self.elements:
+            raise XMLSchemaValueError("encoding needs at least one XSD element declaration!")
+
+        if namespaces is None:
+            namespaces = {}
+        else:
+            namespaces = {k: v for k, v in namespaces.items()}
+
+        converter = self.get_converter(converter, namespaces=namespaces, **kwargs)
+
+        xsd_element = None
+        if path is not None:
+            match = re.search(r'{\w', path)
+            if match:
+                namespace = get_namespace(pathmatch.start():, namespaces)
+                schema = self.get_schema(namespace)
+                xsd_element = schema.find(path, namespaces)
+
+        elif len(self.elements) == 1:
+            xsd_element = list(self.elements.values())0
+        else:
+            root_elements = self.root_elements
+            if len(root_elements) == 1:
+                xsd_element = root_elements0
+            elif isinstance(obj, (converter.dict, dict)) and len(obj) == 1:
+                for key in obj:
+                    match = re.search(r'{\w', key)
+                    if match:
+                        namespace = get_namespace(keymatch.start():, namespaces)
+                        schema = self.get_schema(namespace)
+                        xsd_element = schema.find(key, namespaces)
+
+        if not isinstance(xsd_element, XsdElement):
+            if path is not None:
+                reason = "the path %r doesn't match any element of the schema!" % path
+            else:
+                reason = "unable to select an element for decoding data, " \
+                         "provide a valid 'path' argument."
+            raise XMLSchemaEncodeError(self, obj, self.elements, reason, namespaces=namespaces)
+        else:
+            yield from xsd_element.iter_encode(obj, validation, use_defaults=use_defaults,
+                                               converter=converter, unordered=unordered, **kwargs)
+
+    def encode(self, obj: Any, path: Optionalstr = None, validation: str = 'strict',
+               *args: Any, **kwargs: Any) -> EncodeTypeAny:
+        """
+        Encodes to XML data. Takes the same arguments of the method :func:`XMLSchema.iter_encode`.
+
+        :return: An ElementTree's Element or a list containing a sequence of ElementTree's \
+        elements if the argument *path* matches multiple XML data chunks. If *validation* \
+        argument is 'lax' a 2-items tuple is returned, where the first item is the encoded \
+        object and the second item is a list containing the errors.
+        """
+        data, errors = , 
+        result: UnionElementType, XMLSchemaValidationError
+        for result in self.iter_encode(obj, path, validation, *args, **kwargs):
+            if not isinstance(result, XMLSchemaValidationError):
+                data.append(result)
+            elif validation == 'lax':
+                errors.append(result)
+            elif validation == 'strict':
+                raise result
+
+        if not data:
+            return (None, errors) if validation == 'lax' else None
+        elif len(data) == 1:
+            if errors:
+                resource = XMLResource(data0)
+                for e in errors:
+                    e.source = resource
+
+            return (data0, errors) if validation == 'lax' else data0
+        else:
+            return (data, errors) if validation == 'lax' else data
+
+    to_etree = encode
+
+
+class XMLSchema10(XMLSchemaBase):
+    """
+    XSD 1.0 schema class.
+
+    <schema
+      attributeFormDefault = (qualified | unqualified) : unqualified
+      blockDefault = (#all | List of (extension | restriction | substitution))  : ''
+      elementFormDefault = (qualified | unqualified) : unqualified
+      finalDefault = (#all | List of (extension | restriction | list | union))  : ''
+      id = ID
+      targetNamespace = anyURI
+      version = token
+      xml:lang = language
+      {any attributes with non-schema namespace . . .}>
+      Content: ((include | import | redefine | annotation)*, (((simpleType | complexType | group |
+      attributeGroup) | element | attribute | notation), annotation*)*)
+    </schema>
+    """
+    meta_schema = os.path.join(SCHEMAS_DIR, 'XSD_1.0/XMLSchema.xsd')  # type: ignore
+    BASE_SCHEMAS = {
+        XML_NAMESPACE: os.path.join(SCHEMAS_DIR, 'XML/xml_minimal.xsd'),
+        XSI_NAMESPACE: os.path.join(SCHEMAS_DIR, 'XSI/XMLSchema-instance_minimal.xsd'),
+    }
+
+
+class XMLSchema11(XMLSchemaBase):
+    """
+    XSD 1.1 schema class.
+
+    <schema
+      attributeFormDefault = (qualified | unqualified) : unqualified
+      blockDefault = (#all | List of (extension | restriction | substitution)) : ''
+      defaultAttributes = QName
+      xpathDefaultNamespace = (anyURI | (##defaultNamespace | ##targetNamespace| ##local)) : ##local
+      elementFormDefault = (qualified | unqualified) : unqualified
+      finalDefault = (#all | List of (extension | restriction | list | union))  : ''
+      id = ID
+      targetNamespace = anyURI
+      version = token
+      xml:lang = language
+      {any attributes with non-schema namespace . . .}>
+      Content: ((include | import | redefine | override | annotation)*,
+      (defaultOpenContent, annotation*)?, ((simpleType | complexType |
+      group | attributeGroup | element | attribute | notation), annotation*)*)
+    </schema>
+
+    <schema
+      attributeFormDefault = (qualified | unqualified) : unqualified
+      blockDefault = (#all | List of (extension | restriction | substitution))  : ''
+      elementFormDefault = (qualified | unqualified) : unqualified
+      finalDefault = (#all | List of (extension | restriction | list | union))  : ''
+      id = ID
+      targetNamespace = anyURI
+      version = token
+      xml:lang = language
+      {any attributes with non-schema namespace . . .}>
+      Content: ((include | import | redefine | annotation)*, (((simpleType | complexType | group |
+      attributeGroup) | element | attribute | notation), annotation*)*)
+    </schema>
+    """
+    meta_schema = os.path.join(SCHEMAS_DIR, 'XSD_1.1/XMLSchema.xsd')  # type: ignore
+    XSD_VERSION = '1.1'
+
+    BASE_SCHEMAS = {
+        XML_NAMESPACE: os.path.join(SCHEMAS_DIR, 'XML/xml_minimal.xsd'),
+        XSI_NAMESPACE: os.path.join(SCHEMAS_DIR, 'XSI/XMLSchema-instance_minimal.xsd'),
+        XSD_NAMESPACE: os.path.join(SCHEMAS_DIR, 'XSD_1.1/xsd11-extra.xsd'),
+        VC_NAMESPACE: os.path.join(SCHEMAS_DIR, 'VC/XMLSchema-versioning.xsd'),
+    }
+
+    xsd_complex_type_class = Xsd11ComplexType
+    xsd_attribute_class = Xsd11Attribute
+    xsd_any_attribute_class = Xsd11AnyAttribute
+    xsd_group_class = Xsd11Group
+    xsd_element_class = Xsd11Element
+    xsd_any_class = Xsd11AnyElement
+    xsd_atomic_restriction_class = Xsd11AtomicRestriction
+    xsd_union_class = Xsd11Union
+    xsd_key_class = Xsd11Key
+    xsd_keyref_class = Xsd11Keyref
+    xsd_unique_class = Xsd11Unique
+
+
+XMLSchema = XMLSchema10
+"""The default class for schema instances."""

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/validators/simple_types.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/validators/simple_types.py Changed

@@ -11,9 +11,13 @@
 This module contains classes for XML Schema simple data types.
 """
 from decimal import DecimalException
-from typing import Any
+from typing import cast, Any, Callable, Dict, Iterator, List, \
+    Optional, Set, Union, Tuple, Type
 
 from ..etree import etree_element
+from ..aliases import ElementType, AtomicValueType, ComponentClassType, \
+    IterDecodeType, IterEncodeType, BaseXsdType, SchemaType, DecodedValueType, \
+    EncodedValueType
 from ..exceptions import XMLSchemaTypeError, XMLSchemaValueError
 from ..names import XSD_NAMESPACE, XSD_ANY_TYPE, XSD_SIMPLE_TYPE, XSD_PATTERN, \
     XSD_ANY_ATOMIC_TYPE, XSD_ATTRIBUTE, XSD_ATTRIBUTE_GROUP, XSD_ANY_ATTRIBUTE, \
@@ -22,71 +26,21 @@
     XSD_LIST, XSD_ANY_SIMPLE_TYPE, XSD_UNION, XSD_RESTRICTION, XSD_ANNOTATION, \
     XSD_ASSERTION, XSD_ID, XSD_IDREF, XSD_FRACTION_DIGITS, XSD_TOTAL_DIGITS, \
     XSD_EXPLICIT_TIMEZONE, XSD_ERROR, XSD_ASSERT, XSD_QNAME, XSD_UNTYPED_ATOMIC
-from ..helpers import get_qname, get_prefixed_qname, local_name
+from ..helpers import get_prefixed_qname, local_name
 
 from .exceptions import XMLSchemaValidationError, XMLSchemaEncodeError, \
     XMLSchemaDecodeError, XMLSchemaParseError
-from .helpers import get_xsd_derivation_attribute
-from .xsdbase import XsdAnnotation, XsdType, ValidationMixin
-from .facets import XsdFacet, XsdWhiteSpaceFacet, XSD_10_FACETS_BUILDERS, \
+from .xsdbase import XsdComponent, XsdType, ValidationMixin
+from .facets import XsdFacet, XsdWhiteSpaceFacet, XsdPatternFacets, \
+    XsdEnumerationFacets, XsdAssertionFacet, XSD_10_FACETS_BUILDERS, \
     XSD_11_FACETS_BUILDERS, XSD_10_FACETS, XSD_11_FACETS, XSD_10_LIST_FACETS, \
     XSD_11_LIST_FACETS, XSD_10_UNION_FACETS, XSD_11_UNION_FACETS, MULTIPLE_FACETS
 
+FacetsValueType = UnionXsdFacet, CallableAny, None, ListXsdAssertionFacet
+PythonTypeClasses = TypeAny
 
-def xsd_simple_type_factory(elem, schema, parent):
-    """
-    Factory function for XSD simple types. Parses the xs:simpleType element and its
-    child component, that can be a restriction, a list or an union. Annotations are
-    linked to simple type instance, omitting the inner annotation if both are given.
-    """
-    annotation = None
-    try:
-        child = elem0
-    except IndexError:
-        return schema.maps.typesXSD_ANY_SIMPLE_TYPE
-    else:
-        if child.tag == XSD_ANNOTATION:
-            annotation = XsdAnnotation(elem0, schema, child)
-            try:
-                child = elem1
-            except IndexError:
-                schema.parse_error("(restriction | list | union) expected", elem)
-                return schema.maps.typesXSD_ANY_SIMPLE_TYPE
-
-    if child.tag == XSD_RESTRICTION:
-        xsd_type = schema.BUILDERS.restriction_class(child, schema, parent)
-    elif child.tag == XSD_LIST:
-        xsd_type = XsdList(child, schema, parent)
-    elif child.tag == XSD_UNION:
-        xsd_type = schema.BUILDERS.union_class(child, schema, parent)
-    else:
-        schema.parse_error("(restriction | list | union) expected", elem)
-        return schema.maps.typesXSD_ANY_SIMPLE_TYPE
-
-    if annotation is not None:
-        xsd_type.annotation = annotation
-
-    try:
-        xsd_type.name = get_qname(schema.target_namespace, elem.attrib'name')
-    except KeyError:
-        if parent is None:
-            schema.parse_error("missing attribute 'name' in a global simpleType", elem)
-            xsd_type.name = 'nameless_%s' % str(id(xsd_type))
-    else:
-        if parent is not None:
-            schema.parse_error("attribute 'name' not allowed for a local simpleType", elem)
-            xsd_type.name = None
-
-    if 'final' in elem.attrib:
-        try:
-            xsd_type._final = get_xsd_derivation_attribute(elem, 'final')
-        except ValueError as err:
-            xsd_type.parse_error(err, elem)
-
-    return xsd_type
 
-
-class XsdSimpleType(XsdType, ValidationMixin):
+class XsdSimpleType(XsdType, ValidationMixinUnionstr, bytes, DecodedValueType):
     """
     Base class for simpleTypes definitions. Generally used only for
     instances of xs:anySimpleType.
@@ -101,24 +55,34 @@
     """
     _special_types = {XSD_ANY_TYPE, XSD_ANY_SIMPLE_TYPE}
     _ADMITTED_TAGS = {XSD_SIMPLE_TYPE}
+    copy: Callable'XsdSimpleType', 'XsdSimpleType'
 
-    variety = None
-    min_length = None
-    max_length = None
-    white_space = None
+    block: str = ''
+    min_length: Optionalint = None
+    max_length: Optionalint = None
+    white_space: Optionalstr = None
     patterns = None
-    validators = ()
+    validators: UnionTuple(), ListUnionXsdFacet, CallableAny, None = ()
     allow_empty = True
+    facets: DictOptionalstr, FacetsValueType
+
+    python_type: PythonTypeClasses
+    instance_types: UnionPythonTypeClasses, TuplePythonTypeClasses
 
     # Unicode string as default datatype for XSD simple types
     python_type = instance_types = to_python = from_python = str
 
-    def __init__(self, elem, schema, parent, name=None, facets=None):
+    def __init__(self, elem: ElementType,
+                 schema: SchemaType,
+                 parent: OptionalXsdComponent = None,
+                 name: Optionalstr = None,
+                 facets: OptionalDictOptionalstr, FacetsValueType = None) -> None:
+
         super(XsdSimpleType, self).__init__(elem, schema, parent, name)
         if not hasattr(self, 'facets'):
-            self.facets = facets or {}
+            self.facets = facets if facets is not None else {}
 
-    def __setattr__(self, name, value):
+    def __setattr__(self, name: str, value: Any) -> None:
         super(XsdSimpleType, self).__setattr__(name, value)
         if name == 'facets':
             if not isinstance(self, XsdAtomicBuiltin):
@@ -132,22 +96,25 @@
                 self.white_space = white_space
 
             patterns = self.get_facet(XSD_PATTERN)
-            if patterns is not None:
+            if isinstance(patterns, XsdPatternFacets):
                 self.patterns = patterns
                 if all(p.match('') is None for p in patterns.patterns):
                     self.allow_empty = False
 
             enumeration = self.get_facet(XSD_ENUMERATION)
-            if enumeration is not None and '' not in enumeration:
+            if isinstance(enumeration, XsdEnumerationFacets) \
+                    and '' not in enumeration.enumeration:
                 self.allow_empty = False
 
             if value:
+                validators: ListUnionXsdFacet, CallableAny, None
                 if None in value:
                     validators = valueNone  # Use only the validator function!
                 else:
                     validators = v for k, v in value.items()
                                   if k not in {XSD_WHITE_SPACE, XSD_PATTERN, XSD_ASSERTION}
                 if XSD_ASSERTION in value:
+                    assertions: UnionXsdAssertionFacet, ListXsdAssertionFacet
                     assertions = valueXSD_ASSERTION
                     if isinstance(assertions, list):
                         validators.extend(assertions)
@@ -156,9 +123,11 @@
                 if validators:
                     self.validators = validators
 
-    def _parse_facets(self, facets):
+    def _parse_facets(self, facets: Any) -> None:
+        base_type: Any
+
         if facets and self.base_type is not None:
-            if self.base_type.is_simple():
+            if isinstance(self.base_type, XsdSimpleType):
                 if self.base_type.name == XSD_ANY_SIMPLE_TYPE:
                     self.parse_error(
                         "facets not allowed for a direct derivation of xs:anySimpleType"
@@ -273,73 +242,94 @@
         self.max_length = max_length
 
     @property
-    def simple_type(self):
-        return self
+    def variety(self) -> Optionalstr:
+        return None
 
     @property
-    def model_group(self):
-        return
+    def simple_type(self) -> 'XsdSimpleType':
+        return self
 
     @property
-    def min_value(self):
-        min_exclusive_facet = self.get_facet(XSD_MIN_EXCLUSIVE)
-        if min_exclusive_facet is None:
-            return getattr(self.get_facet(XSD_MIN_INCLUSIVE), 'value', None)
-
-        min_inclusive_facet = self.get_facet(XSD_MIN_INCLUSIVE)
-        if min_inclusive_facet is None or min_inclusive_facet.value <= min_exclusive_facet.value:
-            return min_exclusive_facet.value
+    def min_value(self) -> OptionalAtomicValueType:
+        min_exclusive: Optional'AtomicValueType'
+        min_inclusive: Optional'AtomicValueType'
+        min_exclusive = cast(
+            Optional'AtomicValueType',
+            getattr(self.get_facet(XSD_MIN_EXCLUSIVE), 'value', None)
+        )
+        min_inclusive = cast(
+            Optional'AtomicValueType',
+            getattr(self.get_facet(XSD_MIN_INCLUSIVE), 'value', None)
+        )
+
+        if min_exclusive is None:
+            return min_inclusive
+        elif min_inclusive is None:
+            return min_exclusive
+        elif min_inclusive <= min_exclusive:  # type: ignoreoperator
+            return min_exclusive
         else:
-            return min_inclusive_facet.value
+            return min_inclusive
 
     @property
-    def max_value(self):
-        max_exclusive_facet = self.get_facet(XSD_MAX_EXCLUSIVE)
-        if max_exclusive_facet is None:
-            return getattr(self.get_facet(XSD_MAX_INCLUSIVE), 'value', None)
-
-        max_inclusive_facet = self.get_facet(XSD_MAX_INCLUSIVE)
-        if max_inclusive_facet is None or max_inclusive_facet.value >= max_exclusive_facet.value:
-            return max_exclusive_facet.value
+    def max_value(self) -> OptionalAtomicValueType:
+        max_exclusive: Optional'AtomicValueType'
+        max_inclusive: Optional'AtomicValueType'
+        max_exclusive = cast(
+            Optional'AtomicValueType',
+            getattr(self.get_facet(XSD_MAX_EXCLUSIVE), 'value', None)
+        )
+        max_inclusive = cast(
+            Optional'AtomicValueType',
+            getattr(self.get_facet(XSD_MAX_INCLUSIVE), 'value', None)
+        )
+
+        if max_exclusive is None:
+            return max_inclusive
+        elif max_inclusive is None:
+            return max_exclusive
+        elif max_inclusive >= max_exclusive:  # type: ignoreoperator
+            return max_exclusive
         else:
-            return max_inclusive_facet.value
+            return max_inclusive
 
     @property
-    def enumeration(self):
+    def enumeration(self) -> OptionalListOptionalAtomicValueType:
         enumeration = self.get_facet(XSD_ENUMERATION)
-        if enumeration is not None:
+        if isinstance(enumeration, XsdEnumerationFacets):
             return enumeration.enumeration
+        return None
 
     @property
-    def admitted_facets(self):
+    def admitted_facets(self) -> Setstr:
         return XSD_10_FACETS if self.xsd_version == '1.0' else XSD_11_FACETS
 
     @property
-    def built(self):
+    def built(self) -> bool:
         return True
 
     @staticmethod
-    def is_simple():
+    def is_simple() -> bool:
         return True
 
     @staticmethod
-    def is_complex():
+    def is_complex() -> bool:
         return False
 
     @property
-    def content_type_label(self):
+    def content_type_label(self) -> str:
         return 'empty' if self.max_length == 0 else 'simple'
 
     @property
-    def sequence_type(self):
+    def sequence_type(self) -> str:
         if self.is_empty():
             return 'empty-sequence()'
 
         root_type = self.root_type
-        if root_type.name is None:
-            sequence_type = get_prefixed_qname(XSD_UNTYPED_ATOMIC, self.namespaces)
+        if root_type.name is not None:
+            sequence_type = cast(str, root_type.prefixed_name)
         else:
-            sequence_type = root_type.prefixed_name
+            sequence_type = get_prefixed_qname(XSD_UNTYPED_ATOMIC, self.namespaces)
 
         if not self.is_list():
             return sequence_type
@@ -348,28 +338,32 @@
         else:
             return '{}+'.format(sequence_type)
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         return self.max_length == 0 or \
             self.enumeration is not None and all(v == '' for v in self.enumeration)
 
-    def is_emptiable(self):
+    def is_emptiable(self) -> bool:
         return self.allow_empty
 
-    def has_simple_content(self):
+    def has_simple_content(self) -> bool:
         return self.max_length != 0
 
-    def has_complex_content(self):
+    def has_complex_content(self) -> bool:
         return False
 
-    def has_mixed_content(self):
+    def has_mixed_content(self) -> bool:
         return False
 
-    def is_element_only(self):
+    def is_element_only(self) -> bool:
         return False
 
-    def is_derived(self, other, derivation=None):
+    def is_derived(self, other: UnionBaseXsdType, TupleElementType, SchemaType,
+                   derivation: Optionalstr = None) -> bool:
         if self is other:
             return True
+        elif isinstance(other, tuple):
+            other1.parse_error(f"global type {other0.tag!r} is not built")
+            return False
         elif derivation and self.derivation and derivation != self.derivation:
             return False
         elif other.name in self._special_types:
@@ -377,23 +371,23 @@
         elif self.base_type is other:
             return True
         elif self.base_type is None:
-            if hasattr(other, 'member_types'):
+            if isinstance(other, XsdUnion):
                 return any(self.is_derived(m, derivation) for m in other.member_types)
             return False
         elif self.base_type.is_complex():
             if not self.base_type.has_simple_content():
                 return False
-            return self.base_type.content.is_derived(other, derivation)
-        elif hasattr(other, 'member_types'):
+            return self.base_type.content.is_derived(other, derivation)  # type: ignore
+        elif isinstance(other, XsdUnion):
             return any(self.is_derived(m, derivation) for m in other.member_types)
         else:
             return self.base_type.is_derived(other, derivation)
 
-    def is_dynamic_consistent(self, other):
+    def is_dynamic_consistent(self, other: BaseXsdType) -> bool:
         return other.name in {XSD_ANY_TYPE, XSD_ANY_SIMPLE_TYPE} or self.is_derived(other) or \
-            hasattr(other, 'member_types') and any(self.is_derived(mt) for mt in other.member_types)
+            isinstance(other, XsdUnion) and any(self.is_derived(mt) for mt in other.member_types)
 
-    def normalize(self, text):
+    def normalize(self, text: Unionstr, bytes) -> str:
         """
         Normalize and restrict value-space with pre-lexical and lexical facets.
 
@@ -412,51 +406,51 @@
         else:
             return text
 
-    def text_decode(self, text):
-        return self.decode(text, validation='skip')
-
-    def iter_decode(self, obj, validation='lax', **kwargs):
-        if isinstance(obj, (str, bytes)):
-            obj = self.normalize(obj)
+    def text_decode(self, text: str) -> AtomicValueType:
+        return cast(AtomicValueType, self.decode(text, validation='skip'))
 
-        if obj is not None:
+    def iter_decode(self, obj: Unionstr, bytes, validation: str = 'lax',
+                    **kwargs: Any) -> IterDecodeTypeDecodedValueType:
+        if obj is None:
+            yield obj
+        else:
+            text = self.normalize(obj)
             if self.patterns is not None:
                 try:
-                    self.patterns(obj)
+                    self.patterns(text)
                 except XMLSchemaValidationError as err:
                     yield err
 
             for validator in self.validators:
                 try:
-                    validator(obj)
+                    validator(text)
                 except XMLSchemaValidationError as err:
                     yield err
 
-        yield obj
+            yield text
 
-    def iter_encode(self, obj, validation='lax', **kwargs):
-        if isinstance(obj, (str, bytes)):
-            obj = self.normalize(obj)
-        else:
+    def iter_encode(self, obj: Any, validation: str = 'lax', **kwargs: Any) \
+            -> IterEncodeTypeEncodedValueType:
+        if not isinstance(obj, (str, bytes)):
             reason = "a {!r} or {!r} object required".format(str, bytes)
             yield XMLSchemaEncodeError(self, obj, str, reason)
-
-        if obj is not None:
+        else:
+            text = self.normalize(obj)
             if self.patterns is not None:
                 try:
-                    self.patterns(obj)
+                    self.patterns(text)
                 except XMLSchemaValidationError as err:
                     yield err
 
             for validator in self.validators:
                 try:
-                    validator(obj)
+                    validator(text)
                 except XMLSchemaValidationError as err:
                     yield err
 
-        yield obj
+            yield text
 
-    def get_facet(self, tag):
+    def get_facet(self, tag: str) -> OptionalFacetsValueType:
         return self.facets.get(tag)
 
 
@@ -468,19 +462,23 @@
     a base_type attribute that refers to primitive or derived atomic
     built-in type or another derived simpleType.
     """
-    variety = 'atomic'
-
     _special_types = {XSD_ANY_TYPE, XSD_ANY_SIMPLE_TYPE, XSD_ANY_ATOMIC_TYPE}
     _ADMITTED_TAGS = {XSD_RESTRICTION, XSD_SIMPLE_TYPE}
 
-    def __init__(self, elem, schema, parent, name=None, facets=None, base_type=None):
+    def __init__(self, elem: ElementType,
+                 schema: SchemaType,
+                 parent: OptionalXsdComponent = None,
+                 name: Optionalstr = None,
+                 facets: OptionalDictOptionalstr, FacetsValueType = None,
+                 base_type: OptionalBaseXsdType = None) -> None:
+
         if base_type is None:
             self.primitive_type = self
         else:
             self.base_type = base_type
         super(XsdAtomic, self).__init__(elem, schema, parent, name, facets)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         if self.name is None:
             return '%s(primitive_type=%r)' % (
                 self.__class__.__name__, self.primitive_type.local_name
@@ -488,42 +486,45 @@
         else:
             return '%s(name=%r)' % (self.__class__.__name__, self.prefixed_name)
 
-    def __setattr__(self, name: str, value: XsdType):
+    def __setattr__(self, name: str, value: Any) -> None:
         super(XsdAtomic, self).__setattr__(name, value)
         if name == 'base_type':
             if not hasattr(self, 'white_space'):
                 try:
-                    self.white_space = self.base_type.white_space
+                    self.white_space = value.white_space
                 except AttributeError:
                     pass
             try:
                 if value.is_simple():
-                    self.primitive_type = self.base_type.primitive_type
+                    self.primitive_type = value.primitive_type
                 else:
-                    self.primitive_type = self.base_type.content.primitive_type
+                    self.primitive_type = value.content.primitive_type
             except AttributeError:
                 self.primitive_type = value
 
     @property
-    def admitted_facets(self):
+    def variety(self) -> Optionalstr:
+        return 'atomic'
+
+    @property
+    def admitted_facets(self) -> Setstr:
         if self.primitive_type.is_complex():
             return XSD_10_FACETS if self.xsd_version == '1.0' else XSD_11_FACETS
         return self.primitive_type.admitted_facets
 
-    def is_datetime(self):
+    def is_datetime(self) -> bool:
         return self.primitive_type.to_python.__name__ == 'fromstring'
 
-    def get_facet(self, tag):
-        try:
-            return self.facetstag
-        except KeyError:
-            try:
-                return self.base_type.get_facet(tag)
-            except AttributeError:
-                return
+    def get_facet(self, tag: str) -> OptionalFacetsValueType:
+        facet = self.facets.get(tag)
+        if facet is not None:
+            return facet
+        elif self.base_type is not None:
+            return self.base_type.get_facet(tag)
+        else:
+            return None
 
-    @staticmethod
-    def is_atomic():
+    def is_atomic(self) -> bool:
         return True
 
 
@@ -538,11 +539,18 @@
       - to_python(value): Decoding from XML
       - from_python(value): Encoding to XML
     """
-    def __init__(self, elem, schema, name, python_type, base_type=None, admitted_facets=None,
-                 facets=None, to_python=None, from_python=None):
+    def __init__(self, elem: ElementType,
+                 schema: SchemaType,
+                 name: str,
+                 python_type: TypeAny,
+                 base_type: Optional'XsdAtomicBuiltin' = None,
+                 admitted_facets: OptionalSetstr = None,
+                 facets: OptionalDictOptionalstr, FacetsValueType = None,
+                 to_python: Any = None,
+                 from_python: Any = None) -> None:
         """
         :param name: the XSD type's qualified name.
-        :param python_type: the correspondent Python's type. If a tuple or list of types \
+        :param python_type: the correspondent Python's type. If a tuple of types \
         is provided uses the first and consider the others as compatible types.
         :param base_type: the reference base type, None if it's a primitive type.
         :param admitted_facets: admitted facets tags for type (required for primitive types).
@@ -550,7 +558,7 @@
         :param to_python: optional decode function.
         :param from_python: optional encode function.
         """
-        if isinstance(python_type, (tuple, list)):
+        if isinstance(python_type, tuple):
             self.instance_types, python_type = python_type, python_type0
         else:
             self.instance_types = python_type
@@ -564,20 +572,18 @@
 
         super(XsdAtomicBuiltin, self).__init__(elem, schema, None, name, facets, base_type)
         self.python_type = python_type
-        self.to_python = to_python or python_type
-        self.from_python = from_python or str
+        self.to_python = to_python if to_python is not None else python_type
+        self.from_python = from_python if from_python is not None else str
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return '%s(name=%r)' % (self.__class__.__name__, self.prefixed_name)
 
-    def _parse(self):
-        pass
-
     @property
-    def admitted_facets(self):
+    def admitted_facets(self) -> Setstr:
         return self._admitted_facets or self.primitive_type.admitted_facets
 
-    def iter_decode(self, obj, validation='lax', **kwargs):
+    def iter_decode(self, obj: Unionstr, bytes, validation: str = 'lax', **kwargs: Any) \
+            -> IterDecodeTypeDecodedValueType:
         if isinstance(obj, (str, bytes)):
             obj = self.normalize(obj)
         elif obj is not None and not isinstance(obj, self.instance_types):
@@ -681,7 +687,8 @@
 
         yield result
 
-    def iter_encode(self, obj, validation='lax', **kwargs):
+    def iter_encode(self, obj: Any, validation: str = 'lax', **kwargs: Any) \
+            -> IterEncodeTypeEncodedValueType:
         if isinstance(obj, (str, bytes)):
             obj = self.normalize(obj)
 
@@ -693,7 +700,7 @@
             return
 
         elif isinstance(obj, bool):
-            types_ = self.instance_types
+            types_: Any = self.instance_types
             if types_ is not bool or (isinstance(types_, tuple) and bool in types_):
                 reason = "boolean value {!r} requires a {!r} decoder".format(obj, bool)
                 yield XMLSchemaEncodeError(self, obj, self.from_python, reason)
@@ -754,24 +761,28 @@
           Content: (annotation?, simpleType?)
         </list>
     """
-    variety = 'list'
-
+    base_type: XsdSimpleType
     _ADMITTED_TAGS = {XSD_LIST}
     _white_space_elem = etree_element(
         XSD_WHITE_SPACE, attrib={'value': 'collapse', 'fixed': 'true'}
     )
 
-    def __init__(self, elem, schema, parent, name=None):
-        facets = {XSD_WHITE_SPACE: XsdWhiteSpaceFacet(self._white_space_elem, schema, self, self)}
+    def __init__(self, elem: ElementType,
+                 schema: SchemaType,
+                 parent: OptionalXsdComponent,
+                 name: Optionalstr = None) -> None:
+        facets: OptionalDictOptionalstr, FacetsValueType = {
+            XSD_WHITE_SPACE: XsdWhiteSpaceFacet(self._white_space_elem, schema, self, self)
+        }
         super(XsdList, self).__init__(elem, schema, parent, name, facets)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         if self.name is None:
             return '%s(item_type=%r)' % (self.__class__.__name__, self.base_type)
         else:
             return '%s(name=%r)' % (self.__class__.__name__, self.prefixed_name)
 
-    def __setattr__(self, name, value):
+    def __setattr__(self, name: str, value: Any) -> None:
         if name == 'elem' and value is not None and value.tag != XSD_LIST:
             if value.tag == XSD_SIMPLE_TYPE:
                 for child in value:
@@ -786,14 +797,14 @@
             value = 'collapse'
         super(XsdList, self).__setattr__(name, value)
 
-    def _parse(self):
-        super(XsdList, self)._parse()
+    def _parse(self) -> None:
+        base_type: Any
 
         child = self._parse_child_component(self.elem)
         if child is not None:
             # Case of a local simpleType declaration inside the list tag
             try:
-                base_type = xsd_simple_type_factory(child, self.schema, self)
+                base_type = self.schema.simple_type_factory(child, parent=self)
             except XMLSchemaParseError as err:
                 self.parse_error(err)
                 base_type = self.any_atomic_type
@@ -842,24 +853,30 @@
                 self.allow_empty = False
 
     @property
-    def admitted_facets(self):
+    def variety(self) -> Optionalstr:
+        return 'list'
+
+    @property
+    def admitted_facets(self) -> Setstr:
         return XSD_10_LIST_FACETS if self.xsd_version == '1.0' else XSD_11_LIST_FACETS
 
     @property
-    def item_type(self):
+    def item_type(self) -> BaseXsdType:
         return self.base_type
 
-    @staticmethod
-    def is_atomic():
+    def is_atomic(self) -> bool:
         return False
 
-    @staticmethod
-    def is_list():
+    def is_list(self) -> bool:
         return True
 
-    def is_derived(self, other, derivation=None):
+    def is_derived(self, other: UnionBaseXsdType, TupleElementType, SchemaType,
+                   derivation: Optionalstr = None) -> bool:
         if self is other:
             return True
+        elif isinstance(other, tuple):
+            other1.parse_error(f"global type {other0.tag!r} is not built")
+            return False
         elif derivation and self.derivation and derivation != self.derivation:
             return False
         elif other.name in self._special_types:
@@ -869,31 +886,32 @@
         else:
             return False
 
-    def iter_components(self, xsd_classes=None):
+    def iter_components(self, xsd_classes: ComponentClassType = None) \
+            -> IteratorXsdComponent:
         if xsd_classes is None or isinstance(self, xsd_classes):
             yield self
         if self.base_type.parent is not None:
             yield from self.base_type.iter_components(xsd_classes)
 
-    def iter_decode(self, obj, validation='lax', **kwargs):
-        if isinstance(obj, (str, bytes)):
-            obj = self.normalize(obj)
-
+    def iter_decode(self, obj: Unionstr, bytes,  # type: ignoreoverride
+                    validation: str = 'lax', **kwargs: Any) \
+            -> IterDecodeTypeListDecodedValueType:
         items = 
-        for chunk in obj.split():
+        for chunk in self.normalize(obj).split():
             for result in self.base_type.iter_decode(chunk, validation, **kwargs):
                 if isinstance(result, XMLSchemaValidationError):
                     yield result
                 else:
                     items.append(result)
+        else:
+            yield items
 
-        yield items
-
-    def iter_encode(self, obj, validation='lax', **kwargs):
+    def iter_encode(self, obj: Any, validation: str = 'lax', **kwargs: Any) \
+            -> IterEncodeTypeEncodedValueType:
         if not hasattr(obj, '__iter__') or isinstance(obj, (str, bytes)):
             obj = obj
 
-        encoded_items = 
+        encoded_items: ListAny = 
         for item in obj:
             for result in self.base_type.iter_encode(item, validation, **kwargs):
                 if isinstance(result, XMLSchemaValidationError):
@@ -916,22 +934,23 @@
           Content: (annotation?, simpleType*)
         </union>
     """
-    variety = 'union'
-
-    member_types = None
-    _ADMITTED_TYPES = XsdSimpleType
+    member_types: Any = ()
+    _ADMITTED_TYPES: Any = XsdSimpleType
     _ADMITTED_TAGS = {XSD_UNION}
 
-    def __init__(self, elem, schema, parent, name=None):
+    def __init__(self, elem: ElementType,
+                 schema: SchemaType,
+                 parent: OptionalXsdComponent,
+                 name: Optionalstr = None) -> None:
         super(XsdUnion, self).__init__(elem, schema, parent, name, facets=None)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         if self.name is None:
             return '%s(member_types=%r)' % (self.__class__.__name__, self.member_types)
         else:
             return '%s(name=%r)' % (self.__class__.__name__, self.prefixed_name)
 
-    def __setattr__(self, name, value):
+    def __setattr__(self, name: str, value: Any) -> None:
         if name == 'elem' and value is not None and value.tag != XSD_UNION:
             if value.tag == XSD_SIMPLE_TYPE:
                 for child in value:
@@ -946,13 +965,13 @@
             value = 'collapse'
         super(XsdUnion, self).__setattr__(name, value)
 
-    def _parse(self):
-        super(XsdUnion, self)._parse()
+    def _parse(self) -> None:
+        mt: Any
         member_types = 
 
         for child in self.elem:
             if child.tag != XSD_ANNOTATION and not callable(child.tag):
-                mt = xsd_simple_type_factory(child, self.schema, self)
+                mt = self.schema.simple_type_factory(child, parent=self)
                 if isinstance(mt, XMLSchemaParseError):
                     self.parse_error(mt)
                 else:
@@ -1000,33 +1019,41 @@
                 self.allow_empty = False
 
     @property
-    def admitted_facets(self):
+    def variety(self) -> Optionalstr:
+        return 'union'
+
+    @property
+    def admitted_facets(self) -> Setstr:
         return XSD_10_UNION_FACETS if self.xsd_version == '1.0' else XSD_11_UNION_FACETS
 
-    def is_atomic(self):
+    def is_atomic(self) -> bool:
         return all(mt.is_atomic() for mt in self.member_types)
 
-    def is_list(self):
+    def is_list(self) -> bool:
         return all(mt.is_list() for mt in self.member_types)
 
-    def is_key(self):
+    def is_key(self) -> bool:
         return any(mt.is_key() for mt in self.member_types)
 
-    def is_union(self):
+    def is_union(self) -> bool:
         return True
 
-    def is_dynamic_consistent(self, other):
+    def is_dynamic_consistent(self, other: Any) -> bool:
         return other.name in {XSD_ANY_TYPE, XSD_ANY_SIMPLE_TYPE} or \
             other.is_derived(self) or isinstance(other, self.__class__) and \
             any(mt1.is_derived(mt2) for mt1 in other.member_types for mt2 in self.member_types)
 
-    def iter_components(self, xsd_classes=None):
+    def iter_components(self, xsd_classes: ComponentClassType = None) \
+            -> IteratorXsdComponent:
         if xsd_classes is None or isinstance(self, xsd_classes):
             yield self
         for mt in filter(lambda x: x.parent is not None, self.member_types):
             yield from mt.iter_components(xsd_classes)
 
-    def iter_decode(self, obj, validation='lax', patterns=None, **kwargs):
+    def iter_decode(self, obj: Any, validation: str = 'lax',
+                    patterns: OptionalXsdPatternFacets = None,
+                    **kwargs: Any) -> IterDecodeTypeDecodedValueType:
+
         # Try decoding the whole text
         for member_type in self.member_types:
             for result in member_type.iter_decode(obj, validation='lax', **kwargs):
@@ -1069,7 +1096,9 @@
 
         yield items if len(items) > 1 else items0 if items else None
 
-    def iter_encode(self, obj, validation='lax', **kwargs):
+    def iter_encode(self, obj: Any, validation: str = 'lax', **kwargs: Any) \
+            -> IterEncodeTypeEncodedValueType:
+
         for member_type in self.member_types:
             for result in member_type.iter_encode(obj, validation='lax', **kwargs):
                 if result is not None and not isinstance(result, XMLSchemaValidationError):
@@ -1120,11 +1149,13 @@
           enumeration | whiteSpace | pattern)*))
         </restriction>
     """
+    parent: 'XsdSimpleType'
+    base_type: BaseXsdType
     derivation = 'restriction'
     _FACETS_BUILDERS = XSD_10_FACETS_BUILDERS
     _CONTENT_TAIL_TAGS = {XSD_ATTRIBUTE, XSD_ATTRIBUTE_GROUP, XSD_ANY_ATTRIBUTE}
 
-    def __setattr__(self, name: str, value: Any):
+    def __setattr__(self, name: str, value: Any) -> None:
         if name == 'elem' and value is not None:
             if self.name != XSD_ANY_ATOMIC_TYPE and value.tag != XSD_RESTRICTION:
                 if not (value.tag == XSD_SIMPLE_TYPE and value.get('name') is not None):
@@ -1133,19 +1164,19 @@
                     )
         super(XsdAtomicRestriction, self).__setattr__(name, value)
 
-    def _parse(self):
-        super(XsdAtomicRestriction, self)._parse()
+    def _parse(self) -> None:
         elem = self.elem
         if elem.get('name') == XSD_ANY_ATOMIC_TYPE:
             return  # skip special type xs:anyAtomicType
         elif elem.tag == XSD_SIMPLE_TYPE and elem.get('name') is not None:
-            elem = self._parse_child_component(elem)  # Global simpleType with internal restriction
+            # Global simpleType with internal restriction
+            elem = cast(ElementType, self._parse_child_component(elem))
 
         if self.name is not None and self.parent is not None:
             self.parse_error("'name' attribute in a local simpleType definition")
 
-        base_type = None
-        facets = {}
+        base_type: Any = None
+        facets: Any = {}
         has_attributes = False
         has_simple_type_child = False
 
@@ -1213,17 +1244,17 @@
 
                 if base_type is None:
                     try:
-                        base_type = xsd_simple_type_factory(child, self.schema, self)
+                        base_type = self.schema.simple_type_factory(child, parent=self)
                     except XMLSchemaParseError as err:
                         self.parse_error(err, child)
                         base_type = self.any_simple_type
                 elif base_type.is_complex():
                     if base_type.admit_simple_restriction():
-                        base_type = self.schema.BUILDERS.complex_type_class(
+                        base_type = self.schema.xsd_complex_type_class(
                             elem=elem,
                             schema=self.schema,
                             parent=self,
-                            content=xsd_simple_type_factory(child, self.schema, self),
+                            content=self.schema.simple_type_factory(child, parent=self),
                             attributes=base_type.attributes,
                             mixed=base_type.mixed,
                             block=base_type.block,
@@ -1267,20 +1298,38 @@
         self.facets = facets
 
     @property
-    def variety(self):
-        return self.base_type.variety
+    def variety(self) -> Optionalstr:
+        return cast(Optionalstr, getattr(self.base_type, 'variety', None))
 
-    def iter_components(self, xsd_classes=None):
-        if xsd_classes is None or isinstance(self, xsd_classes):
+    def iter_components(self, xsd_classes: ComponentClassType = None) \
+            -> IteratorXsdComponent:
+        if xsd_classes is None:
             yield self
+            for facet in self.facets.values():
+                if isinstance(facet, list):
+                    yield from facet  # XSD 1.1 assertions can be more than one
+                elif isinstance(facet, XsdFacet):
+                    yield facet  # only XSD facets, skip callables
+        else:
+            if isinstance(self, xsd_classes):
+                yield self
+            if issubclass(XsdFacet, xsd_classes):
+                for facet in self.facets.values():
+                    if isinstance(facet, list):
+                        yield from facet
+                    elif isinstance(facet, XsdFacet):
+                        yield facet
+
         if self.base_type.parent is not None:
             yield from self.base_type.iter_components(xsd_classes)
 
-    def iter_decode(self, obj, validation='lax', **kwargs):
+    def iter_decode(self, obj: Unionstr, bytes, validation: str = 'lax', **kwargs: Any) \
+            -> IterDecodeTypeDecodedValueType:
         if isinstance(obj, (str, bytes)):
             obj = self.normalize(obj)
 
-        if self.base_type.is_simple():
+        base_type: Any
+        if isinstance(self.base_type, XsdSimpleType):
             base_type = self.base_type
         elif self.base_type.has_simple_content():
             base_type = self.base_type.content
@@ -1316,7 +1365,10 @@
                 yield result
                 return
 
-    def iter_encode(self, obj, validation='lax', **kwargs):
+    def iter_encode(self, obj: Any, validation: str = 'lax', **kwargs: Any) \
+            -> IterEncodeTypeEncodedValueType:
+
+        base_type: Any
         if self.is_list():
             if not hasattr(obj, '__iter__') or isinstance(obj, (str, bytes)):
                 obj =  if obj is None or obj == '' else obj
@@ -1325,7 +1377,7 @@
             if isinstance(obj, (str, bytes)):
                 obj = self.normalize(obj)
 
-            if self.base_type.is_simple():
+            if isinstance(self.base_type, XsdSimpleType):
                 base_type = self.base_type
             elif self.base_type.has_simple_content():
                 base_type = self.base_type.content
@@ -1336,6 +1388,7 @@
                 raise XMLSchemaValueError("wrong base type %r: a simpleType or a complexType with "
                                           "simple or mixed content required." % self.base_type)
 
+        result: Any
         for result in base_type.iter_encode(obj, validation):
             if isinstance(result, XMLSchemaValidationError):
                 yield result
@@ -1370,10 +1423,10 @@
                 yield result
                 return
 
-    def is_list(self):
+    def is_list(self) -> bool:
         return self.primitive_type.is_list()
 
-    def is_union(self):
+    def is_union(self) -> bool:
         return self.primitive_type.is_union()

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/validators/wildcards.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/validators/wildcards.py Changed

@@ -10,23 +10,38 @@
 """
 This module contains classes for XML Schema wildcards.
 """
+from typing import cast, Any, Callable, Dict, Iterable, Iterator, List, Optional, \
+    Tuple, Union, Counter
+
 from ..exceptions import XMLSchemaValueError
 from ..names import XSI_NAMESPACE, XSD_ANY, XSD_ANY_ATTRIBUTE, \
     XSD_OPEN_CONTENT, XSD_DEFAULT_OPEN_CONTENT, XSI_TYPE
+from ..aliases import ElementType, SchemaType, SchemaElementType, SchemaAttributeType, \
+    ModelGroupType, ModelParticleType, AtomicValueType, IterDecodeType, IterEncodeType, \
+    DecodedValueType, EncodedValueType
 from ..helpers import get_namespace, raw_xml_encode
-from ..xpath import XMLSchemaProxy, ElementPathMixin
+from ..xpath import XMLSchemaProtocol, ElementProtocol, XMLSchemaProxy, ElementPathMixin
 from .xsdbase import ValidationMixin, XsdComponent
 from .particles import ParticleMixin
+from . import elements
+
 
+OccursCounterType = CounterUnionModelParticleType, TupleModelParticleType
 
-class XsdWildcard(XsdComponent, ValidationMixin):
+
+class XsdWildcard(XsdComponent):
     names = ()
-    namespace = ('##any',)
-    not_namespace = ()
-    not_qname = ()
+    namespace: UnionTuplestr, Liststr = ('##any',)
+    not_namespace: UnionTuple(), Liststr = ()
+    not_qname: UnionTuple(), Liststr = ()
     process_contents = 'strict'
 
-    def __repr__(self):
+    # For compatibility with protocol of XSD elements/attributes
+    type = None
+    default = None
+    fixed = None
+
+    def __repr__(self) -> str:
         if self.not_namespace:
             return '%s(not_namespace=%r, process_contents=%r)' % (
                 self.__class__.__name__, self.not_namespace, self.process_contents
@@ -36,11 +51,9 @@
                 self.__class__.__name__, self.namespace, self.process_contents
             )
 
-    def _parse(self):
-        super(XsdWildcard, self)._parse()
-
+    def _parse(self) -> None:
         # Parse namespace and processContents
-        namespace = self.elem.get('namespace', '##any').strip()
+        namespace = self.elem.attrib.get('namespace', '##any').strip()
         if namespace == '##any':
             pass
         elif not namespace:
@@ -63,7 +76,7 @@
                 else:
                     self.namespace.append(ns)
 
-        process_contents = self.elem.get('processContents', 'strict')
+        process_contents = self.elem.attrib.get('processContents', 'strict')
         if process_contents == 'strict':
             pass
         elif process_contents not in ('lax', 'skip'):
@@ -72,7 +85,7 @@
         else:
             self.process_contents = process_contents
 
-    def _parse_not_constraints(self):
+    def _parse_not_constraints(self) -> None:
         if 'notNamespace' not in self.elem.attrib:
             pass
         elif 'namespace' in self.elem.attrib:
@@ -127,10 +140,12 @@
         self.not_qname = names
 
     @property
-    def built(self):
+    def built(self) -> bool:
         return True
 
-    def is_matching(self, name, default_namespace=None, **kwargs):
+    def is_matching(self, name: Optionalstr,
+                    default_namespace: Optionalstr = None,
+                    **kwargs: Any) -> bool:
         if name is None:
             return False
         elif not name or name0 == '{':
@@ -141,17 +156,19 @@
             return self.is_namespace_allowed('') or \
                 self.is_namespace_allowed(default_namespace)
 
-    def is_namespace_allowed(self, namespace):
+    def is_namespace_allowed(self, namespace: str) -> bool:
         if self.not_namespace:
             return namespace not in self.not_namespace
         elif '##any' in self.namespace or namespace == XSI_NAMESPACE:
             return True
         elif '##other' in self.namespace:
-            return namespace and namespace != self.target_namespace
+            if not namespace:
+                return False
+            return namespace != self.target_namespace
         else:
             return namespace in self.namespace
 
-    def deny_namespaces(self, namespaces):
+    def deny_namespaces(self, namespaces: Liststr) -> bool:
         if self.not_namespace:
             return all(x in self.not_namespace for x in namespaces)
         elif '##any' in self.namespace:
@@ -161,7 +178,7 @@
         else:
             return all(x not in self.namespace for x in namespaces)
 
-    def deny_qnames(self, names):
+    def deny_qnames(self, names: Iterablestr) -> bool:
         if self.not_namespace:
             return all(x in self.not_qname or get_namespace(x) in self.not_namespace
                        for x in names)
@@ -174,13 +191,17 @@
             return all(x in self.not_qname or get_namespace(x) not in self.namespace
                        for x in names)
 
-    def is_restriction(self, other, check_occurs=True):
+    def is_restriction(self, other: UnionModelParticleType, 'XsdAnyAttribute',
+                       check_occurs: bool = True) -> bool:
         if check_occurs and isinstance(self, ParticleMixin) \
+                and not isinstance(other, XsdAnyAttribute) \
                 and not self.has_occurs_restriction(other):
             return False
-        elif not isinstance(other, type(self)):
+        elif not isinstance(other, self.__class__):
             return False
-        elif other.process_contents == 'strict' and self.process_contents != 'strict':
+
+        other: XsdWildcard  # type: ignoreno-redef
+        if other.process_contents == 'strict' and self.process_contents != 'strict':
             return False
         elif other.process_contents == 'lax' and self.process_contents == 'skip':
             return False
@@ -226,7 +247,7 @@
         else:
             return all(ns in other.namespace for ns in self.namespace)
 
-    def union(self, other):
+    def union(self, other: Union'XsdAnyElement', 'XsdAnyAttribute') -> None:
         """
         Update an XSD wildcard with the union of itself and another XSD wildcard.
         """
@@ -267,6 +288,8 @@
             self.namespace = '##any' if not self.not_namespace else 
             return
 
+        w1: XsdWildcard
+        w2: XsdWildcard
         if '##any' in self.namespace or self.namespace == other.namespace:
             return
         elif '##any' in other.namespace:
@@ -277,6 +300,7 @@
         elif '##other' in self.namespace:
             w1, w2 = self, other
         else:
+            assert isinstance(self.namespace, list)
             self.namespace.extend(ns for ns in other.namespace if ns not in self.namespace)
             return
 
@@ -291,7 +315,7 @@
             self.namespace = 
             self.not_namespace = '', w1.target_namespace if w1.target_namespace else ''
 
-    def intersection(self, other):
+    def intersection(self, other: Union'XsdAnyElement', 'XsdAnyAttribute') -> None:
         """
         Update an XSD wildcard with the intersection of itself and another XSD wildcard.
         """
@@ -342,19 +366,16 @@
         elif '##other' not in other.namespace:
             self.namespace = ns for ns in self.namespace if ns in other.namespace
         else:
+            assert isinstance(self.namespace, list)
             if other.target_namespace in self.namespace:
                 self.namespace.remove(other.target_namespace)
             if '' in self.namespace:
                 self.namespace.remove('')
 
-    def iter_decode(self, source, validation='lax', **kwargs):
-        raise NotImplementedError
 
-    def iter_encode(self, obj, validation='lax', **kwargs):
-        raise NotImplementedError
-
-
-class XsdAnyElement(XsdWildcard, ParticleMixin, ElementPathMixin):
+class XsdAnyElement(XsdWildcard, ParticleMixin,
+                    ElementPathMixinSchemaElementType,
+                    ValidationMixinElementType, Any):
     """
     Class for XSD 1.0 *any* wildcards.
 
@@ -369,31 +390,38 @@
         </any>
     """
     _ADMITTED_TAGS = {XSD_ANY}
-    precedences = ()
+    precedences: DictModelGroupType, ListModelParticleType
+    copy: Callable'XsdAnyElement', 'XsdAnyElement'
 
-    def __init__(self, elem, schema, parent, maps=None):
-        super(XsdAnyElement, self).__init__(elem, schema, parent, maps)
-        ElementPathMixin.__init__(self)
+    def __init__(self, elem: ElementType, schema: SchemaType, parent: XsdComponent) -> None:
+        self.precedences = {}
+        super(XsdAnyElement, self).__init__(elem, schema, parent)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         if self.namespace:
             return '%s(namespace=%r, process_contents=%r, occurs=%r)' % (
-                self.__class__.__name__, self.namespace, self.process_contents, self.occurs
+                self.__class__.__name__, self.namespace,
+                self.process_contents, list(self.occurs)
             )
         else:
             return '%s(not_namespace=%r, process_contents=%r, occurs=%r)' % (
-                self.__class__.__name__, self.not_namespace, self.process_contents, self.occurs
+                self.__class__.__name__, self.not_namespace,
+                self.process_contents, list(self.occurs)
             )
 
     @property
-    def xpath_proxy(self):
-        return XMLSchemaProxy(self.schema, self)
+    def xpath_proxy(self) -> XMLSchemaProxy:
+        return XMLSchemaProxy(
+            schema=cast(XMLSchemaProtocol, self.schema),
+            base_element=cast(ElementProtocol, self)
+        )
 
-    def _parse(self):
+    def _parse(self) -> None:
         super(XsdAnyElement, self)._parse()
         self._parse_particle(self.elem)
 
-    def match(self, name, default_namespace=None, resolve=False, **kwargs):
+    def match(self, name: Optionalstr, default_namespace: Optionalstr = None,
+              resolve: bool = False, **kwargs: Any) -> OptionalSchemaElementType:
         """
         Returns the element wildcard if name is matching the name provided
         as argument, `None` otherwise.
@@ -405,8 +433,8 @@
         resolve and return the element matching the name.
         :param kwargs: additional options used by XSD 1.1 xs:any wildcards.
         """
-        if not self.is_matching(name, default_namespace, **kwargs):
-            return
+        if not name or not self.is_matching(name, default_namespace, **kwargs):
+            return None
         elif not resolve:
             return self
 
@@ -416,62 +444,63 @@
             else:
                 return self.maps.lookup_element(name)
         except LookupError:
-            pass
+            return None
 
-    def __iter__(self):
+    def __iter__(self) -> IteratorAny:
         return iter(())
 
-    def iter(self, tag=None):
+    def iter(self, tag: Optionalstr = None) -> IteratorAny:
         return iter(())
 
-    def iterchildren(self, tag=None):
+    def iterchildren(self, tag: Optionalstr = None) -> IteratorAny:
         return iter(())
 
     @staticmethod
-    def iter_substitutes():
+    def iter_substitutes() -> IteratorAny:
         return iter(())
 
-    def iter_decode(self, elem, validation='lax', **kwargs):
-        if not self.is_matching(elem.tag):
-            reason = "{!r} is not allowed here".format(elem)
-            yield self.validation_error(validation, reason, elem, **kwargs)
+    def iter_decode(self, obj: ElementType, validation: str = 'lax', **kwargs: Any) \
+            -> IterDecodeTypeAny:
 
-        elif self.process_contents == 'skip':
-            return
+        if not self.is_matching(obj.tag):
+            reason = "{!r} is not allowed here".format(obj)
+            yield self.validation_error(validation, reason, obj, **kwargs)
+
+        if self.process_contents == 'skip':
+            if 'process_skipped' not in kwargs or not kwargs'process_skipped':
+                return
 
-        elif self.maps.load_namespace(get_namespace(elem.tag)):
+        namespace = get_namespace(obj.tag)
+        if not self.maps.load_namespace(namespace):
+            reason = f"unavailable namespace {namespace!r}"
+        else:
             try:
-                xsd_element = self.maps.lookup_element(elem.tag)
+                xsd_element = self.maps.lookup_element(obj.tag)
             except LookupError:
-                if XSI_TYPE in elem.attrib:
-                    if self.process_contents == 'lax':
-                        xsd_element = self.maps.validator.create_element(
-                            elem.tag, parent=self, nillable='true', form='unqualified'
-                        )
-                    else:
-                        xsd_element = self.maps.validator.create_element(
-                            elem.tag, parent=self, form='unqualified'
-                        )
-                    yield from xsd_element.iter_decode(elem, validation, **kwargs)
-                elif validation == 'skip' or self.process_contents == 'lax':
-                    yield from self.any_type.iter_decode(elem, validation, **kwargs)
-                else:
-                    reason = "element %r not found." % elem.tag
-                    yield self.validation_error(validation, reason, elem, **kwargs)
+                reason = f"element {obj.tag!r} not found"
             else:
-                yield from xsd_element.iter_decode(elem, validation, **kwargs)
+                yield from xsd_element.iter_decode(obj, validation, **kwargs)
+                return
 
-        elif validation == 'skip':
-            if len(elem) > 0:
-                yield self.any_type.decode(elem, validation, **kwargs)
+        if XSI_TYPE in obj.attrib:
+            if self.process_contents == 'strict':
+                xsd_element = self.maps.validator.create_element(
+                    obj.tag, parent=self, form='unqualified'
+                )
             else:
-                yield elem.text
+                xsd_element = self.maps.validator.create_element(
+                    obj.tag, parent=self, nillable='true', form='unqualified'
+                )
 
-        elif self.process_contents == 'strict':
-            reason = "unavailable namespace {!r}".format(get_namespace(elem.tag))
-            yield self.validation_error(validation, reason, elem, **kwargs)
+            yield from xsd_element.iter_decode(obj, validation, **kwargs)
+            return
 
-    def iter_encode(self, obj, validation='lax', **kwargs):
+        if validation != 'skip' and self.process_contents == 'strict':
+            yield self.validation_error(validation, reason, obj, **kwargs)
+        yield from self.any_type.iter_decode(obj, validation, **kwargs)
+
+    def iter_encode(self, obj: Tuplestr, ElementType, validation: str = 'lax', **kwargs: Any) \
+            -> IterEncodeTypeAny:
         name, value = obj
         namespace = get_namespace(name)
 
@@ -479,32 +508,59 @@
             reason = "element {!r} is not allowed here".format(name)
             yield self.validation_error(validation, reason, value, **kwargs)
 
-        elif self.process_contents == 'skip':
-            return
+        if self.process_contents == 'skip':
+            if 'process_skipped' not in kwargs or not kwargs'process_skipped':
+                return
 
-        elif self.maps.load_namespace(namespace):
+        if not self.maps.load_namespace(namespace):
+            reason = f"unavailable namespace {namespace!r}"
+        else:
             try:
                 xsd_element = self.maps.lookup_element(name)
             except LookupError:
-                if validation == 'skip' or self.process_contents == 'lax':
-                    yield from self.any_type.iter_encode(obj, validation, **kwargs)
-                elif self.process_contents == 'strict':
-                    reason = "element %r not found." % name
-                    yield self.validation_error(validation, reason, **kwargs)
+                reason = f"element {name!r} not found"
             else:
                 yield from xsd_element.iter_encode(value, validation, **kwargs)
+                return
+
+        # Check if there is an xsi:type attribute, but it has to extract
+        # attributes using the converter instance.
+        if self.process_contents == 'strict':
+            xsd_element = self.maps.validator.create_element(
+                name, parent=self, form='unqualified'
+            )
+        else:
+            xsd_element = self.maps.validator.create_element(
+                name, parent=self, nillable='true', form='unqualified'
+            )
+
+        try:
+            converter = kwargs'converter'
+        except KeyError:
+            converter = kwargs'converter' = self.schema.get_converter(**kwargs)
 
-        elif validation == 'skip':
-            yield self.any_type.encode(value, validation, **kwargs)
+        try:
+            level = kwargs'level'
+        except KeyError:
+            element_data = converter.element_encode(value, xsd_element)
+        else:
+            element_data = converter.element_encode(value, xsd_element, level)
+
+        if XSI_TYPE in element_data.attributes:
+            yield from xsd_element.iter_encode(value, validation, **kwargs)
+            return
 
-        elif self.process_contents == 'strict':
-            reason = "unavailable namespace {!r}".format(namespace)
+        if validation != 'skip' and self.process_contents == 'strict':
             yield self.validation_error(validation, reason, **kwargs)
+        yield from self.any_type.iter_encode(obj, validation, **kwargs)
 
-    def is_overlap(self, other):
+    def is_overlap(self, other: ModelParticleType) -> bool:
         if not isinstance(other, XsdAnyElement):
-            return other.is_overlap(self)
-        elif self.not_namespace:
+            if isinstance(other, elements.XsdElement):
+                return other.is_overlap(self)
+            return False
+
+        if self.not_namespace:
             if other.not_namespace:
                 return True
             elif '##any' in other.namespace:
@@ -531,11 +587,11 @@
         else:
             return any(ns in self.namespace for ns in other.namespace)
 
-    def is_consistent(self, other):
+    def is_consistent(self, other: SchemaElementType, **kwargs: Any) -> bool:
         return True
 
 
-class XsdAnyAttribute(XsdWildcard):
+class XsdAnyAttribute(XsdWildcard, ValidationMixinTuplestr, str, DecodedValueType):
     """
     Class for XSD 1.0 *anyAttribute* wildcards.
 
@@ -547,9 +603,15 @@
           Content: (annotation?)
         </anyAttribute>
     """
+    copy: Callable'XsdAnyAttribute', 'XsdAnyAttribute'
     _ADMITTED_TAGS = {XSD_ANY_ATTRIBUTE}
 
-    def match(self, name, default_namespace=None, resolve=False, **kwargs):
+    # Added for compatibility with protocol of XSD attributes
+    use = None
+    inheritable = False  # XSD 1.1 attributes
+
+    def match(self, name: Optionalstr, default_namespace: Optionalstr = None,
+              resolve: bool = False, **kwargs: Any) -> OptionalSchemaAttributeType:
         """
         Returns the attribute wildcard if name is matching the name provided
         as argument, `None` otherwise.
@@ -561,8 +623,8 @@
         resolve and return the attribute matching the name.
         :param kwargs: additional options that can be used by certain components.
         """
-        if not self.is_matching(name, default_namespace, **kwargs):
-            return
+        if not name or not self.is_matching(name, default_namespace, **kwargs):
+            return None
         elif not resolve:
             return self
 
@@ -572,67 +634,67 @@
             else:
                 return self.maps.lookup_attribute(name)
         except LookupError:
-            pass
+            return None
 
-    def iter_decode(self, attribute, validation='lax', **kwargs):
-        name, value = attribute
+    def iter_decode(self, obj: Tuplestr, str, validation: str = 'lax', **kwargs: Any) \
+            -> IterDecodeTypeDecodedValueType:
+        name, value = obj
 
         if not self.is_matching(name):
             reason = "attribute %r not allowed." % name
-            yield self.validation_error(validation, reason, attribute, **kwargs)
+            yield self.validation_error(validation, reason, obj, **kwargs)
 
-        elif self.process_contents == 'skip':
-            return
+        if self.process_contents == 'skip':
+            if 'process_skipped' not in kwargs or not kwargs'process_skipped':
+                return
 
-        elif self.maps.load_namespace(get_namespace(name)):
+        if self.maps.load_namespace(get_namespace(name)):
             try:
                 xsd_attribute = self.maps.lookup_attribute(name)
             except LookupError:
-                if validation == 'skip':
-                    yield value
-                elif self.process_contents == 'strict':
+                if validation != 'skip' and self.process_contents == 'strict':
                     reason = "attribute %r not found." % name
-                    yield self.validation_error(validation, reason, attribute, **kwargs)
+                    yield self.validation_error(validation, reason, obj, **kwargs)
             else:
                 yield from xsd_attribute.iter_decode(value, validation, **kwargs)
+                return
 
-        elif validation == 'skip':
-            yield value
-
-        elif self.process_contents == 'strict':
+        elif validation != 'skip' and self.process_contents == 'strict':
             reason = "unavailable namespace {!r}".format(get_namespace(name))
             yield self.validation_error(validation, reason, **kwargs)
 
-    def iter_encode(self, attribute, validation='lax', **kwargs):
-        name, value = attribute
+        yield value
+
+    def iter_encode(self, obj: Tuplestr, AtomicValueType, validation: str = 'lax',
+                    **kwargs: Any) -> IterEncodeTypeEncodedValueType:
+        name, value = obj
         namespace = get_namespace(name)
 
         if not self.is_namespace_allowed(namespace):
             reason = "attribute %r not allowed." % name
-            yield self.validation_error(validation, reason, attribute, **kwargs)
+            yield self.validation_error(validation, reason, obj, **kwargs)
 
-        elif self.process_contents == 'skip':
-            return
+        if self.process_contents == 'skip':
+            if 'process_skipped' not in kwargs or not kwargs'process_skipped':
+                return
 
-        elif self.maps.load_namespace(namespace):
+        if self.maps.load_namespace(namespace):
             try:
                 xsd_attribute = self.maps.lookup_attribute(name)
             except LookupError:
-                if validation == 'skip':
-                    yield raw_xml_encode(value)
-                elif self.process_contents == 'strict':
+                if validation != 'skip' and self.process_contents == 'strict':
                     reason = "attribute %r not found." % name
-                    yield self.validation_error(validation, reason, attribute, **kwargs)
+                    yield self.validation_error(validation, reason, obj, **kwargs)
             else:
                 yield from xsd_attribute.iter_encode(value, validation, **kwargs)
+                return
 
-        elif validation == 'skip':
-            yield raw_xml_encode(value)
-
-        elif self.process_contents == 'strict':
+        elif validation != 'skip' and self.process_contents == 'strict':
             reason = "unavailable namespace {!r}".format(get_namespace(name))
             yield self.validation_error(validation, reason, **kwargs)
 
+        yield raw_xml_encode(value)
+
 
 class Xsd11AnyElement(XsdAnyElement):
     """
@@ -650,11 +712,15 @@
           Content: (annotation?)
         </any>
     """
-    def _parse(self):
+    def _parse(self) -> None:
         super(Xsd11AnyElement, self)._parse()
         self._parse_not_constraints()
 
-    def is_matching(self, name, default_namespace=None, group=None, occurs=None):
+    def is_matching(self, name: Optionalstr,
+                    default_namespace: Optionalstr = None,
+                    group: OptionalModelGroupType = None,
+                    occurs: OptionalOccursCounterType = None,
+                    **kwargs: Any) -> bool:
         """
         Returns `True` if the component name is matching the name provided as argument,
         `False` otherwise. For XSD elements the matching is extended to substitutes.
@@ -697,15 +763,13 @@
 
         return name not in self.not_qname
 
-    def is_consistent(self, other):
+    def is_consistent(self, other: SchemaElementType, **kwargs: Any) -> bool:
         if isinstance(other, XsdAnyElement) or self.process_contents == 'skip':
             return True
         xsd_element = self.match(other.name, other.default_namespace, resolve=True)
         return xsd_element is None or other.is_consistent(xsd_element, strict=False)
 
-    def add_precedence(self, other, group):
-        if not self.precedences:
-            self.precedences = {}
+    def add_precedence(self, other: ModelParticleType, group: ModelGroupType) -> None:
         try:
             self.precedencesgroup.append(other)
         except KeyError:
@@ -726,13 +790,13 @@
           Content: (annotation?)
         </anyAttribute>
     """
-    inheritable = False  # Added for reduce checkings on XSD 1.1 attributes
-
-    def _parse(self):
+    def _parse(self) -> None:
         super(Xsd11AnyAttribute, self)._parse()
         self._parse_not_constraints()
 
-    def is_matching(self, name, default_namespace=None, **kwargs):
+    def is_matching(self, name: Optionalstr,
+                    default_namespace: Optionalstr = None,
+                    **kwargs: Any) -> bool:
         if name is None:
             return False
         elif not name or name0 == '{':
@@ -744,8 +808,13 @@
             namespace = default_namespace
 
         if '##defined' in self.not_qname and name in self.maps.attributes:
-            if self.maps.attributesname.schema is self.schema:
+            xsd_attribute = self.maps.attributesname
+            if isinstance(xsd_attribute, tuple):
+                if xsd_attribute1 is self.schema:
+                    return False
+            elif xsd_attribute.schema is self.schema:
                 return False
+
         return name not in self.not_qname and self.is_namespace_allowed(namespace)
 
 
@@ -762,15 +831,15 @@
     """
     _ADMITTED_TAGS = {XSD_OPEN_CONTENT}
     mode = 'interleave'
-    any_element = None
+    any_element = None  # type: Xsd11AnyElement
 
-    def __init__(self, elem, schema, parent):
+    def __init__(self, elem: ElementType, schema: SchemaType, parent: XsdComponent) -> None:
         super(XsdOpenContent, self).__init__(elem, schema, parent)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return '%s(mode=%r)' % (self.__class__.__name__, self.mode)
 
-    def _parse(self):
+    def _parse(self) -> None:
         super(XsdOpenContent, self)._parse()
         try:
             self.mode = self.elem.attrib'mode'
@@ -794,10 +863,10 @@
             self.any_element = any_element
 
     @property
-    def built(self):
+    def built(self) -> bool:
         return True
 
-    def is_restriction(self, other):
+    def is_restriction(self, other: 'XsdOpenContent') -> bool:
         if other is None or other.mode == 'none':
             return self.mode == 'none'
         elif self.mode == 'interleave' and other.mode == 'suffix':
@@ -821,10 +890,10 @@
     _ADMITTED_TAGS = {XSD_DEFAULT_OPEN_CONTENT}
     applies_to_empty = False
 
-    def __init__(self, elem, schema):
+    def __init__(self, elem: ElementType, schema: SchemaType) -> None:
         super(XsdOpenContent, self).__init__(elem, schema)
 
-    def _parse(self):
+    def _parse(self) -> None:
         super(XsdDefaultOpenContent, self)._parse()
         if self.parent is not None:
             self.parse_error("defaultOpenContent must be a child of the schema")

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/validators/xsdbase.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/validators/xsdbase.py Changed

@@ -11,17 +11,30 @@
 This module contains base functions and classes XML Schema components.
 """
 import re
-from typing import Optional
+from typing import TYPE_CHECKING, cast, Any, Dict, Generic, List, Iterator, Optional, \
+    Set, Tuple, TypeVar, Union, MutableMapping
+
+import elementpath
 
 from ..exceptions import XMLSchemaValueError, XMLSchemaTypeError
 from ..names import XSD_ANNOTATION, XSD_APPINFO, XSD_DOCUMENTATION, XML_LANG, \
     XSD_ANY_TYPE, XSD_ANY_SIMPLE_TYPE, XSD_ANY_ATOMIC_TYPE, XSD_ID, XSD_QNAME, \
     XSD_OVERRIDE, XSD_NOTATION_TYPE, XSD_DECIMAL
-from ..etree import is_etree_element, etree_tostring
+from ..etree import is_etree_element, etree_tostring, etree_element
+from ..aliases import ElementType, NamespacesType, SchemaType, BaseXsdType, \
+    ComponentClassType, ExtraValidatorType, DecodeType, IterDecodeType, \
+    EncodeType, IterEncodeType
 from ..helpers import get_qname, local_name, get_prefixed_qname
-from .. import dataobjects
+from ..resources import XMLResource
 from .exceptions import XMLSchemaParseError, XMLSchemaValidationError
 
+if TYPE_CHECKING:
+    from .simple_types import XsdSimpleType
+    from .complex_types import XsdComplexType
+    from .elements import XsdElement
+    from .groups import XsdGroup
+    from .global_maps import XsdGlobals
+
 XSD_TYPE_DERIVATIONS = {'extension', 'restriction'}
 XSD_ELEMENT_DERIVATIONS = {'extension', 'restriction', 'substitution'}
 
@@ -32,7 +45,7 @@
 """
 
 
-def check_validation_mode(validation):
+def check_validation_mode(validation: str) -> None:
     if validation not in XSD_VALIDATION_MODES:
         raise XMLSchemaValueError("validation mode can be 'strict', "
                                   "'lax' or 'skip': %r" % validation)
@@ -53,14 +66,16 @@
     :ivar errors: XSD validator building errors.
     :vartype errors: list
     """
-    xsd_version = elem = None
+    elem: Optionaletree_element = None
+    namespaces: Any = None
+    errors: ListXMLSchemaParseError
 
-    def __init__(self, validation='strict'):
+    def __init__(self, validation: str = 'strict') -> None:
         self.validation = validation
         self.errors = 
 
     @property
-    def built(self):
+    def built(self) -> bool:
         """
         Property that is ``True`` if XSD validator has been fully parsed and built,
         ``False`` otherwise. For schemas the property is checked on all global
@@ -69,7 +84,7 @@
         raise NotImplementedError()
 
     @property
-    def validation_attempted(self):
+    def validation_attempted(self) -> str:
         """
         Property that returns the *validation status* of the XSD validator.
         It can be 'full', 'partial' or 'none'.
@@ -80,7 +95,7 @@
         raise NotImplementedError()
 
     @property
-    def validity(self):
+    def validity(self) -> str:
         """
         Property that returns the XSD validator's validity.
         It can be ‘valid’, ‘invalid’ or ‘notKnown’.
@@ -97,7 +112,8 @@
         else:
             return 'notKnown'
 
-    def iter_components(self, xsd_classes=None):
+    def iter_components(self, xsd_classes: ComponentClassType = None) \
+            -> IteratorUnion'XsdComponent', SchemaType, 'XsdGlobals':
         """
         Creates an iterator for traversing all XSD components of the validator.
 
@@ -107,7 +123,7 @@
         raise NotImplementedError()
 
     @property
-    def all_errors(self):
+    def all_errors(self) -> ListXMLSchemaParseError:
         """
         A list with all the building errors of the XSD validator and its components.
         """
@@ -117,15 +133,17 @@
                 errors.extend(comp.errors)
         return errors
 
-    def copy(self):
-        validator = object.__new__(self.__class__)
+    def copy(self) -> 'XsdValidator':
+        validator: 'XsdValidator' = object.__new__(self.__class__)
         validator.__dict__.update(self.__dict__)
-        validator.errors = self.errors:
+        validator.errors = self.errors:  # shallow copy duplicates errors list
         return validator
 
     __copy__ = copy
 
-    def parse_error(self, error, elem=None, validation=None):
+    def parse_error(self, error: Unionstr, Exception,
+                    elem: OptionalElementType = None,
+                    validation: Optionalstr = None) -> None:
         """
         Helper method for registering parse errors. Does nothing if validation mode is 'skip'.
         Il validation mode is 'lax' collects the error, otherwise raise the error.
@@ -135,7 +153,7 @@
         attribute of the validator, if it's present.
         :param validation: overrides the default validation mode of the validator.
         """
-        if validation:
+        if validation is not None:
             check_validation_mode(validation)
         else:
             validation = self.validation
@@ -169,7 +187,46 @@
         else:
             raise error
 
-    def _parse_xpath_default_namespace(self, elem):
+    def validation_error(self, validation: str,
+                         error: Unionstr, Exception,
+                         obj: Any = None,
+                         source: OptionalXMLResource = None,
+                         namespaces: OptionalNamespacesType = None,
+                         **_kwargs: Any) -> XMLSchemaValidationError:
+        """
+        Helper method for generating and updating validation errors. If validation
+        mode is 'lax' or 'skip' returns the error, otherwise raises the error.
+
+        :param validation: an error-compatible validation mode: can be 'lax' or 'strict'.
+        :param error: an error instance or the detailed reason of failed validation.
+        :param obj: the instance related to the error.
+        :param source: the XML resource related to the validation process.
+        :param namespaces: is an optional mapping from namespace prefix to URI.
+        :param _kwargs: keyword arguments of the validation process that are not used.
+        """
+        check_validation_mode(validation)
+        if isinstance(error, XMLSchemaValidationError):
+            if error.namespaces is None and namespaces is not None:
+                error.namespaces = namespaces
+            if error.source is None and source is not None:
+                error.source = source
+            if error.obj is None and obj is not None:
+                error.obj = obj
+            if error.elem is None and obj is not None and is_etree_element(obj):
+                error.elem = obj
+                if is_etree_element(error.obj) and obj.tag == error.obj.tag:
+                    error.obj = obj
+
+        elif isinstance(error, Exception):
+            error = XMLSchemaValidationError(self, obj, str(error), source, namespaces)
+        else:
+            error = XMLSchemaValidationError(self, obj, error, source, namespaces)
+
+        if validation == 'strict' and error.elem is not None:
+            raise error
+        return error
+
+    def _parse_xpath_default_namespace(self, elem: ElementType) -> str:
         """
         Parse XSD 1.1 xpathDefaultNamespace attribute for schema, alternative, assert, assertion
         and selector declarations, checking if the value is conforming to the specification. In
@@ -184,9 +241,11 @@
         if value == '##local':
             return ''
         elif value == '##defaultNamespace':
-            return getattr(self, 'default_namespace')
+            default_namespace = getattr(self, 'default_namespace', None)
+            return default_namespace if isinstance(default_namespace, str) else ''
         elif value == '##targetNamespace':
-            return getattr(self, 'target_namespace')
+            target_namespace = getattr(self, 'target_namespace', '')
+            return target_namespace if isinstance(target_namespace, str) else ''
         elif len(value.split()) == 1:
             return value
         else:
@@ -212,105 +271,124 @@
     """
     _REGEX_SPACE = re.compile(r'\s')
     _REGEX_SPACES = re.compile(r'\s+')
-    _ADMITTED_TAGS = ()
+    _ADMITTED_TAGS: UnionSetstr, Tuplestr, ..., Tuple() = ()
 
+    elem: etree_element
     parent = None
     name = None
-    ref = None
-    annotation = None
+    ref: Optional'XsdComponent' = None
     qualified = True
     redefine = None
+    _annotation = None
+    _target_namespace: Optionalstr
+
+    def __init__(self, elem: etree_element,
+                 schema: SchemaType,
+                 parent: Optional'XsdComponent' = None,
+                 name: Optionalstr = None) -> None:
 
-    def __init__(self, elem, schema, parent=None, name: Optionalstr = None):
         super(XsdComponent, self).__init__(schema.validation)
         if name:
             self.name = name
         if parent is not None:
             self.parent = parent
         self.schema = schema
-        self.maps = schema.maps
+        self.maps: XsdGlobals = schema.maps
         self.elem = elem
 
-    def __setattr__(self, name, value):
-        super(XsdComponent, self).__setattr__(name, value)
+    def __setattr__(self, name: str, value: Any) -> None:
         if name == 'elem':
             if value.tag not in self._ADMITTED_TAGS:
                 msg = "wrong XSD element {!r} for {!r}, must be one of {!r}"
                 raise XMLSchemaValueError(
                     msg.format(value.tag, self.__class__, self._ADMITTED_TAGS)
                 )
+            super(XsdComponent, self).__setattr__(name, value)
+            if self.errors:
+                self.errors.clear()
             self._parse()
+        else:
+            super(XsdComponent, self).__setattr__(name, value)
 
     @property
-    def xsd_version(self):
+    def xsd_version(self) -> str:
         return self.schema.XSD_VERSION
 
-    def is_global(self):
+    def is_global(self) -> bool:
         """Returns `True` if the instance is a global component, `False` if it's local."""
         return self.parent is None
 
-    def is_override(self):
+    def is_override(self) -> bool:
         """Returns `True` if the instance is an override of a global component."""
         if self.parent is not None:
             return False
         return any(self.elem in x for x in self.schema.root if x.tag == XSD_OVERRIDE)
 
     @property
-    def schema_elem(self):
+    def schema_elem(self) -> ElementType:
         """The reference element of the schema for the component instance."""
         return self.elem
 
     @property
-    def source(self):
+    def source(self) -> XMLResource:
         """Property that references to schema source."""
         return self.schema.source
 
     @property
-    def target_namespace(self):
+    def target_namespace(self) -> str:
         """Property that references to schema's targetNamespace."""
         return self.schema.target_namespace if self.ref is None else self.ref.target_namespace
 
     @property
-    def default_namespace(self):
+    def default_namespace(self) -> Optionalstr:
         """Property that references to schema's default namespaces."""
         return self.schema.namespaces.get('')
 
     @property
-    def namespaces(self):
+    def namespaces(self) -> NamespacesType:
         """Property that references to schema's namespace mapping."""
         return self.schema.namespaces
 
     @property
-    def any_type(self):
+    def any_type(self) -> 'XsdComplexType':
         """Property that references to the xs:anyType instance of the global maps."""
-        return self.maps.typesXSD_ANY_TYPE
+        return cast('XsdComplexType', self.maps.typesXSD_ANY_TYPE)
 
     @property
-    def any_simple_type(self):
+    def any_simple_type(self) -> 'XsdSimpleType':
         """Property that references to the xs:anySimpleType instance of the global maps."""
-        return self.maps.typesXSD_ANY_SIMPLE_TYPE
+        return cast('XsdSimpleType', self.maps.typesXSD_ANY_SIMPLE_TYPE)
 
     @property
-    def any_atomic_type(self):
+    def any_atomic_type(self) -> 'XsdSimpleType':
         """Property that references to the xs:anyAtomicType instance of the global maps."""
-        return self.maps.typesXSD_ANY_ATOMIC_TYPE
+        return cast('XsdSimpleType', self.maps.typesXSD_ANY_ATOMIC_TYPE)
+
+    @property
+    def annotation(self) -> Optional'XsdAnnotation':
+        if '_annotation' not in self.__dict__:
+            for child in self.elem:
+                if child.tag == XSD_ANNOTATION:
+                    self._annotation = XsdAnnotation(child, self.schema, self)
+                    break
+                elif not callable(child.tag):
+                    self._annotation = None
+                    break
+            else:
+                self._annotation = None
 
-    def __repr__(self):
+        return self._annotation
+
+    def __repr__(self) -> str:
         if self.ref is not None:
             return '%s(ref=%r)' % (self.__class__.__name__, self.prefixed_name)
         else:
             return '%s(name=%r)' % (self.__class__.__name__, self.prefixed_name)
 
-    def _parse(self):
-        del self.errors:
-        for child in self.elem:
-            if child.tag == XSD_ANNOTATION:
-                self.annotation = XsdAnnotation(child, self.schema, self)
-                break
-            elif not callable(child.tag):
-                break
+    def _parse(self) -> None:
+        return
 
-    def _parse_reference(self):
+    def _parse_reference(self) -> Optionalbool:
         """
         Helper method for referable components. Returns `True` if a valid reference QName
         is found without any error, otherwise returns `None`. Sets an id-related name for
@@ -320,7 +398,7 @@
         ref = self.elem.get('ref')
         if ref is None:
             if 'name' in self.elem.attrib:
-                return
+                return None
             elif self.parent is None:
                 self.parse_error("missing attribute 'name' in a global %r" % type(self))
             else:
@@ -342,7 +420,10 @@
                                      "child definitions/declarations")
                 return True
 
-    def _parse_child_component(self, elem, strict=True):
+        return None
+
+    def _parse_child_component(self, elem: ElementType, strict: bool = True) \
+            -> OptionalElementType:
         child = None
         for e in elem:
             if e.tag == XSD_ANNOTATION or callable(e.tag):
@@ -357,7 +438,7 @@
                 child = e
         return child
 
-    def _parse_target_namespace(self):
+    def _parse_target_namespace(self) -> None:
         """
         XSD 1.1 targetNamespace attribute in elements and attributes declarations.
         """
@@ -377,46 +458,56 @@
                                  "its parent schema" % self.__class__.__name__)
 
             xsd_type = self.get_parent_type()
-            if not xsd_type or xsd_type.parent is not None:
+            if xsd_type is None or xsd_type.parent is not None:
                 pass
-            elif xsd_type.derivation != 'restriction' or xsd_type.base_type.name == XSD_ANY_TYPE:
+            elif xsd_type.derivation != 'restriction' or \
+                    getattr(xsd_type.base_type, 'name', None) == XSD_ANY_TYPE:
                 self.parse_error("a declaration contained in a global complexType "
                                  "must have the same namespace as its parent schema")
 
-        if not self._target_namespace:
+        if self.name is None:
+            pass  # pragma: no cover
+        elif not self._target_namespace:
             self.name = local_name(self.name)
         else:
             self.name = '{%s}%s' % (self._target_namespace, local_name(self.name))
 
     @property
-    def local_name(self):
+    def local_name(self) -> Optionalstr:
         """The local part of the name of the component, or `None` if the name is `None`."""
-        return local_name(self.name)
+        return None if self.name is None else local_name(self.name)
 
     @property
-    def qualified_name(self):
+    def qualified_name(self) -> Optionalstr:
         """The name of the component in extended format, or `None` if the name is `None`."""
-        return get_qname(self.target_namespace, self.name)
+        return None if self.name is None else get_qname(self.target_namespace, self.name)
 
     @property
-    def prefixed_name(self):
+    def prefixed_name(self) -> Optionalstr:
         """The name of the component in prefixed format, or `None` if the name is `None`."""
-        return get_prefixed_qname(self.name, self.namespaces)
+        return None if self.name is None else get_prefixed_qname(self.name, self.namespaces)
 
     @property
-    def id(self):
+    def id(self) -> Optionalstr:
         """The ``'id'`` attribute of the component tag, ``None`` if missing."""
         return self.elem.get('id')
 
     @property
-    def validation_attempted(self):
+    def validation_attempted(self) -> str:
         return 'full' if self.built else 'partial'
 
+    def build(self) -> None:
+        """
+        Builds components that are not fully parsed at initialization, like model groups
+        or internal local elements in model groups. Otherwise does nothing.
+        """
+
     @property
-    def built(self):
+    def built(self) -> bool:
         raise NotImplementedError()
 
-    def is_matching(self, name, default_namespace=None, **kwargs):
+    def is_matching(self, name: Optionalstr, default_namespace: Optionalstr = None,
+                    **kwargs: Any) -> bool:
         """
         Returns `True` if the component name is matching the name provided as argument,
         `False` otherwise. For XSD elements the matching is extended to substitutes.
@@ -436,25 +527,28 @@
             qname = '{%s}%s' % (default_namespace, name)
             return self.qualified_name == qname or not self.qualified and self.local_name == name
 
-    def match(self, name, default_namespace=None, **kwargs):
+    def match(self, name: Optionalstr, default_namespace: Optionalstr = None,
+              **kwargs: Any) -> Optional'XsdComponent':
         """
         Returns the component if its name is matching the name provided as argument,
         `None` otherwise.
         """
         return self if self.is_matching(name, default_namespace, **kwargs) else None
 
-    def get_matching_item(self, mapping, ns_prefix='xmlns', match_local_name=False):
+    def get_matching_item(self, mapping: MutableMappingstr, Any,
+                          ns_prefix: str = 'xmlns',
+                          match_local_name: bool = False) -> OptionalAny:
         """
         If a key is matching component name, returns its value, otherwise returns `None`.
         """
         if self.name is None:
-            return
+            return None
         elif not self.target_namespace:
             return mapping.get(self.name)
         elif self.qualified_name in mapping:
-            return mappingself.qualified_name
+            return mappingcast(str, self.qualified_name)
         elif self.prefixed_name in mapping:
-            return mappingself.prefixed_name
+            return mappingcast(str, self.prefixed_name)
 
         # Try a match with other prefixes
         target_namespace = self.target_namespace
@@ -474,9 +568,10 @@
                 pass
         else:
             if match_local_name:
-                return mapping.get(self.local_name)
+                return mapping.get(self.local_name)  # type: ignorearg-type
+            return None
 
-    def get_global(self):
+    def get_global(self) -> 'XsdComponent':
         """Returns the global XSD component that contains the component instance."""
         if self.parent is None:
             return self
@@ -485,8 +580,10 @@
             if component.parent is None:
                 return component
             component = component.parent
+        else:
+            raise XMLSchemaValueError(f"parent circularity from {self}")  # pragma: no cover
 
-    def get_parent_type(self):
+    def get_parent_type(self) -> Optional'XsdType':
         """
         Returns the nearest XSD type that contains the component instance,
         or `None` if the component doesn't have an XSD type parent.
@@ -496,8 +593,10 @@
             if isinstance(component, XsdType):
                 return component
             component = component.parent
+        return None
 
-    def iter_components(self, xsd_classes=None):
+    def iter_components(self, xsd_classes: ComponentClassType = None) \
+            -> Iterator'XsdComponent':
         """
         Creates an iterator for XSD subcomponents.
 
@@ -507,7 +606,8 @@
         if xsd_classes is None or isinstance(self, xsd_classes):
             yield self
 
-    def iter_ancestors(self, xsd_classes=None):
+    def iter_ancestors(self, xsd_classes: ComponentClassType = None)\
+            -> Iterator'XsdComponent':
         """
         Creates an iterator for XSD ancestor components, schema excluded. Stops when the component
         is global or if the ancestor is not an instance of the specified class/classes.
@@ -517,12 +617,15 @@
         """
         ancestor = self
         while True:
+            if ancestor.parent is None:
+                break
             ancestor = ancestor.parent
-            if ancestor is None or xsd_classes and not isinstance(ancestor, xsd_classes):
+            if xsd_classes is not None and not isinstance(ancestor, xsd_classes):
                 break
             yield ancestor
 
-    def tostring(self, indent='', max_lines=None, spaces_for_tab=4):
+    def tostring(self, indent: str = '', max_lines: Optionalint = None,
+                 spaces_for_tab: int = 4) -> Unionstr, bytes:
         """Serializes the XML elements that declare or define the component to a string."""
         return etree_tostring(self.schema_elem, self.namespaces, indent, max_lines, spaces_for_tab)
 
@@ -555,12 +658,19 @@
     """
     _ADMITTED_TAGS = {XSD_ANNOTATION}
 
+    annotation = None
+
+    def __repr__(self) -> str:
+        return '%s(%r)' % (self.__class__.__name__, str(self):40)
+
+    def __str__(self) -> str:
+        return '\n'.join(elementpath.select(self.elem, '*/fn:string()'))
+
     @property
-    def built(self):
+    def built(self) -> bool:
         return True
 
-    def _parse(self):
-        del self.errors:
+    def _parse(self) -> None:
         self.appinfo = 
         self.documentation = 
         for child in self.elem:
@@ -580,52 +690,56 @@
     """Common base class for XSD types."""
 
     abstract = False
-    block = None
-    base_type = None
-    derivation = None
-    _final = None
+    base_type: OptionalBaseXsdType = None
+    derivation: Optionalstr = None
+    _final: Optionalstr = None
 
     @property
-    def final(self):
+    def final(self) -> str:
         return self.schema.final_default if self._final is None else self._final
 
     @property
-    def built(self):
+    def built(self) -> bool:
         raise NotImplementedError()
 
     @property
-    def content_type_label(self):
+    def content_type_label(self) -> str:
         """The content type classification."""
         raise NotImplementedError()
 
     @property
-    def sequence_type(self):
+    def sequence_type(self) -> str:
         """The XPath sequence type associated with the content."""
         raise NotImplementedError()
 
     @property
-    def root_type(self):
+    def root_type(self) -> BaseXsdType:
         """
         The root type of the type definition hierarchy. For an atomic type
         is the primitive type. For a list is the primitive type of the item.
         For a union is the base union type. For a complex type is xs:anyType.
         """
-        if self.is_complex() and self.attributes:
-            return self.maps.typesXSD_ANY_TYPE
+        if getattr(self, 'attributes', None):
+            return cast('XsdComplexType', self.maps.typesXSD_ANY_TYPE)
         elif self.base_type is None:
-            return self if self.is_simple() else self.maps.typesXSD_ANY_TYPE
+            if self.is_simple():
+                return cast('XsdSimpleType', self)
+            return cast('XsdComplexType', self.maps.typesXSD_ANY_TYPE)
 
+        primitive_type: BaseXsdType
         try:
             if self.base_type.is_simple():
-                return self.base_type.primitive_type
+                primitive_type = self.base_type.primitive_type  # type: ignoreunion-attr
             else:
-                return self.base_type.content.primitive_type
+                primitive_type = self.base_type.content.primitive_type  # type: ignoreunion-attr
         except AttributeError:
             # The type has complex or XsdList content
             return self.base_type.root_type
+        else:
+            return primitive_type
 
     @property
-    def simple_type(self):
+    def simple_type(self) -> Optional'XsdSimpleType':
         """
         Property that is the instance itself for a simpleType. For a
         complexType is the instance's *content* if this is a simpleType
@@ -634,90 +748,91 @@
         raise NotImplementedError()
 
     @property
-    def model_group(self):
+    def model_group(self) -> Optional'XsdGroup':
         """
         Property that is `None` for a simpleType. For a complexType is
         the instance's *content* if this is a model group or `None` if
         the instance's *content* is a simpleType.
         """
-        raise NotImplementedError()
+        return None
 
     @staticmethod
-    def is_simple():
+    def is_simple() -> bool:
         """Returns `True` if the instance is a simpleType, `False` otherwise."""
         raise NotImplementedError()
 
     @staticmethod
-    def is_complex():
+    def is_complex() -> bool:
         """Returns `True` if the instance is a complexType, `False` otherwise."""
-        raise NotImplementedError()
 
-    @staticmethod
-    def is_atomic():
+    def is_atomic(self) -> bool:
         """Returns `True` if the instance is an atomic simpleType, `False` otherwise."""
         return False
 
-    @staticmethod
-    def is_list():
+    def is_list(self) -> bool:
         """Returns `True` if the instance is a list simpleType, `False` otherwise."""
         return False
 
-    @staticmethod
-    def is_union():
+    def is_union(self) -> bool:
         """Returns `True` if the instance is a union simpleType, `False` otherwise."""
         return False
 
-    @staticmethod
-    def is_datetime():
+    def is_datetime(self) -> bool:
         """
         Returns `True` if the instance is a datetime/duration XSD builtin-type, `False` otherwise.
         """
         return False
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         """Returns `True` if the instance has an empty content, `False` otherwise."""
         raise NotImplementedError()
 
-    def is_emptiable(self):
+    def is_emptiable(self) -> bool:
         """Returns `True` if the instance has an emptiable value or content, `False` otherwise."""
         raise NotImplementedError()
 
-    def has_simple_content(self):
+    def has_simple_content(self) -> bool:
         """
         Returns `True` if the instance has a simple content, `False` otherwise.
         """
         raise NotImplementedError()
 
-    def has_complex_content(self):
+    def has_complex_content(self) -> bool:
         """
         Returns `True` if the instance is a complexType with mixed or element-only
         content, `False` otherwise.
         """
         raise NotImplementedError()
 
-    def has_mixed_content(self):
+    def has_mixed_content(self) -> bool:
         """
         Returns `True` if the instance is a complexType with mixed content, `False` otherwise.
         """
         raise NotImplementedError()
 
-    def is_element_only(self):
+    def is_element_only(self) -> bool:
         """
         Returns `True` if the instance is a complexType with element-only content,
         `False` otherwise.
         """
         raise NotImplementedError()
 
-    def is_derived(self, other, derivation=None):
+    def is_derived(self, other: UnionBaseXsdType, TupleElementType, SchemaType,
+                   derivation: Optionalstr = None) -> bool:
+        """
+        Returns `True` if the instance is derived from *other*, `False` otherwise.
+        The optional argument derivation can be a string containing the words
+        'extension' or 'restriction' or both.
+        """
         raise NotImplementedError()
 
-    def is_extension(self):
+    def is_extension(self) -> bool:
         return self.derivation == 'extension'
 
-    def is_restriction(self):
+    def is_restriction(self) -> bool:
         return self.derivation == 'restriction'
 
-    def is_blocked(self, xsd_element):
+    def is_blocked(self, xsd_element: 'XsdElement') -> bool:
         """
         Returns `True` if the base type derivation is blocked, `False` otherwise.
         """
@@ -728,91 +843,108 @@
         block = ('%s %s' % (xsd_element.block, xsd_type.block)).strip()
         if not block:
             return False
-        block = {x for x in block.split() if x in ('extension', 'restriction')}
 
-        return any(self.is_derived(xsd_type, derivation) for derivation in block)
+        _block = {x for x in block.split() if x in ('extension', 'restriction')}
+        return any(self.is_derived(xsd_type, derivation) for derivation in _block)
 
-    def is_dynamic_consistent(self, other):
+    def is_dynamic_consistent(self, other: Any) -> bool:
         return other.name == XSD_ANY_TYPE or self.is_derived(other) or \
             hasattr(other, 'member_types') and \
             any(self.is_derived(mt) for mt in other.member_types)  # pragma: no cover
 
-    def is_key(self):
+    def is_key(self) -> bool:
         return self.name == XSD_ID or self.is_derived(self.maps.typesXSD_ID)
 
-    def is_qname(self):
+    def is_qname(self) -> bool:
         return self.name == XSD_QNAME or self.is_derived(self.maps.typesXSD_QNAME)
 
-    def is_notation(self):
+    def is_notation(self) -> bool:
         return self.name == XSD_NOTATION_TYPE or self.is_derived(self.maps.typesXSD_NOTATION_TYPE)
 
-    def is_decimal(self):
+    def is_decimal(self) -> bool:
         return self.name == XSD_DECIMAL or self.is_derived(self.maps.typesXSD_DECIMAL)
 
-    def text_decode(self, text):
+    def text_decode(self, text: str) -> Any:
         raise NotImplementedError()
 
 
-class ValidationMixin:
+ST = TypeVar('ST')
+DT = TypeVar('DT')
+
+
+class ValidationMixin(GenericST, DT):
     """
-    Mixin for implementing XML data validators/decoders. A derived class must implement the
-    methods `iter_decode` and `iter_encode`.
+    Mixin for implementing XML data validators/decoders on XSD components.
+    A derived class must implement the methods `iter_decode` and `iter_encode`.
     """
-    def validate(self, source, use_defaults=True, namespaces=None):
+    def validate(self, obj: ST,
+                 use_defaults: bool = True,
+                 namespaces: OptionalNamespacesType = None,
+                 max_depth: Optionalint = None,
+                 extra_validator: OptionalExtraValidatorType = None) -> None:
         """
-        Validates an XML data against the XSD schema/component instance.
+        Validates XML data against the XSD schema/component instance.
 
-        :param source: the source of XML data. For a schema can be a path \
-        to a file or an URI of a resource or an opened file-like object or an Element Tree \
-        instance or a string containing XML data. For other XSD components can be a string \
-        for an attribute or a simple type validators, or an ElementTree's Element otherwise.
+        :param obj: the XML data. Can be a string for an attribute or a simple type \
+        validators, or an ElementTree's Element otherwise.
         :param use_defaults: indicates whether to use default values for filling missing data.
         :param namespaces: is an optional mapping from namespace prefix to URI.
-        :raises: :exc:`XMLSchemaValidationError` if XML *data* instance is not valid.
-        """
-        for error in self.iter_errors(source, use_defaults=use_defaults, namespaces=namespaces):
+        :param max_depth: maximum level of validation, for default there is no limit.
+        :param extra_validator: an optional function for performing non-standard \
+        validations on XML data. The provided function is called for each traversed \
+        element, with the XML element as 1st argument and the corresponding XSD \
+        element as 2nd argument. It can be also a generator function and has to \
+        raise/yield :exc:`XMLSchemaValidationError` exceptions.
+        :raises: :exc:`XMLSchemaValidationError` if the XML data instance is invalid.
+        """
+        for error in self.iter_errors(obj, use_defaults, namespaces,
+                                      max_depth, extra_validator):
             raise error
 
-    def is_valid(self, source, use_defaults=True, namespaces=None):
-        """
-        Like :meth:`validate` except that does not raise an exception but returns ``True`` if
-        the XML document is valid, ``False`` if it's invalid.
-
-        :param source: the source of XML data. For a schema can be a path \
-        to a file or an URI of a resource or an opened file-like object or an Element Tree \
-        instance or a string containing XML data. For other XSD components can be a string \
-        for an attribute or a simple type validators, or an ElementTree's Element otherwise.
-        :param use_defaults: indicates whether to use default values for filling missing data.
-        :param namespaces: is an optional mapping from namespace prefix to URI.
-        """
-        return next(
-            self.iter_errors(source, use_defaults=use_defaults, namespaces=namespaces), None
-        ) is None
-
-    def iter_errors(self, source, use_defaults=True, namespaces=None):
-        """
-        Creates an iterator for the errors generated by the validation of an XML data
-        against the XSD schema/component instance.
-
-        :param source: the source of XML data. For a schema can be a path \
-        to a file or an URI of a resource or an opened file-like object or an Element Tree \
-        instance or a string containing XML data. For other XSD components can be a string \
-        for an attribute or a simple type validators, or an ElementTree's Element otherwise.
-        :param use_defaults: Use schema's default values for filling missing data.
-        :param namespaces: is an optional mapping from namespace prefix to URI.
-        """
-        for result in self.iter_decode(source, use_defaults=use_defaults, namespaces=namespaces):
+    def is_valid(self, obj: ST,
+                 use_defaults: bool = True,
+                 namespaces: OptionalNamespacesType = None,
+                 max_depth: Optionalint = None,
+                 extra_validator: OptionalExtraValidatorType = None) -> bool:
+        """
+        Like :meth:`validate` except that does not raise an exception but returns
+        ``True`` if the XML data instance is valid, ``False`` if it is invalid.
+        """
+        error = next(self.iter_errors(obj, use_defaults, namespaces,
+                                      max_depth, extra_validator), None)
+        return error is None
+
+    def iter_errors(self, obj: ST,
+                    use_defaults: bool = True,
+                    namespaces: OptionalNamespacesType = None,
+                    max_depth: Optionalint = None,
+                    extra_validator: OptionalExtraValidatorType = None) \
+            -> IteratorXMLSchemaValidationError:
+        """
+        Creates an iterator for the errors generated by the validation of an XML data against
+        the XSD schema/component instance. Accepts the same arguments of :meth:`validate`.
+        """
+        kwargs: Dictstr, Any = {
+            'use_defaults': use_defaults,
+            'namespaces': namespaces,
+        }
+        if max_depth is not None:
+            kwargs'max_depth' = max_depth
+        if extra_validator is not None:
+            kwargs'extra_validator' = extra_validator
+
+        for result in self.iter_decode(obj, **kwargs):
             if isinstance(result, XMLSchemaValidationError):
                 yield result
             else:
                 del result
 
-    def decode(self, source, validation='strict', **kwargs):
+    def decode(self, obj: ST, validation: str = 'strict', **kwargs: Any) -> DecodeTypeDT:
         """
         Decodes XML data.
 
-        :param source: the XML data. Can be a string for an attribute or for a simple \
-        type components or a dictionary for an attribute group or an ElementTree's \
+        :param obj: the XML data. Can be a string for an attribute or for simple type \
+        components or a dictionary for an attribute group or an ElementTree's \
         Element for other components.
         :param validation: the validation mode. Can be 'lax', 'strict' or 'skip.
         :param kwargs: optional keyword arguments for the method :func:`iter_decode`.
@@ -826,36 +958,19 @@
         """
         check_validation_mode(validation)
 
-        result, errors = None, 
-        for result in self.iter_decode(source, validation, **kwargs):  # pragma: no cover
+        result: UnionDT, XMLSchemaValidationError
+        errors: ListXMLSchemaValidationError = 
+        for result in self.iter_decode(obj, validation, **kwargs):  # pragma: no cover
             if not isinstance(result, XMLSchemaValidationError):
-                break
+                return (result, errors) if validation == 'lax' else result
             elif validation == 'strict':
                 raise result
             else:
                 errors.append(result)
 
-        return (result, errors) if validation == 'lax' else result
-
-    def to_objects(self, source, with_bindings=False, **kwargs):
-        """
-        Decodes XML data to Python data objects.
+        return (None, errors) if validation == 'lax' else None  # fallback: pragma: no cover
 
-        :param source: the XML data. Can be a string for an attribute or for a simple \
-        type components or a dictionary for an attribute group or an ElementTree's \
-        Element for other components.
-        :param with_bindings: if `True` is provided the decoding is done using \
-        :class:`DataBindingConverter` that used XML data binding classes. For \
-        default the objects are intances of :class:`DataElement` and uses the \
-        :class:`DataElementConverter`.
-        :param kwargs: other optional keyword arguments for the method \
-        :func:`iter_decode`, except the argument *converter*.
-        """
-        if with_bindings:
-            return self.decode(source, converter=dataobjects.DataBindingConverter, **kwargs)
-        return self.decode(source, converter=dataobjects.DataElementConverter, **kwargs)
-
-    def encode(self, obj, validation='strict', **kwargs):
+    def encode(self, obj: Any, validation: str = 'strict', **kwargs: Any) -> EncodeTypeAny:
         """
         Encodes data to XML.
 
@@ -881,11 +996,12 @@
 
         return (result, errors) if validation == 'lax' else result
 
-    def iter_decode(self, source, validation='lax', **kwargs):
+    def iter_decode(self, obj: ST, validation: str = 'lax', **kwargs: Any) \
+            -> IterDecodeTypeDT:
         """
         Creates an iterator for decoding an XML source to a Python object.
 
-        :param source: the XML data source.
+        :param obj: the XML data.
         :param validation: the validation mode. Can be 'lax', 'strict' or 'skip.
         :param kwargs: keyword arguments for the decoder API.
         :return: Yields a decoded object, eventually preceded by a sequence of \
@@ -893,7 +1009,8 @@
         """
         raise NotImplementedError()
 
-    def iter_encode(self, obj, validation='lax', **kwargs):
+    def iter_encode(self, obj: Any, validation: str = 'lax', **kwargs: Any) \
+            -> IterEncodeTypeAny:
         """
         Creates an iterator for encoding data to an Element tree.
 
@@ -904,35 +1021,3 @@
         or encoding errors.
         """
         raise NotImplementedError()
-
-    def validation_error(self, validation, error, obj=None,
-                         source=None, namespaces=None, **_kwargs):
-        """
-        Helper method for generating and updating validation errors. If validation
-        mode is 'lax' or 'skip' returns the error, otherwise raises the error.
-
-        :param validation: an error-compatible validation mode: can be 'lax' or 'strict'.
-        :param error: an error instance or the detailed reason of failed validation.
-        :param obj: the instance related to the error.
-        :param source: the XML resource related to the validation process.
-        :param namespaces: is an optional mapping from namespace prefix to URI.
-        :param _kwargs: keyword arguments of the validation process that are not used.
-        """
-        check_validation_mode(validation)
-        if isinstance(error, XMLSchemaValidationError):
-            if error.namespaces is None and namespaces is not None:
-                error.namespaces = namespaces
-            if error.source is None and source is not None:
-                error.source = source
-            if error.obj is None and obj is not None:
-                error.obj = obj
-            if error.elem is None and is_etree_element(obj):
-                error.elem = obj
-        elif isinstance(error, Exception):
-            error = XMLSchemaValidationError(self, obj, str(error), source, namespaces)
-        else:
-            error = XMLSchemaValidationError(self, obj, error, source, namespaces)
-
-        if validation == 'strict' and error.elem is not None:
-            raise error
-        return error

_service:tar_scm:xmlschema-1.5.2.tar.gz/xmlschema/xpath.py -> _service:tar_scm:xmlschema-1.9.2.tar.gz/xmlschema/xpath.py Changed

@@ -10,35 +10,78 @@
 """
 This module defines a proxy class and a mixin class for enabling XPath on schemas.
 """
+import sys
 from abc import abstractmethod
-from collections.abc import Sequence
+from typing import cast, overload, Any, Dict, Iterator, List, Optional, \
+    Sequence, Set, TypeVar, Union
 import re
-import threading
 
 from elementpath import AttributeNode, TypedElement, XPath2Parser, \
-    XPathSchemaContext, AbstractSchemaProxy
+    XPathSchemaContext, AbstractSchemaProxy, protocols
 
-from .names import XSD_NAMESPACE
 from .exceptions import XMLSchemaValueError, XMLSchemaTypeError
+from .names import XSD_NAMESPACE
+from .aliases import NamespacesType, SchemaType, BaseXsdType, XPathElementType
+from .helpers import get_qname, local_name, get_prefixed_qname
+
+if sys.version_info < (3, 8):
+    XMLSchemaProtocol = SchemaType
+    ElementProtocol = XPathElementType
+    XsdTypeProtocol = BaseXsdType
+else:
+    from typing import runtime_checkable, Protocol
+
+    XsdTypeProtocol = protocols.XsdTypeProtocol
+
+    class XMLSchemaProtocol(protocols.XMLSchemaProtocol, Protocol):
+        attributes: Dictstr, Any
+
+    @runtime_checkable
+    class ElementProtocol(protocols.ElementProtocol, Protocol):
+        schema: XMLSchemaProtocol
+        attributes: Dictstr, Any
+
 
 _REGEX_TAG_POSITION = re.compile(r'\b\\d+')
 
 
-def iter_schema_nodes(root, with_root=True, with_attributes=False):
+def iter_schema_nodes(root: UnionXMLSchemaProtocol, ElementProtocol,
+                      with_root: bool = True,
+                      with_attributes: bool = False) \
+        -> IteratorUnionXMLSchemaProtocol, ElementProtocol, AttributeNode:
     """
     Iteration function for schema nodes. It doesn't yield text nodes,
     that are always `None` for schema elements, and detects visited
     element in order to skip already visited nodes.
 
-    :param root: schema or schema's element.
+    :param root: schema or schema element.
     :param with_root: if `True` yields initial element.
     :param with_attributes: if `True` yields also attribute nodes.
     """
-    def attribute_node(x):
+    def attribute_node(x: Any) -> AttributeNode:
         return AttributeNode(*x)
 
-    def _iter_schema_nodes(elem):
-        for child in elem:
+    if isinstance(root, TypedElement):
+        root = cast(ElementProtocol, root.elem)
+
+    nodes = {root}
+    if with_root:
+        yield root
+    if with_attributes:
+        yield from map(attribute_node, root.attributes.items())
+
+    iterators: ListAny = 
+    children: IteratorAny = iter(root)
+
+    while True:
+        try:
+            child = next(children)
+        except StopIteration:
+            try:
+                children = iterators.pop()
+            except IndexError:
+                return
+        else:
             if child in nodes:
                 continue
             elif child.ref is not None:
@@ -49,23 +92,15 @@
                     yield child.ref
                     if with_attributes:
                         yield from map(attribute_node, child.attributes.items())
-                    yield from _iter_schema_nodes(child.ref)
+                    iterators.append(children)
+                    children = iter(child.ref)
             else:
                 nodes.add(child)
                 yield child
                 if with_attributes:
                     yield from map(attribute_node, child.attributes.items())
-                yield from _iter_schema_nodes(child)
-
-    if isinstance(root, TypedElement):
-        root = root.elem
-
-    nodes = {root}
-    if with_root:
-        yield root
-    if with_attributes:
-        yield from map(attribute_node, root.attributes.items())
-    yield from _iter_schema_nodes(root)
+                iterators.append(children)
+                children = iter(child)
 
 
 class XMLSchemaContext(XPathSchemaContext):
@@ -75,10 +110,15 @@
 
 class XMLSchemaProxy(AbstractSchemaProxy):
     """XPath schema proxy for the *xmlschema* library."""
-    def __init__(self, schema=None, base_element=None):
+    _schema: SchemaType  # type: ignoreassignment
+
+    def __init__(self, schema: OptionalXMLSchemaProtocol = None,
+                 base_element: OptionalElementProtocol = None) -> None:
+
         if schema is None:
-            from xmlschema import XMLSchema
-            schema = XMLSchema.meta_schema
+            from xmlschema import XMLSchema10
+            schema = cast(XMLSchemaProtocol, getattr(XMLSchema10, 'meta_schema', None))
+
         super(XMLSchemaProxy, self).__init__(schema, base_element)
 
         if base_element is not None:
@@ -88,60 +128,33 @@
             except AttributeError:
                 raise XMLSchemaTypeError("%r is not an XsdElement" % base_element)
 
-    @property
-    def xsd_version(self):
-        return self._schema.XSD_VERSION
-
-    def bind_parser(self, parser):
-        if parser.schema is not self:
-            parser.schema = self
-
-        if self._schema.xpath_tokens is None:
-            parser.symbol_table = parser.__class__.symbol_table.copy()
-            for xsd_type in self.iter_atomic_types():
-                parser.schema_constructor(xsd_type.name)
-            self._schema.xpath_tokens = parser.symbol_table
-        else:
-            parser.symbol_table = self._schema.xpath_tokens
-        parser.tokenizer = parser.create_tokenizer(parser.symbol_table)
+    def bind_parser(self, parser: XPath2Parser) -> None:
+        parser.schema = self
+        parser.symbol_table = dict(parser.__class__.symbol_table)
+
+        with self._schema.lock:
+            if self._schema.xpath_tokens is None:
+                self._schema.xpath_tokens = {
+                    xsd_type.name: parser.schema_constructor(xsd_type.name)
+                    for xsd_type in self.iter_atomic_types() if xsd_type.name
+                }
 
-    def get_context(self):
+        parser.symbol_table.update(self._schema.xpath_tokens)
+
+    def get_context(self) -> XMLSchemaContext:
         return XMLSchemaContext(
-            root=self._schema,
-            namespaces=self._schema.namespaces,
+            root=self._schema,  # type: ignorearg-type
+            namespaces=dict(self._schema.namespaces),
             item=self._base_element
         )
 
-    def get_type(self, qname):
-        try:
-            return self._schema.maps.typesqname
-        except KeyError:
-            return None
-
-    def get_attribute(self, qname):
-        try:
-            return self._schema.maps.attributesqname
-        except KeyError:
-            return None
-
-    def get_element(self, qname):
-        try:
-            return self._schema.maps.elementsqname
-        except KeyError:
-            return None
-
-    def get_substitution_group(self, qname):
-        try:
-            return self._schema.maps.substitution_groupsqname
-        except KeyError:
-            return None
-
-    def find(self, path, namespaces=None):
-        return self._schema.find(path, namespaces)
-
-    def is_instance(self, obj, type_qname):
+    def is_instance(self, obj: Any, type_qname: str) -> bool:
         # FIXME: use elementpath.datatypes for checking atomic datatypes
         xsd_type = self._schema.maps.typestype_qname
+        if isinstance(xsd_type, tuple):
+            from .validators import XMLSchemaNotBuiltError
+            raise XMLSchemaNotBuiltError(xsd_type1, f"XSD type {type_qname} is not built")
+
         try:
             xsd_type.encode(obj)
         except ValueError:
@@ -149,84 +162,85 @@
         else:
             return True
 
-    def cast_as(self, obj, type_qname):
+    def cast_as(self, obj: Any, type_qname: str) -> Any:
         xsd_type = self._schema.maps.typestype_qname
+        if isinstance(xsd_type, tuple):
+            from .validators import XMLSchemaNotBuiltError
+            raise XMLSchemaNotBuiltError(xsd_type1, f"XSD type {type_qname} is not built")
         return xsd_type.decode(obj)
 
-    def iter_atomic_types(self):
+    def iter_atomic_types(self) -> IteratorXsdTypeProtocol:
         for xsd_type in self._schema.maps.types.values():
-            if xsd_type.target_namespace != XSD_NAMESPACE and hasattr(xsd_type, 'primitive_type'):
-                yield xsd_type
+            if not isinstance(xsd_type, tuple) and \
+                    xsd_type.target_namespace != XSD_NAMESPACE and \
+                    hasattr(xsd_type, 'primitive_type'):
+                yield cast(XsdTypeProtocol, xsd_type)
+
+    def get_primitive_type(self, xsd_type: XsdTypeProtocol) -> XsdTypeProtocol:
+        primitive_type = cast(BaseXsdType, xsd_type).root_type
+        return cast(XsdTypeProtocol, primitive_type)
+
 
-    def get_primitive_type(self, xsd_type):
-        return xsd_type.root_type
+E = TypeVar('E', bound='ElementPathMixinAny')
 
 
-class ElementPathMixin(Sequence):
+class ElementPathMixin(SequenceE):
     """
-    Mixin abstract class for enabling ElementTree and XPath API on XSD components.
+    Mixin abstract class for enabling ElementTree and XPath 2.0 API on XSD components.
 
     :cvar text: the Element text, for compatibility with the ElementTree API.
     :cvar tail: the Element tail, for compatibility with the ElementTree API.
     """
-    text = None
-    tail = None
-    attributes = {}
-    namespaces = {}
+    text: Optionalstr = None
+    tail: Optionalstr = None
+    name: Optionalstr = None
+    attributes: Any = {}
+    namespaces: Any = {}
     xpath_default_namespace = ''
 
-    _xpath_parser = None  # Internal XPath 2.0 parser, instantiated at first use.
-
-    def __init__(self):
-        self._xpath_lock = threading.Lock()  # Lock for XPath operations
-
-    def __getstate__(self):
-        state = self.__dict__.copy()
-        state.pop('_xpath_lock', None)
-        state.pop('_xpath_parser', None)
-        state.pop('xpath_tokens', None)  # For schema objects
-        return state
-
-    def __setstate__(self, state):
-        self.__dict__.update(state)
-        self._xpath_lock = threading.Lock()
-
     @abstractmethod
-    def __iter__(self):
+    def __iter__(self) -> IteratorE:
         raise NotImplementedError
 
-    def __getitem__(self, i):
+    @overload
+    def __getitem__(self, i: int) -> E: ...
+
+    @overload
+    def __getitem__(self, s: slice) -> SequenceE: ...
+
+    def __getitem__(self, i: Unionint, slice) -> UnionE, SequenceE:
         try:
             return e for e in selfi
         except IndexError:
             raise IndexError('child index out of range')
 
-    def __reversed__(self):
+    def __reversed__(self) -> IteratorE:
         return reversed(e for e in self)
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(e for e in self)
 
     @property
-    def tag(self):
+    def tag(self) -> str:
         """Alias of the *name* attribute. For compatibility with the ElementTree API."""
-        return getattr(self, 'name')
+        return self.name or ''
 
     @property
-    def attrib(self):
+    def attrib(self) -> Any:
         """Returns the Element attributes. For compatibility with the ElementTree API."""
         return self.attributes
 
-    def get(self, key, default=None):
+    def get(self, key: str, default: Any = None) -> Any:
         """Gets an Element attribute. For compatibility with the ElementTree API."""
         return self.attributes.get(key, default)
 
     @property
-    def xpath_proxy(self):
+    def xpath_proxy(self) -> XMLSchemaProxy:
         """Returns an XPath proxy instance bound with the schema."""
         raise NotImplementedError
 
-    def _get_xpath_namespaces(self, namespaces=None):
+    def _get_xpath_namespaces(self, namespaces: OptionalNamespacesType = None) \
+            -> Dictstr, str:
         """
         Returns a dictionary with namespaces for XPath selection.
 
@@ -239,24 +253,17 @@
         elif '' not in namespaces:
             namespaces'' = self.xpath_default_namespace
 
-        xpath_namespaces = XPath2Parser.DEFAULT_NAMESPACES.copy()
+        xpath_namespaces: Dictstr, str = XPath2Parser.DEFAULT_NAMESPACES.copy()
         xpath_namespaces.update(namespaces)
         return xpath_namespaces
 
-    def _xpath_parse(self, path, namespaces=None):
-        path = _REGEX_TAG_POSITION.sub('', path.strip())  # Strips tags positions from path
-
-        namespaces = self._get_xpath_namespaces(namespaces)
-        with self._xpath_lock:
-            parser = self._xpath_parser
-            if parser is None:
-                parser = XPath2Parser(namespaces, strict=False, schema=self.xpath_proxy)
-                self._xpath_parser = parser
-            else:
-                parser.namespaces = namespaces
-            return parser.parse(path)
+    def is_matching(self, name: Optionalstr, default_namespace: Optionalstr = None) -> bool:
+        if not name or name0 == '{' or not default_namespace:
+            return self.name == name
+        else:
+            return self.name == '{%s}%s' % (default_namespace, name)
 
-    def find(self, path, namespaces=None):
+    def find(self, path: str, namespaces: OptionalNamespacesType = None) -> OptionalE:
         """
         Finds the first XSD subelement matching the path.
 
@@ -264,10 +271,14 @@
         :param namespaces: an optional mapping from namespace prefix to namespace URI.
         :return: the first matching XSD subelement or ``None`` if there is no match.
         """
-        context = XMLSchemaContext(self)
-        return next(self._xpath_parse(path, namespaces).select_results(context), None)
+        path = _REGEX_TAG_POSITION.sub('', path.strip())  # Strips tags positions from path
+        namespaces = self._get_xpath_namespaces(namespaces)
+        parser = XPath2Parser(namespaces, strict=False)
+        context = XMLSchemaContext(self)  # type: ignorearg-type
 
-    def findall(self, path, namespaces=None):
+        return cast(OptionalE, next(parser.parse(path).select_results(context), None))
+
+    def findall(self, path: str, namespaces: OptionalNamespacesType = None) -> ListE:
         """
         Finds all XSD subelements matching the path.
 
@@ -276,10 +287,14 @@
         :return: a list containing all matching XSD subelements in document order, an empty \
         list is returned if there is no match.
         """
-        context = XMLSchemaContext(self)
-        return self._xpath_parse(path, namespaces).get_results(context)
+        path = _REGEX_TAG_POSITION.sub('', path.strip())  # Strips tags positions from path
+        namespaces = self._get_xpath_namespaces(namespaces)
+        parser = XPath2Parser(namespaces, strict=False)
+        context = XMLSchemaContext(self)  # type: ignorearg-type
 
-    def iterfind(self, path, namespaces=None):
+        return cast(ListE, parser.parse(path).get_results(context))
+
+    def iterfind(self, path: str, namespaces: OptionalNamespacesType = None) -> IteratorE:
         """
         Creates and iterator for all XSD subelements matching the path.
 
@@ -287,17 +302,21 @@
         :param namespaces: is an optional mapping from namespace prefix to full name.
         :return: an iterable yielding all matching XSD subelements in document order.
         """
-        context = XMLSchemaContext(self)
-        return self._xpath_parse(path, namespaces).select_results(context)
+        path = _REGEX_TAG_POSITION.sub('', path.strip())  # Strips tags positions from path
+        namespaces = self._get_xpath_namespaces(namespaces)
+        parser = XPath2Parser(namespaces, strict=False)
+        context = XMLSchemaContext(self)  # type: ignorearg-type
+
+        return cast(IteratorE, parser.parse(path).select_results(context))
 
-    def iter(self, tag=None):
+    def iter(self, tag: Optionalstr = None) -> IteratorE:
         """
         Creates an iterator for the XSD element and its subelements. If tag is not `None` or '*',
         only XSD elements whose matches tag are returned from the iterator. Local elements are
         expanded without repetitions. Element references are not expanded because the global
         elements are not descendants of other elements.
         """
-        def safe_iter(elem):
+        def safe_iter(elem: Any) -> IteratorE:
             if tag is None or elem.is_matching(tag):
                 yield elem
             for child in elem:
@@ -312,10 +331,10 @@
 
         if tag == '*':
             tag = None
-        local_elements = set()
+        local_elements: SetE = set()
         return safe_iter(self)
 
-    def iterchildren(self, tag=None):
+    def iterchildren(self, tag: Optionalstr = None) -> IteratorE:
         """
         Creates an iterator for the child elements of the XSD component. If *tag* is not `None`
         or '*', only XSD elements whose name matches tag are returned from the iterator.
@@ -325,3 +344,49 @@
         for child in self:
             if tag is None or child.is_matching(tag):
                 yield child
+
+
+class XPathElement(ElementPathMixin'XPathElement'):
+    """An element node for making XPath operations on schema types."""
+    name: str
+    parent = None
+
+    def __init__(self, name: str, xsd_type: BaseXsdType) -> None:
+        self.name = name
+        self.type = xsd_type
+        self.attributes = getattr(xsd_type, 'attributes', {})
+
+    def __iter__(self) -> Iterator'XPathElement':
+        if not self.type.has_simple_content():
+            yield from self.type.content.iter_elements()  # type: ignoreunion-attr
+
+    @property
+    def xpath_proxy(self) -> XMLSchemaProxy:
+        return XMLSchemaProxy(
+            cast(XMLSchemaProtocol, self.schema),
+            cast(ElementProtocol, self)
+        )
+
+    @property
+    def schema(self) -> SchemaType:
+        return self.type.schema
+
+    @property
+    def target_namespace(self) -> str:
+        return self.type.schema.target_namespace
+
+    @property
+    def namespaces(self) -> NamespacesType:
+        return self.type.schema.namespaces
+
+    @property
+    def local_name(self) -> str:
+        return local_name(self.name)
+
+    @property
+    def qualified_name(self) -> str:
+        return get_qname(self.target_namespace, self.name)
+
+    @property
+    def prefixed_name(self) -> str:
+        return get_prefixed_qname(self.name, self.namespaces)