Source Code for Module xmlschema_acue.validators.facets

  1  # -*- coding: utf-8 -*- 
  2  # 
  3  # Copyright (c), 2016-2019, SISSA (International School for Advanced Studies). 
  4  # All rights reserved. 
  5  # This file is distributed under the terms of the MIT License. 
  6  # See the file 'LICENSE' in the root directory of the present 
  7  # distribution, or http://opensource.org/licenses/MIT. 
  8  # 
  9  # @author Davide Brunato <brunato@sissa.it> 
 10  # 
 11  """ 
 12  This module contains declarations and classes for XML Schema constraint facets. 
 13  """ 
 14  from __future__ import unicode_literals 
 15  import re 
 16  from elementpath import XPath2Parser, ElementPathSyntaxError, ElementPathTypeError, datatypes 
 17   
 18  from xmlschema_acue.compat import unicode_type, MutableSequence 
 19  from xmlschema_acue.qnames import XSD_LENGTH, XSD_MIN_LENGTH, XSD_MAX_LENGTH, XSD_ENUMERATION, XSD_WHITE_SPACE, \ 
 20      XSD_PATTERN, XSD_MAX_INCLUSIVE, XSD_MAX_EXCLUSIVE, XSD_MIN_INCLUSIVE, XSD_MIN_EXCLUSIVE, \ 
 21      XSD_TOTAL_DIGITS, XSD_FRACTION_DIGITS, XSD_ASSERTION, XSD_EXPLICIT_TIMEZONE, XSD_NOTATION_TYPE, \ 
 22      XSD_BASE64_BINARY, XSD_HEX_BINARY 
 23  from xmlschema_acue.regex import get_python_regex 
 24   
 25  from xmlschema_acue.validators.exceptions import XMLSchemaValidationError, XMLSchemaDecodeError 
 26  from xmlschema_acue.validators.xsdbase import XsdComponent 
 27   
 28   
 29 -class XsdFacet(XsdComponent): 
 30      """ 
 31      XML Schema constraining facets base class. 
 32      """ 
 33 -    def __init__(self, elem, schema, parent, base_type): 
 34          self.base_type = base_type 
 35          super(XsdFacet, self).__init__(elem, schema, parent) 
 36   
 37 -    def __repr__(self): 
 38          return '%s(value=%r, fixed=%r)' % (self.__class__.__name__, self.value, self.fixed) 
 39   
 40 -    def __call__(self, value): 
 41          for error in self.validator(value): 
 42              yield error 
 43   
 44 -    def _parse(self): 
 45          super(XsdFacet, self)._parse() 
 46          elem = self.elem 
 47          self.fixed = elem.get('fixed', False) 
 48          base_facet = self.base_facet 
 49          self.base_value = None if base_facet is None else base_facet.value 
 50   
 51          try: 
 52              self._parse_value(elem) 
 53          except (KeyError, ValueError, XMLSchemaDecodeError) as err: 
 54              self.value = None 
 55              self.parse_error(unicode_type(err)) 
 56          else: 
 57              if base_facet is not None and base_facet.fixed and \ 
 58                      base_facet.value is not None and self.value != base_facet.value: 
 59                  self.parse_error("%r facet value is fixed to %r" % (elem.tag, base_facet.value)) 
 60   
 61 -    def _parse_value(self, elem): 
 62          self.value = elem.attrib['value'] 
 63   
 64      @property 
 65 -    def built(self): 
 66          return self.base_type.is_global or self.base_type.built 
 67   
 68      @property 
 69 -    def validation_attempted(self): 
 70          if self.built: 
 71              return 'full' 
 72          else: 
 73              return self.base_type.validation_attempted 
 74   
 75      @property 
 76 -    def base_facet(self): 
 77          """ 
 78          An object of the same type if the instance has a base facet, `None` otherwise. 
 79          """ 
 80          base_type = self.base_type 
 81          tag = self.elem.tag 
 82          while True: 
 83              try: 
 84                  return base_type.facets[tag] 
 85              except (AttributeError, KeyError): 
 86                  if hasattr(base_type, 'base_type'): 
 87                      base_type = base_type.base_type 
 88                  else: 
 89                      return None 
 90   
 91      @staticmethod 
 92 -    def validator(_): 
 93          return () 
 94   
 95   
 96 -class XsdWhiteSpaceFacet(XsdFacet): 
 97      """ 
 98      XSD whiteSpace facet. 
 99   
100      <whiteSpace 
101        fixed = boolean : false 
102        id = ID 
103        value = (collapse | preserve | replace) 
104        {any attributes with non-schema namespace . . .}> 
105        Content: (annotation?) 
106      </whiteSpace> 
107      """ 
108      _admitted_tags = XSD_WHITE_SPACE, 
109   
110 -    def _parse_value(self, elem): 
111          self.value = value = elem.attrib['value'] 
112          if self.base_value == 'collapse' and value in ('preserve', 'replace'): 
113              self.parse_error("facet value can be only 'collapse'") 
114          elif self.base_value == 'replace' and value == 'preserve': 
115              self.parse_error("facet value can be only 'replace' or 'collapse'") 
116          elif value == 'replace': 
117              self.validator = self.replace_white_space_validator 
118          elif value == 'collapse': 
119              self.validator = self.collapse_white_space_validator 
120          elif value != 'preserve': 
121              self.parse_error("attribute 'value' must be one of ('preserve', 'replace', 'collapse').") 
122   
123 -    def replace_white_space_validator(self, x): 
124          if '\t' in x or '\n' in x: 
125              yield XMLSchemaValidationError(self, x) 
126   
127 -    def collapse_white_space_validator(self, x): 
128          if '\t' in x or '\n' in x or '  ' in x: 
129              yield XMLSchemaValidationError(self, x) 
130   
131   
132 -class XsdLengthFacet(XsdFacet): 
133      """ 
134      XSD length facet. 
135   
136      <length 
137        fixed = boolean : false 
138        id = ID 
139        value = nonNegativeInteger 
140        {any attributes with non-schema namespace . . .}> 
141        Content: (annotation?) 
142      </length> 
143      """ 
144      _admitted_tags = XSD_LENGTH, 
145   
146 -    def _parse_value(self, elem): 
147          self.value = int(elem.attrib['value']) 
148          if self.base_value is not None and self.value != self.base_value: 
149              self.parse_error("base type has a different 'length': %r" % self.base_value) 
150   
151          primitive_type = getattr(self.base_type, 'primitive_type', None) 
152          if primitive_type is None: 
153              self.validator = self.length_validator 
154          elif primitive_type.name == XSD_HEX_BINARY: 
155              self.validator = self.hex_length_validator 
156          elif primitive_type.name == XSD_BASE64_BINARY: 
157              self.validator = self.base64_length_validator 
158          else: 
159              self.validator = self.length_validator 
160   
161 -    def length_validator(self, x): 
162          if len(x) != self.value: 
163              yield XMLSchemaValidationError(self, x, "length has to be %r." % self.value) 
164   
165 -    def hex_length_validator(self, x): 
166          if len(x) != self.value * 2: 
167              yield XMLSchemaValidationError(self, x, "binary length has to be %r." % self.value) 
168   
169 -    def base64_length_validator(self, x): 
170          x = x.replace(' ', '') 
171          if (len(x) // 4 * 3 - (x[-1] == '=') - (x[-2] == '=')) != self.value: 
172              yield XMLSchemaValidationError(self, x, "binary length has to be %r." % self.value) 
173   
174   
175 -class XsdMinLengthFacet(XsdFacet): 
176      """ 
177      XSD minLength facet. 
178   
179      <minLength 
180        fixed = boolean : false 
181        id = ID 
182        value = nonNegativeInteger 
183        {any attributes with non-schema namespace . . .}> 
184        Content: (annotation?) 
185      </minLength> 
186      """ 
187      _admitted_tags = XSD_MIN_LENGTH, 
188   
189 -    def _parse_value(self, elem): 
190          self.value = int(elem.attrib['value']) 
191          if self.base_value is not None and self.value < self.base_value: 
192              self.parse_error("base type has a greater 'minLength': %r" % self.base_value) 
193   
194          primitive_type = getattr(self.base_type, 'primitive_type', None) 
195          if primitive_type is None: 
196              self.validator = self.min_length_validator 
197          elif primitive_type.name == XSD_HEX_BINARY: 
198              self.validator = self.hex_min_length_validator 
199          elif primitive_type.name == XSD_BASE64_BINARY: 
200              self.validator = self.base64_min_length_validator 
201          else: 
202              self.validator = self.min_length_validator 
203   
204 -    def min_length_validator(self, x): 
205          if len(x) < self.value: 
206              yield XMLSchemaValidationError(self, x, "length cannot be lesser than %r." % self.value) 
207   
208 -    def hex_min_length_validator(self, x): 
209          if len(x) < self.value * 2: 
210              yield XMLSchemaValidationError(self, x, "binary length cannot be lesser than %r." % self.value) 
211   
212 -    def base64_min_length_validator(self, x): 
213          x = x.replace(' ', '') 
214          if (len(x) // 4 * 3 - (x[-1] in ('=', 61)) - (x[-2] in ('=', 61))) < self.value: 
215              yield XMLSchemaValidationError(self, x, "binary length cannot be lesser than %r." % self.value) 
216   
217   
218 -class XsdMaxLengthFacet(XsdFacet): 
219      """ 
220      XSD maxLength facet. 
221   
222      <maxLength 
223        fixed = boolean : false 
224        id = ID 
225        value = nonNegativeInteger 
226        {any attributes with non-schema namespace . . .}> 
227        Content: (annotation?) 
228      </maxLength> 
229      """ 
230      _admitted_tags = XSD_MAX_LENGTH, 
231   
232 -    def _parse_value(self, elem): 
233          self.value = int(elem.attrib['value']) 
234          if self.base_value is not None and self.value > self.base_value: 
235              self.parse_error("base type has a lesser 'maxLength': %r" % self.base_value) 
236   
237          primitive_type = getattr(self.base_type, 'primitive_type', None) 
238          if primitive_type is None: 
239              self.validator = self.max_length_validator 
240          elif primitive_type.name == XSD_HEX_BINARY: 
241              self.validator = self.hex_max_length_validator 
242          elif primitive_type.name == XSD_BASE64_BINARY: 
243              self.validator = self.base64_max_length_validator 
244          else: 
245              self.validator = self.max_length_validator 
246   
247 -    def max_length_validator(self, x): 
248          if len(x) > self.value: 
249              yield XMLSchemaValidationError(self, x, "length cannot be greater than %r." % self.value) 
250   
251 -    def hex_max_length_validator(self, x): 
252          if len(x) > self.value * 2: 
253              yield XMLSchemaValidationError(self, x, "binary length cannot be greater than %r." % self.value) 
254   
255 -    def base64_max_length_validator(self, x): 
256          x = x.replace(' ', '') 
257          if (len(x) // 4 * 3 - (x[-1] == '=') - (x[-2] == '=')) > self.value: 
258              yield XMLSchemaValidationError(self, x, "binary length cannot be greater than %r." % self.value) 
259   
260   
261 -class XsdMinInclusiveFacet(XsdFacet): 
262      """ 
263      XSD minInclusive facet. 
264   
265      <minInclusive 
266        fixed = boolean : false 
267        id = ID 
268        value = anySimpleType 
269        {any attributes with non-schema namespace . . .}> 
270        Content: (annotation?) 
271      </minInclusive> 
272      """ 
273      _admitted_tags = XSD_MIN_INCLUSIVE, 
274   
275 -    def _parse_value(self, elem): 
276          self.value = self.base_type.decode(elem.attrib['value']) 
277   
278          facet = self.base_type.get_facet(XSD_MIN_EXCLUSIVE) 
279          if facet is not None and facet.value >= self.value: 
280              self.parse_error("minimum value of base_type is greater") 
281          facet = self.base_type.get_facet(XSD_MIN_INCLUSIVE) 
282          if facet is not None and facet.value > self.value: 
283              self.parse_error("minimum value of base_type is greater") 
284          facet = self.base_type.get_facet(XSD_MAX_EXCLUSIVE) 
285          if facet is not None and facet.value <= self.value: 
286              self.parse_error("maximum value of base_type is lesser") 
287          facet = self.base_type.get_facet(XSD_MAX_INCLUSIVE) 
288          if facet is not None and facet.value < self.value: 
289              self.parse_error("maximum value of base_type is lesser") 
290   
291 -    def validator(self, x): 
292          if x < self.value: 
293              yield XMLSchemaValidationError(self, x, "value has to be greater or equal than %r." % self.value) 
294   
295   
296 -class XsdMinExclusiveFacet(XsdFacet): 
297      """ 
298      XSD minExclusive facet. 
299   
300      <minExclusive 
301        fixed = boolean : false 
302        id = ID 
303        value = anySimpleType 
304        {any attributes with non-schema namespace . . .}> 
305        Content: (annotation?) 
306      </minExclusive> 
307      """ 
308      _admitted_tags = XSD_MIN_EXCLUSIVE, 
309   
310 -    def _parse_value(self, elem): 
311          self.value = self.base_type.decode(elem.attrib['value']) 
312   
313          facet = self.base_type.get_facet(XSD_MIN_EXCLUSIVE) 
314          if facet is not None and facet.value > self.value: 
315              self.parse_error("minimum value of base_type is greater") 
316          facet = self.base_type.get_facet(XSD_MIN_INCLUSIVE) 
317          if facet is not None and facet.value > self.value: 
318              self.parse_error("minimum value of base_type is greater") 
319          facet = self.base_type.get_facet(XSD_MAX_EXCLUSIVE) 
320          if facet is not None and facet.value <= self.value: 
321              self.parse_error("maximum value of base_type is lesser") 
322          facet = self.base_type.get_facet(XSD_MAX_INCLUSIVE) 
323          if facet is not None and facet.value <= self.value: 
324              self.parse_error("maximum value of base_type is lesser") 
325   
326 -    def validator(self, x): 
327          if x <= self.value: 
328              yield XMLSchemaValidationError(self, x, "value has to be greater than %r." % self.value) 
329   
330   
331 -class XsdMaxInclusiveFacet(XsdFacet): 
332      """ 
333      XSD maxInclusive facet. 
334   
335      <maxInclusive 
336        fixed = boolean : false 
337        id = ID 
338        value = anySimpleType 
339        {any attributes with non-schema namespace . . .}> 
340        Content: (annotation?) 
341      </maxInclusive> 
342      """ 
343      _admitted_tags = XSD_MAX_INCLUSIVE, 
344   
345 -    def _parse_value(self, elem): 
346          self.value = self.base_type.decode(elem.attrib['value']) 
347   
348          facet = self.base_type.get_facet(XSD_MIN_EXCLUSIVE) 
349          if facet is not None and facet.value >= self.value: 
350              self.parse_error("minimum value of base_type is greater") 
351          facet = self.base_type.get_facet(XSD_MIN_INCLUSIVE) 
352          if facet is not None and facet.value > self.value: 
353              self.parse_error("minimum value of base_type is greater") 
354          facet = self.base_type.get_facet(XSD_MAX_EXCLUSIVE) 
355          if facet is not None and facet.value <= self.value: 
356              self.parse_error("maximum value of base_type is lesser") 
357          facet = self.base_type.get_facet(XSD_MAX_INCLUSIVE) 
358          if facet is not None and facet.value < self.value: 
359              self.parse_error("maximum value of base_type is lesser") 
360   
361 -    def validator(self, x): 
362          if x > self.value: 
363              yield XMLSchemaValidationError(self, x, "value has to be lesser or equal than %r." % self.value) 
364   
365   
366 -class XsdMaxExclusiveFacet(XsdFacet): 
367      """ 
368      XSD maxExclusive facet. 
369   
370      <maxExclusive 
371        fixed = boolean : false 
372        id = ID 
373        value = anySimpleType 
374        {any attributes with non-schema namespace . . .}> 
375        Content: (annotation?) 
376      </maxExclusive> 
377      """ 
378      _admitted_tags = XSD_MAX_EXCLUSIVE, 
379   
380 -    def _parse_value(self, elem): 
381          self.value = self.base_type.decode(elem.attrib['value']) 
382   
383          facet = self.base_type.get_facet(XSD_MIN_EXCLUSIVE) 
384          if facet is not None and facet.value >= self.value: 
385              self.parse_error("minimum value of base_type is greater") 
386          facet = self.base_type.get_facet(XSD_MIN_INCLUSIVE) 
387          if facet is not None and facet.value >= self.value: 
388              self.parse_error("minimum value of base_type is greater") 
389          facet = self.base_type.get_facet(XSD_MAX_EXCLUSIVE) 
390          if facet is not None and facet.value < self.value: 
391              self.parse_error("maximum value of base_type is lesser") 
392          facet = self.base_type.get_facet(XSD_MAX_INCLUSIVE) 
393          if facet is not None and facet.value < self.value: 
394              self.parse_error("maximum value of base_type is lesser") 
395   
396 -    def validator(self, x): 
397          if x >= self.value: 
398              yield XMLSchemaValidationError(self, x, "value has to be lesser than %r" % self.value) 
399   
400   
401 -class XsdTotalDigitsFacet(XsdFacet): 
402      """ 
403      XSD totalDigits facet. 
404   
405      <totalDigits 
406        fixed = boolean : false 
407        id = ID 
408        value = positiveInteger 
409        {any attributes with non-schema namespace . . .}> 
410        Content: (annotation?) 
411      </totalDigits> 
412      """ 
413      _admitted_tags = XSD_TOTAL_DIGITS, 
414   
415 -    def _parse_value(self, elem): 
416          self.value = int(elem.attrib['value']) 
417          if self.value < 1: 
418              raise ValueError("'value' must be greater or equal than 1") 
419          self.validator = self.total_digits_validator 
420   
421 -    def total_digits_validator(self, x): 
422          if len([d for d in str(x).strip('0') if d.isdigit()]) > self.value: 
423              yield XMLSchemaValidationError(self, x, "the number of digits is greater than %r." % self.value) 
424   
425   
426 -class XsdFractionDigitsFacet(XsdFacet): 
427      """ 
428      XSD fractionDigits facet. 
429   
430      <fractionDigits 
431        fixed = boolean : false 
432        id = ID 
433        value = nonNegativeInteger 
434        {any attributes with non-schema namespace . . .}> 
435        Content: (annotation?) 
436      </fractionDigits> 
437      """ 
438      _admitted_tags = XSD_FRACTION_DIGITS, 
439   
440 -    def __init__(self, elem, schema, parent, base_type): 
441          super(XsdFractionDigitsFacet, self).__init__(elem, schema, parent, base_type) 
442          if not base_type.is_derived(self.schema.builtin_types()['decimal']): 
443              self.parse_error("fractionDigits facet can be applied only to types derived from xs:decimal") 
444   
445 -    def _parse_value(self, elem): 
446          self.value = int(elem.attrib['value']) 
447          if self.value < 0: 
448              raise ValueError("'value' must be greater or equal than 0") 
449          elif self.value > 0 and self.base_type.is_derived(self.schema.builtin_types()['integer']): 
450              raise ValueError("fractionDigits facet value has to be 0 for types derived from xs:integer.") 
451          self.validator = self.fraction_digits_validator 
452   
453 -    def fraction_digits_validator(self, x): 
454          if len(str(x).strip('0').partition('.')[2]) > self.value: 
455              yield XMLSchemaValidationError(self, x, "the number of fraction digits is greater than %r." % self.value) 
456   
457   
458 -class XsdExplicitTimezoneFacet(XsdFacet): 
459      """ 
460      XSD 1.1 explicitTimezone facet. 
461   
462      <explicitTimezone 
463        fixed = boolean : false 
464        id = ID 
465        value = NCName 
466        {any attributes with non-schema namespace . . .}> 
467        Content: (annotation?) 
468      </explicitTimezone> 
469      """ 
470      _admitted_tags = XSD_EXPLICIT_TIMEZONE, 
471   
472 -    def _parse_value(self, elem): 
473          self.value = value = elem.attrib['value'] 
474          if value == 'prohibited': 
475              self.validator = self.prohibited_timezone_validator 
476          elif value == 'required': 
477              self.validator = self.required_timezone_validator 
478          elif value != 'optional': 
479              self.parse_error("attribute 'value' must be one of ('required', 'prohibited', 'optional').") 
480   
481 -    def required_timezone_validator(self, x): 
482          if x.tzinfo is None: 
483              yield XMLSchemaValidationError(self, x, "time zone required for value %r." % self.value) 
484   
485 -    def prohibited_timezone_validator(self, x): 
486          if x.tzinfo is not None: 
487              yield XMLSchemaValidationError(self, x, "time zone prohibited for value %r." % self.value) 
488   
489   
490 -class XsdEnumerationFacets(MutableSequence, XsdFacet): 
491      """ 
492      Sequence of XSD enumeration facets. Values are validates if match any of enumeration values. 
493   
494      <enumeration 
495        id = ID 
496        value = anySimpleType 
497        {any attributes with non-schema namespace . . .}> 
498        Content: (annotation?) 
499      </enumeration> 
500      """ 
501      _admitted_tags = {XSD_ENUMERATION} 
502   
503 -    def __init__(self, elem, schema, parent, base_type): 
504          XsdFacet.__init__(self, elem, schema, parent, base_type) 
505   
506 -    def _parse(self): 
507          super(XsdFacet, self)._parse() 
508          self._elements = [self.elem] 
509          self.enumeration = [self._parse_value(self.elem)] 
510   
511 -    def _parse_value(self, elem): 
512          try: 
513              value = self.base_type.decode(elem.attrib['value']) 
514          except KeyError: 
515              self.parse_error("missing 'value' attribute", elem) 
516          except XMLSchemaDecodeError as err: 
517              self.parse_error(err, elem) 
518          else: 
519              if self.base_type.name == XSD_NOTATION_TYPE: 
520                  try: 
521                      notation_qname = self.schema.resolve_qname(value) 
522                  except ValueError as err: 
523                      self.parse_error(err, elem) 
524                  else: 
525                      if notation_qname not in self.maps.notations: 
526                          self.parse_error("value {} must match a notation global declaration".format(value), elem) 
527   
528              return value 
529   
530      # Implements the abstract methods of MutableSequence 
531 -    def __getitem__(self, i): 
532          return self._elements[i] 
533   
534 -    def __setitem__(self, i, elem): 
535          self._elements[i] = elem 
536          self.enumeration[i] = self._parse_value(elem) 
537   
538 -    def __delitem__(self, i): 
539          del self._elements[i] 
540          del self.enumeration[i] 
541   
542 -    def __len__(self): 
543          return len(self._elements) 
544   
545 -    def insert(self, i, elem): 
546          self._elements.insert(i, elem) 
547          self.enumeration.insert(i, self._parse_value(elem)) 
548   
549 -    def __repr__(self): 
550          if len(self.enumeration) > 5: 
551              return '%s(%r)' % ( 
552                  self.__class__.__name__, '[%s, ...]' % ', '.join(map(repr, self.enumeration[:5])) 
553              ) 
554          else: 
555              return '%s(%r)' % (self.__class__.__name__, self.enumeration) 
556   
557 -    def __call__(self, value): 
558          if value not in self.enumeration: 
559              yield XMLSchemaValidationError( 
560                  self, value, reason="invalid value %r, it must be one of %r" % (value, self.enumeration) 
561              ) 
562   
563   
564 -class XsdPatternFacets(MutableSequence, XsdFacet): 
565      """ 
566      Sequence of XSD pattern facets. Values are validates if match any of patterns. 
567   
568      <pattern 
569        id = ID 
570        value = string 
571        {any attributes with non-schema namespace . . .}> 
572        Content: (annotation?) 
573      </pattern> 
574      """ 
575      _admitted_tags = {XSD_PATTERN} 
576   
577 -    def __init__(self, elem, schema, parent, base_type): 
578          XsdFacet.__init__(self, elem, schema, parent, base_type) 
579   
580 -    def _parse(self): 
581          super(XsdFacet, self)._parse() 
582          self._elements = [self.elem] 
583          self.patterns = [self._parse_value(self.elem)] 
584   
585 -    def _parse_value(self, elem): 
586          try: 
587              return re.compile(get_python_regex(elem.attrib['value'])) 
588          except KeyError: 
589              self.parse_error("missing 'value' attribute", elem) 
590              return re.compile(r'^$') 
591          except (re.error, XMLSchemaDecodeError) as err: 
592              self.parse_error(err, elem) 
593              return re.compile(r'^$') 
594   
595      # Implements the abstract methods of MutableSequence 
596 -    def __getitem__(self, i): 
597          return self._elements[i] 
598   
599 -    def __setitem__(self, i, elem): 
600          self._elements[i] = elem 
601          self.patterns[i] = self._parse_value(elem) 
602   
603 -    def __delitem__(self, i): 
604          del self._elements[i] 
605          del self.patterns[i] 
606   
607 -    def __len__(self): 
608          return len(self._elements) 
609   
610 -    def insert(self, i, elem): 
611          self._elements.insert(i, elem) 
612          self.patterns.insert(i, self._parse_value(elem)) 
613   
614 -    def __repr__(self): 
615          s = repr(self.regexps) 
616          if len(s) < 70: 
617              return '%s(%s)' % (self.__class__.__name__, s) 
618          else: 
619              return '%s(%s...\'])' % (self.__class__.__name__, s[:70]) 
620   
621 -    def __call__(self, text): 
622          if all(pattern.match(text) is None for pattern in self.patterns): 
623              msg = "value doesn't match any pattern of %r." 
624              yield XMLSchemaValidationError(self, text, reason=msg % self.regexps) 
625   
626      @property 
627 -    def regexps(self): 
628          return [e.get('value', '') for e in self._elements] 
629   
630   
631 -class XsdAssertionFacet(XsdFacet): 
632      """ 
633      XSD 1.1 assertion facet for simpleType definitions. 
634   
635      <assertion 
636        id = ID 
637        test = an XPath expression 
638        xpathDefaultNamespace = (anyURI | (##defaultNamespace | ##targetNamespace | ##local)) 
639        {any attributes with non-schema namespace . . .}> 
640        Content: (annotation?) 
641      </assertion> 
642      """ 
643      _admitted_tags = {XSD_ASSERTION} 
644   
645 -    def __repr__(self): 
646          return '%s(test=%r)' % (self.__class__.__name__, self.path) 
647   
648 -    def _parse(self): 
649          super(XsdFacet, self)._parse() 
650          try: 
651              self.path = self.elem.attrib['test'] 
652          except KeyError as err: 
653              self.parse_error(str(err), elem=self.elem) 
654              self.path = 'true()' 
655   
656          builtin_type_name = self.base_type.primitive_type.local_name 
657          variables = {'value': datatypes.XSD_BUILTIN_TYPES[builtin_type_name].value} 
658   
659          if 'xpathDefaultNamespace' in self.elem.attrib: 
660              self.xpath_default_namespace = self._parse_xpath_default_namespace(self.elem) 
661          else: 
662              self.xpath_default_namespace = self.schema.xpath_default_namespace 
663          self.parser = XPath2Parser(self.namespaces, strict=False, variables=variables, 
664                                     default_namespace=self.xpath_default_namespace) 
665   
666          try: 
667              self.token = self.parser.parse(self.path) 
668          except (ElementPathSyntaxError, ElementPathTypeError) as err: 
669              self.parse_error(err, elem=self.elem) 
670              self.token = self.parser.parse('true()') 
671   
672 -    def __call__(self, value): 
673          self.parser.variables['value'] = value 
674          if not self.token.evaluate(): 
675              msg = "value is not true with test path %r." 
676              yield XMLSchemaValidationError(self, value, reason=msg % self.path) 
677   
678   
679  XSD_10_FACETS_BUILDERS = { 
680      XSD_WHITE_SPACE: XsdWhiteSpaceFacet, 
681      XSD_LENGTH: XsdLengthFacet, 
682      XSD_MIN_LENGTH: XsdMinLengthFacet, 
683      XSD_MAX_LENGTH: XsdMaxLengthFacet, 
684      XSD_MIN_INCLUSIVE: XsdMinInclusiveFacet, 
685      XSD_MIN_EXCLUSIVE: XsdMinExclusiveFacet, 
686      XSD_MAX_INCLUSIVE: XsdMaxInclusiveFacet, 
687      XSD_MAX_EXCLUSIVE: XsdMaxExclusiveFacet, 
688      XSD_TOTAL_DIGITS: XsdTotalDigitsFacet, 
689      XSD_FRACTION_DIGITS: XsdFractionDigitsFacet, 
690      XSD_ENUMERATION: XsdEnumerationFacets, 
691      XSD_PATTERN: XsdPatternFacets 
692  } 
693   
694  XSD_11_FACETS_BUILDERS = XSD_10_FACETS_BUILDERS.copy() 
695  XSD_11_FACETS_BUILDERS.update({ 
696      XSD_ASSERTION: XsdAssertionFacet, 
697      XSD_EXPLICIT_TIMEZONE: XsdExplicitTimezoneFacet 
698  }) 
699   
700  XSD_10_FACETS = set(XSD_10_FACETS_BUILDERS) 
701  XSD_11_FACETS = set(XSD_11_FACETS_BUILDERS) 
702   
703  XSD_10_LIST_FACETS = {XSD_LENGTH, XSD_MIN_LENGTH, XSD_MAX_LENGTH, XSD_PATTERN, XSD_ENUMERATION, XSD_WHITE_SPACE} 
704  XSD_11_LIST_FACETS = XSD_10_LIST_FACETS | {XSD_ASSERTION} 
705   
706  XSD_10_UNION_FACETS = {XSD_PATTERN, XSD_ENUMERATION} 
707  XSD_11_UNION_FACETS = MULTIPLE_FACETS = {XSD_PATTERN, XSD_ENUMERATION, XSD_ASSERTION} 
708