pyxb.binding.facets

Source Code for Module pyxb.binding.facets

1 # -*- coding: utf-8 -*- 2 # Copyright 2009-2013, Peter A. Bigot 3 # 4 # Licensed under the Apache License, Version 2.0 (the "License"); you may 5 # not use this file except in compliance with the License. You may obtain a 6 # copy of the License at: 7 # 8 # http://www.apache.org/licenses/LICENSE-2.0 9 # 10 # Unless required by applicable law or agreed to in writing, software 11 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 12 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 13 # License for the specific language governing permissions and limitations 14 # under the License. 15 16 """Classes related to XMLSchema facets. 17 18 The definitions herein are from sections U{4.2<http://www.w3.org/TR/xmlschema-2/index.html#rf-facets>} 19 and U{4.3<http://www.w3.org/TR/xmlschema-2/index.html#rf-facets>} of 20 U{XML Schema Part 2: Datatypes<http://www.w3.org/TR/xmlschema-2/>}. 21 Facets are attributes of a datatype that constrain its lexical and 22 value spaces. 23 24 """ 25 26 import logging 27 import re 28 import decimal 29 import pyxb 30 from . import datatypes 31 from . import basis 32 from pyxb.utils import utility, six 33 34 _log = logging.getLogger(__name__)

37 """The base class for facets. 38 39 This provides association with STDs, a name, and a value for the facet. 40 """ 41 42 _Name = None 43 @classmethod 47 48 __baseTypeDefinition = None 57 58 __ownerTypeDefinition = None 66 67 # The default valueDatatype to use for instances of this class. 68 # This is overridden in subclasses that do not use late value 69 # datatype bindings. 70 _ValueDatatype = None 71 72 # The datatype used for facet values. 73 __valueDatatype = None 88 89 __value = None 92 93 __annotation = None 95 102 131 135 136 @classmethod 147 158

165

166 -class ConstrainingFacet (Facet):

167 """One of the facets defined in section 4.3, which provide 168 constraints on the lexical space of a type definition.""" 169 170 # The prefix used for Python classes used for a constraining 171 # facet. Note that this is not the prefix used when generating a 172 # Python class member that specifies a constraining instance, even 173 # if it happens to be the same digraph. 174 _FacetPrefix = 'CF' 175

176 - def __init__ (self, **kw):

177 super(ConstrainingFacet, self).__init__(**kw)

178

179 - def _validateConstraint_vx (self, value):

180 raise pyxb.LogicError("Facet %s does not implement constraints" % (self.Name(),))

181

182 - def validateConstraint (self, value):

183 """Return True iff the given value satisfies the constraint represented by this facet instance. 184 185 The actual test is delegated to the subclasses.""" 186 return self._validateConstraint_vx(value)

187

188 - def __setFromKeywords(self, **kw):

189 kwv = kw.get('value') 190 if kwv is not None: 191 vdt = self.valueDatatype() 192 if not isinstance(kwv, vdt): 193 kwv = vdt(kwv) 194 self._value(kwv)

195

196 - def _setFromKeywords_vb (self, **kw):

197 """Extend base class. 198 199 Additional keywords: 200 * value 201 """ 202 # NB: This uses post-extension because it makes reference to the value_data_type 203 super_fn = getattr(super(ConstrainingFacet, self), '_setFromKeywords_vb', lambda *a,**kw: self) 204 rv = super_fn(**kw) 205 self.__setFromKeywords(**kw) 206 return rv

207

208 -class _LateDatatype_mixin (pyxb.cscRoot):

209 """Marker class to indicate that the facet instance must be told 210 its datatype when it is constructed. 211 212 This is necessary for facets like L{CF_minInclusive} and 213 L{CF_minExclusive}, for which the value is determined by the base 214 type definition of the associated STD. In some cases the value 215 that must be used in the facet cannot be represented in the Python 216 type used for the facet; see L{LateDatatypeBindsSuperclass}. 217 """ 218 219 _LateDatatypeBindsSuperclass = None 220 """The class variable that indicates that the Subclasses must 221 override this variable with a value of C{True} or C{False}. The 222 value is C{True} iff the value used for the facet is not within 223 the value space of the corresponding value datatype; for example, 224 L{CF_minExclusive}.""" 225 226 227 @classmethod

228 - def LateDatatypeBindsSuperclass (cls):

229 """Return true if false if the proposed datatype should be 230 used, or True if the base type definition of the proposed 231 datatype should be used.""" 232 if cls._LateDatatypeBindsSuperclass is None: 233 raise pyxb.LogicError('Class %s did not set _LateDatatypeBindsSuperclass variable.') 234 return cls._LateDatatypeBindsSuperclass

235 236 @classmethod

237 - def BindingValueDatatype (cls, value_type):

238 """Find the datatype for facet values when this facet is bound 239 to the given value_type. 240 241 If the C{value_type} is an STD, the associated Python support 242 datatype from this value_type scanning up through the base 243 type hierarchy is used. 244 """ 245 246 import pyxb.xmlschema.structures as structures 247 if isinstance(value_type, structures.SimpleTypeDefinition): 248 # Back up until we find something that actually has a 249 # datatype 250 while not value_type.hasPythonSupport(): 251 value_type = value_type.baseTypeDefinition() 252 value_type = value_type.pythonSupport() 253 assert issubclass(value_type, basis.simpleTypeDefinition) 254 if cls.LateDatatypeBindsSuperclass(): 255 value_type = value_type.XsdSuperType() 256 return value_type

257

258 - def bindValueDatatype (self, value_datatype):

259 self.setFromKeywords(_constructor=True, value_datatype=self.BindingValueDatatype(value_datatype))

260

261 -class _Fixed_mixin (pyxb.cscRoot):

262 """Mix-in to a constraining facet that adds support for the 'fixed' property.""" 263 __fixed = None

264 - def fixed (self): return self.__fixed

265

266 - def __setFromKeywords (self, **kw):

267 if kw.get('_reset', False): 268 self.__fixed = None 269 kwv = kw.get('fixed') 270 if kwv is not None: 271 self.__fixed = datatypes.boolean(kwv)

272

273 - def _setFromKeywords_vb (self, **kw):

274 """Extend base class. 275 276 Additional keywords: 277 * fixed 278 """ 279 self.__setFromKeywords(**kw) 280 super_fn = getattr(super(_Fixed_mixin, self), '_setFromKeywords_vb', lambda *a,**kw: self) 281 return super_fn(**kw)

282

283 -class _CollectionFacet_mixin (pyxb.cscRoot):

284 """Mix-in to handle facets whose values are collections, not scalars. 285 286 For example, the enumeration and pattern facets maintain a list of 287 enumeration values and patterns, respectively, as their value 288 space. 289 290 Subclasses must define a class variable _CollectionFacet_itemType 291 which is a reference to a class that is used to construct members 292 of the collection. 293 """ 294 295 __items = None

296 - def _setFromKeywords_vb (self, **kw):

297 """Extend base class. 298 299 @keyword _constructor: If C{False} or absent, the object being 300 set is a member of the collection. If 301 C{True}, the object being set is the 302 collection itself. 303 """ 304 if kw.get('_reset', False): 305 self.__items = [] 306 if not kw.get('_constructor', False): 307 self.__items.append(self._CollectionFacet_itemType(facet_instance=self, **kw)) 308 super_fn = getattr(super(_CollectionFacet_mixin, self), '_setFromKeywords_vb', lambda *a,**kw: self) 309 return super_fn(**kw)

310

311 - def _items (self):

312 """The members of the collection, as a reference.""" 313 return self.__items

314

315 - def items (self):

316 """The members of the collection, as a copy.""" 317 return self.__items[:]

318

319 - def iteritems (self):

320 """The members of the collection as an iterator""" 321 return iter(self.__items)

322

323 -class CF_length (ConstrainingFacet, _Fixed_mixin):

324 """A facet that specifies the length of the lexical representation of a value. 325 326 See U{http://www.w3.org/TR/xmlschema-2/#rf-length} 327 """ 328 _Name = 'length' 329 _ValueDatatype = datatypes.nonNegativeInteger 330

331 - def _validateConstraint_vx (self, value):

332 value_length = value.xsdValueLength() 333 return (value_length is None) or (self.value() is None) or (value_length == self.value())

334

335 -class CF_minLength (ConstrainingFacet, _Fixed_mixin):

336 """A facet that constrains the length of the lexical representation of a value. 337 338 See U{http://www.w3.org/TR/xmlschema-2/#rf-minLength} 339 """ 340 _Name = 'minLength' 341 _ValueDatatype = datatypes.nonNegativeInteger 342

343 - def _validateConstraint_vx (self, value):

344 value_length = value.xsdValueLength() 345 return (value_length is None) or (self.value() is None) or (value_length >= self.value())

346

347 -class CF_maxLength (ConstrainingFacet, _Fixed_mixin):

348 """A facet that constrains the length of the lexical representation of a value. 349 350 See U{http://www.w3.org/TR/xmlschema-2/#rf-minLength} 351 """ 352 _Name = 'maxLength' 353 _ValueDatatype = datatypes.nonNegativeInteger 354

355 - def _validateConstraint_vx (self, value):

356 value_length = value.xsdValueLength() 357 return (value_length is None) or (self.value() is None) or (value_length <= self.value())

358 359 import pyxb.utils.xmlre

360 361 -class _PatternElement (utility.PrivateTransient_mixin):

362 """This class represents individual patterns that appear within a CF_pattern collection.""" 363 364 # The compiled regular expression is marked transient because we 365 # normally do development with Python 2.5, and consequently save 366 # the pickled namespace archives that go into the distribution 367 # with that version. Compiled regular expressions in Python 2.5 368 # include a reference to the re._compile method, which does not 369 # exist in Python 2.4. As a result, attempts to load a namespace 370 # which includes types with pattern restrictions fail. 371 __PrivateTransient = set() 372 373 __compiledExpression = None 374 __PrivateTransient.add('compiledExpression') 375 376 __pythonExpression = None 377 378 pattern = None 379 annotation = None

380 - def __init__ (self, pattern=None, value=None, annotation=None, **kw):

381 if pattern is None: 382 assert value is not None 383 pattern = value 384 assert isinstance(pattern, six.string_types) 385 self.pattern = pattern 386 if isinstance(annotation, six.string_types): 387 self.annotation = annotation 388 self.__pythonExpression = pyxb.utils.xmlre.XMLToPython(pattern) 389 super(_PatternElement, self).__init__()

390

391 - def __str__ (self): return self.pattern

392

393 - def matches (self, text):

394 if self.__compiledExpression is None: 395 self.__compiledExpression = re.compile(self.__pythonExpression) 396 return self.__compiledExpression.match(text)

397

398 -class CF_pattern (ConstrainingFacet, _CollectionFacet_mixin):

399 """A facet that constrains the lexical representation of a value 400 to match one of a set of patterns. 401 402 See U{http://www.w3.org/TR/xmlschema-2/#rf-pattern} 403 404 @note: In PyXB, pattern constraints are ignored for any type with 405 a Python representation that does not derive from a string type. 406 This is due to the difficulty in reconstructing the lexical 407 representation of a non-string type after it has been converted to 408 its value space. 409 410 @todo: On creating new instances of non-string simple types from 411 string representations, we could apply pattern constraints. That 412 would mean checking them prior to invoking the Factory method. 413 """ 414 _Name = 'pattern' 415 _CollectionFacet_itemType = _PatternElement 416 _ValueDatatype = datatypes.string 417 418 __patternElements = None

419 - def patternElements (self): return self.__patternElements

420

421 - def __init__ (self, **kw):

422 super(CF_pattern, self).__init__(**kw) 423 self.__patternElements = []

424

425 - def addPattern (self, **kw):

426 pattern = self._CollectionFacet_itemType(**kw) 427 self.__patternElements.append(pattern) 428 return pattern

429

430 - def _validateConstraint_vx (self, value):

431 # If validation is inhibited, or if the facet hasn't had any 432 # restrictions applied yet, return True. 433 if 0 == len(self.__patternElements): 434 return True 435 if not isinstance(value, six.string_types): 436 # Ignore pattern constraint when value space and lexical 437 # space differ. 438 return True 439 for pe in self.__patternElements: 440 if pe.matches(value): 441 return True 442 return False

443

444 @six.python_2_unicode_compatible 445 -class _EnumerationElement (object):

446 """This class represents individual values that appear within a 447 L{CF_enumeration} collection.""" 448 449 __value = None

450 - def value (self):

451 """The Python value that is used for equality testing 452 against this enumeration. 453 454 This is an instance of L{enumeration.valueDatatype()<CF_enumeration.valueDatatype>}, 455 initialized from the unicodeValue.""" 456 return self.__value

457 458 __tag = None

459 - def tag (self):

460 """The Python identifier used for the named constant representing 461 the enumeration value. 462 463 This should include any desired prefix, since it must be 464 unique within its binding class. If C{None}, no enumeration 465 constant will be generated.""" 466 return self.__tag

467 - def _setTag (self, tag):

468 """Set the tag to be used for this enumeration.""" 469 self.__tag = tag

470 471 __enumeration = None

472 - def enumeration (self):

473 """A reference to the L{CF_enumeration} instance that owns this element.""" 474 return self.__enumeration

475 476 __unicodeValue = None

477 - def unicodeValue (self):

478 """The unicode string that defines the enumeration value.""" 479 return self.__unicodeValue

480

481 - def __init__ (self, enumeration=None, unicode_value=None, 482 description=None, annotation=None, tag=None, 483 **kw):

484 # The preferred keyword is "unicode_value", but when being 485 # generically applied by 486 # structures.SimpleTypeDefinition.__updateFacets, the unicode 487 # value comes in through the keyword "value". Similarly for 488 # "enumeration" and "facet_instance". 489 value = kw.get('value', unicode_value) 490 if unicode_value is None: 491 unicode_value = value 492 if enumeration is None: 493 enumeration = kw['facet_instance'] 494 self.__unicodeValue = unicode_value 495 self.__enumeration = enumeration 496 self.__description = description 497 self.__annotation = annotation 498 self.__tag = tag 499 500 assert self.__enumeration is not None 501 502 value_datatype = self.enumeration().valueDatatype() 503 self.__value = value_datatype.Factory(value, _validate_constraints=False, _from_xml=True) 504 505 if (self.__description is None) and (self.__annotation is not None): 506 self.__description = six.text_type(self.__annotation)

507

508 - def __str__ (self):

509 return utility.QuotedEscaped(self.unicodeValue())

510

511 -class CF_enumeration (ConstrainingFacet, _CollectionFacet_mixin, _LateDatatype_mixin):

512 """Capture a constraint that restricts valid values to a fixed set. 513 514 A STD that has an enumeration restriction should mix-in 515 L{pyxb.binding.basis.enumeration_mixin}, and should have a class 516 variable titled C{_CF_enumeration} that is an instance of this 517 class. 518 519 "unicode" refers to the Unicode string by which the value is 520 represented in XML. 521 522 "tag" refers to the Python member reference associated with the 523 enumeration. The value is derived from the unicode value of the 524 enumeration element and an optional prefix that identifies the 525 owning simple type when the tag is promoted to module-level 526 visibility. 527 528 "value" refers to the Python value held in the tag 529 530 See U{http://www.w3.org/TR/xmlschema-2/#rf-enumeration} 531 """ 532 _Name = 'enumeration' 533 _CollectionFacet_itemType = _EnumerationElement 534 _LateDatatypeBindsSuperclass = False 535 536 __tagToElement = None 537 __valueToElement = None 538 __unicodeToElement = None 539 540 # The prefix to be used when making enumeration tags visible at 541 # the module level. If None, tags are not made visible. 542 __enumPrefix = None 543

544 - def __init__ (self, **kw):

545 super(CF_enumeration, self).__init__(**kw) 546 self.__enumPrefix = kw.get('enum_prefix', self.__enumPrefix) 547 self.__tagToElement = { } 548 self.__valueToElement = { } 549 self.__unicodeToElement = { }

550

551 - def enumPrefix (self):

552 return self.__enumPrefix

553

554 - def elements (self):

555 """@deprecated: Use L{items} or L{iteritems} instead.""" 556 return list(six.iteritems(self))

557

558 - def values (self):

559 """Return a list of enumeration values.""" 560 return [ _ee.value() for _ee in six.iteritems(self) ]

561

562 - def itervalues (self):

563 """Generate the enumeration values.""" 564 for ee in six.iteritems(self): 565 yield ee.value()

566

567 - def addEnumeration (self, **kw):

568 kw['enumeration'] = self 569 ee = _EnumerationElement(**kw) 570 assert not (ee.tag in self.__tagToElement) 571 self.__tagToElement[ee.tag()] = ee 572 self.__unicodeToElement[ee.unicodeValue()] = ee 573 value = ee.value() 574 # Not just issubclass(self.valueDatatype(), basis.STD_list); 575 # this may be a union with one of those as a member type. 576 if isinstance(value, list): 577 value = ' '.join([ _v.xsdLiteral() for _v in value ]) 578 self.__valueToElement[value] = ee 579 self._items().append(ee) 580 return value

581

582 - def elementForValue (self, value):

583 """Return the L{_EnumerationElement} instance that has the given value. 584 585 @raise KeyError: the value is not valid for the enumeration.""" 586 return self.__valueToElement[value]

587

588 - def valueForUnicode (self, ustr):

589 """Return the enumeration value corresponding to the given unicode string. 590 591 If ustr is not a valid option for this enumeration, return None.""" 592 rv = self.__unicodeToElement.get(ustr) 593 if rv is not None: 594 rv = rv.value() 595 return rv

596

597 - def _validateConstraint_vx (self, value):

598 # If validation is inhibited, or if the facet hasn't had any 599 # restrictions applied yet, return True. 600 if 0 == len(self._items()): 601 return True 602 for ee in six.iteritems(self): 603 if ee.value() == value: 604 return True 605 return False

606

607 -class _Enumeration_mixin (pyxb.cscRoot):

608 """Marker class to indicate that the generated binding has enumeration members.""" 609 @classmethod

610 - def valueForUnicode (cls, ustr):

611 return cls._CF_enumeration.valueForUnicode(ustr)

612

613 -class _WhiteSpace_enum (datatypes.NMTOKEN, _Enumeration_mixin):

614 """The enumeration used to constrain the whiteSpace facet""" 615 pass

616 _WhiteSpace_enum._CF_enumeration = CF_enumeration(value_datatype=_WhiteSpace_enum) 617 _WhiteSpace_enum.preserve = _WhiteSpace_enum._CF_enumeration.addEnumeration(unicode_value=six.u('preserve'), tag='preserve') 618 _WhiteSpace_enum.replace = _WhiteSpace_enum._CF_enumeration.addEnumeration(unicode_value=six.u('replace'), tag='replace') 619 _WhiteSpace_enum.collapse = _WhiteSpace_enum._CF_enumeration.addEnumeration(unicode_value=six.u('collapse'), tag='collapse') 620 # NOTE: For correctness we really need to initialize the facet map for 621 # WhiteSpace_enum, even though at the moment it isn't necessary. We 622 # can't right now, because its parent datatypes.NMTOKEN hasn't been 623 # initialized yet 624 _WhiteSpace_enum._InitializeFacetMap(_WhiteSpace_enum._CF_enumeration)

625 626 -class CF_whiteSpace (ConstrainingFacet, _Fixed_mixin):

627 """Specify the value-space interpretation of whitespace. 628 629 See U{http://www.w3.org/TR/xmlschema-2/#rf-whiteSpace} 630 """ 631 _Name = 'whiteSpace' 632 _ValueDatatype = _WhiteSpace_enum 633 634 __TabCRLF_re = re.compile("[\t\n\r]") 635 __MultiSpace_re = re.compile(" +")

636 - def normalizeString (self, value):

637 """Normalize the given string in accordance with the configured whitespace interpretation.""" 638 if self.value() is None: 639 return value 640 if self.value() == _WhiteSpace_enum.preserve: 641 return utility.NormalizeWhitespace(value, preserve=True) 642 if self.value() == _WhiteSpace_enum.replace: 643 return utility.NormalizeWhitespace(value, replace=True) 644 assert self.value() == _WhiteSpace_enum.collapse, 'Unexpected value "%s" for whiteSpace facet' % (self.value(),) 645 return utility.NormalizeWhitespace(value, collapse=True)

646

647 - def _validateConstraint_vx (self, value):

648 """No validation rules for whitespace facet.""" 649 return True

650

651 -class CF_minInclusive (ConstrainingFacet, _Fixed_mixin, _LateDatatype_mixin):

652 """Specify the minimum legal value for the constrained type. 653 654 See U{http://www.w3.org/TR/xmlschema-2/#rf-minInclusive} 655 """ 656 _Name = 'minInclusive' 657 _LateDatatypeBindsSuperclass = False 658

659 - def _validateConstraint_vx (self, value):

660 return (self.value() is None) or (self.value() <= value)

661

662 663 -class CF_maxInclusive (ConstrainingFacet, _Fixed_mixin, _LateDatatype_mixin):

664 """Specify the maximum legal value for the constrained type. 665 666 See U{http://www.w3.org/TR/xmlschema-2/#rf-maxInclusive} 667 """ 668 _Name = 'maxInclusive' 669 _LateDatatypeBindsSuperclass = False 670

671 - def _validateConstraint_vx (self, value):

672 return (self.value() is None) or (self.value() >= value)

673

674 -class CF_minExclusive (ConstrainingFacet, _Fixed_mixin, _LateDatatype_mixin):

675 """Specify the exclusive lower bound of legal values for the constrained type. 676 677 See U{http://www.w3.org/TR/xmlschema-2/#rf-minExclusive} 678 """ 679 _Name = 'minExclusive' 680 _LateDatatypeBindsSuperclass = True 681

682 - def _validateConstraint_vx (self, value):

683 return (self.value() is None) or (self.value() < value)

684

685 -class CF_maxExclusive (ConstrainingFacet, _Fixed_mixin, _LateDatatype_mixin):

686 """Specify the exclusive upper bound of legal values for the constrained type. 687 688 See U{http://www.w3.org/TR/xmlschema-2/#rf-maxExclusive} 689 """ 690 _Name = 'maxExclusive' 691 _LateDatatypeBindsSuperclass = True 692

693 - def _validateConstraint_vx (self, value):

694 return (self.value() is None) or (self.value() > value)

695

696 -class CF_totalDigits (ConstrainingFacet, _Fixed_mixin):

697 """Specify the number of digits in the *value* space of the type. 698 699 See U{http://www.w3.org/TR/xmlschema-2/#rf-totalDigits} 700 """ 701 _Name = 'totalDigits' 702 _ValueDatatype = datatypes.positiveInteger 703

704 - def _validateConstraint_vx (self, value):

705 if self.value() is None: 706 return True 707 if isinstance(value, datatypes.decimal): 708 (sign, digits, exponent) = value.normalize().as_tuple() 709 if len(digits) > self.value(): 710 return False 711 if 0 > exponent: 712 return -exponent <= self.value() 713 return (exponent + len(digits)) <= self.value() 714 n = 0 715 scale = 1 716 match = False 717 v = None 718 while (n <= self.value()) and (not match): 719 v = six.long_type(value * scale) 720 match = ((value * scale) == v) 721 if self.value() == n: 722 break 723 n += 1 724 scale *= 10 725 while n < self.value(): 726 n += 1 727 scale *= 10 728 return match and (v is not None) and (abs(v) < scale)

729

730 -class CF_fractionDigits (ConstrainingFacet, _Fixed_mixin):

731 """Specify the number of sub-unit digits in the *value* space of the type. 732 733 See U{http://www.w3.org/TR/xmlschema-2/#rf-fractionDigits} 734 """ 735 _Name = 'fractionDigits' 736 _ValueDatatype = datatypes.nonNegativeInteger 737

738 - def _validateConstraint_vx (self, value):

739 if self.value() is None: 740 return True 741 if isinstance(value, datatypes.decimal): 742 (sign, digits, exponent) = value.normalize().as_tuple() 743 return (0 <= exponent) or (-exponent <= self.value()) 744 n = 0 745 scale = 1 746 while n <= self.value(): 747 if ((value * scale) == six.long_type(value * scale)): 748 return True 749 n += 1 750 scale *= 10 751 return False

752

753 -class FundamentalFacet (Facet):

754 """A fundamental facet provides information on the value space of the associated type.""" 755 756 _FacetPrefix = 'FF' 757 758 @classmethod

759 - def CreateFromDOM (cls, node, owner_type_definition, base_type_definition=None):

760 facet_class = cls.ClassForFacet(node.getAttribute('name')) 761 rv = facet_class(base_type_definition=base_type_definition, 762 owner_type_definition=owner_type_definition) 763 rv.updateFromDOM(node)

764

765 - def updateFromDOM (self, node):

766 if not node.hasAttribute('name'): 767 raise pyxb.SchemaValidationError('No name attribute in facet') 768 assert node.getAttribute('name') == self.Name() 769 self._updateFromDOM(node)

770

771 - def _updateFromDOM (self, node):

772 try: 773 super(FundamentalFacet, self)._updateFromDOM(node) 774 except AttributeError: 775 pass 776 if (self.valueDatatype() is not None) and node.hasAttribute('value'): 777 self._value(self.valueDatatype()(node.getAttribute('value'))) 778 # @todo 779 self.__annotation = None 780 return self

781

782 -class FF_equal (FundamentalFacet):

783 """Specifies that the associated type supports a notion of equality. 784 785 See U{http://www.w3.org/TR/xmlschema-2/#equal} 786 """ 787 788 _Name = 'equal'

789

790 -class FF_ordered (FundamentalFacet):

791 """Specifies that the associated type supports a notion of order. 792 793 See U{http://www.w3.org/TR/xmlschema-2/#rf-ordered} 794 """ 795 796 _LegalValues = ( 'false', 'partial', 'total' ) 797 _Name = 'ordered' 798 _ValueDatatype = datatypes.string 799

800 - def __init__ (self, **kw):

801 # @todo: correct value type definition 802 super(FF_ordered, self).__init__(**kw)

803

804 -class FF_bounded (FundamentalFacet):

805 """Specifies that the associated type supports a notion of bounds. 806 807 See U{http://www.w3.org/TR/xmlschema-2/#rf-bounded} 808 """ 809 810 _Name = 'bounded' 811 _ValueDatatype = datatypes.boolean

812

813 -class FF_cardinality (FundamentalFacet):

814 """Specifies that the associated type supports a notion of length. 815 816 See U{http://www.w3.org/TR/xmlschema-2/#rf-cardinality} 817 """ 818 819 _LegalValues = ( 'finite', 'countably infinite' ) 820 _Name = 'cardinality' 821 _ValueDatatype = datatypes.string

822 - def __init__ (self, **kw):

823 # @todo correct value type definition 824 super(FF_cardinality, self).__init__(value_datatype=datatypes.string, **kw)

825

826 -class FF_numeric (FundamentalFacet):

827 """Specifies that the associated type represents a number. 828 829 See U{http://www.w3.org/TR/xmlschema-2/#rf-numeric} 830 """ 831 832 _Name = 'numeric' 833 _ValueDatatype = datatypes.boolean

834 835 # The fixed set of expected facets 836 ConstrainingFacet.Facets = [ 837 CF_length, CF_minLength, CF_maxLength, CF_pattern, CF_enumeration, 838 CF_whiteSpace, CF_minInclusive, CF_maxInclusive, CF_minExclusive, 839 CF_maxExclusive, CF_totalDigits, CF_fractionDigits ] 840 841 FundamentalFacet.Facets = [ 842 FF_equal, FF_ordered, FF_bounded, FF_cardinality, FF_numeric ] 843 844 Facet.Facets = [] 845 Facet.Facets.extend(ConstrainingFacet.Facets) 846 Facet.Facets.extend(FundamentalFacet.Facets) 847 848 # Facet details from a hacked generator reading the normative schema 849 # and only printing the facet-related code. 850 datatypes.ENTITIES._CF_pattern = CF_pattern() 851 datatypes.ENTITIES._CF_maxLength = CF_maxLength() 852 datatypes.ENTITIES._CF_enumeration = CF_enumeration(value_datatype=datatypes.ENTITIES) 853 datatypes.ENTITIES._CF_minLength = CF_minLength(value=datatypes.nonNegativeInteger(1)) 854 datatypes.ENTITIES._CF_whiteSpace = CF_whiteSpace() 855 datatypes.ENTITIES._CF_length = CF_length() 856 datatypes.ENTITIES._InitializeFacetMap(datatypes.ENTITIES._CF_pattern, 857 datatypes.ENTITIES._CF_maxLength, 858 datatypes.ENTITIES._CF_enumeration, 859 datatypes.ENTITIES._CF_minLength, 860 datatypes.ENTITIES._CF_whiteSpace, 861 datatypes.ENTITIES._CF_length) 862 datatypes.ENTITY._InitializeFacetMap() 863 datatypes.ID._InitializeFacetMap() 864 datatypes.IDREF._InitializeFacetMap() 865 datatypes.IDREFS._CF_pattern = CF_pattern() 866 datatypes.IDREFS._CF_maxLength = CF_maxLength() 867 datatypes.IDREFS._CF_enumeration = CF_enumeration(value_datatype=datatypes.IDREFS) 868 datatypes.IDREFS._CF_minLength = CF_minLength(value=datatypes.nonNegativeInteger(1)) 869 datatypes.IDREFS._CF_whiteSpace = CF_whiteSpace() 870 datatypes.IDREFS._CF_length = CF_length() 871 datatypes.IDREFS._InitializeFacetMap(datatypes.IDREFS._CF_pattern, 872 datatypes.IDREFS._CF_maxLength, 873 datatypes.IDREFS._CF_enumeration, 874 datatypes.IDREFS._CF_minLength, 875 datatypes.IDREFS._CF_whiteSpace, 876 datatypes.IDREFS._CF_length) 877 datatypes.NCName._CF_pattern = CF_pattern() 878 datatypes.NCName._CF_pattern.addPattern(pattern=six.u('[\\i-[:]][\\c-[:]]*')) 879 datatypes.NCName._InitializeFacetMap(datatypes.NCName._CF_pattern) 880 datatypes.NMTOKEN._CF_pattern = CF_pattern() 881 datatypes.NMTOKEN._CF_pattern.addPattern(pattern=six.u('\\c+')) 882 datatypes.NMTOKEN._InitializeFacetMap(datatypes.NMTOKEN._CF_pattern) 883 datatypes.NMTOKENS._CF_pattern = CF_pattern() 884 datatypes.NMTOKENS._CF_maxLength = CF_maxLength() 885 datatypes.NMTOKENS._CF_enumeration = CF_enumeration(value_datatype=datatypes.NMTOKENS) 886 datatypes.NMTOKENS._CF_minLength = CF_minLength(value=datatypes.nonNegativeInteger(1)) 887 datatypes.NMTOKENS._CF_whiteSpace = CF_whiteSpace() 888 datatypes.NMTOKENS._CF_length = CF_length() 889 datatypes.NMTOKENS._InitializeFacetMap(datatypes.NMTOKENS._CF_pattern, 890 datatypes.NMTOKENS._CF_maxLength, 891 datatypes.NMTOKENS._CF_enumeration, 892 datatypes.NMTOKENS._CF_minLength, 893 datatypes.NMTOKENS._CF_whiteSpace, 894 datatypes.NMTOKENS._CF_length) 895 datatypes.NOTATION._CF_minLength = CF_minLength() 896 datatypes.NOTATION._CF_maxLength = CF_maxLength() 897 datatypes.NOTATION._CF_enumeration = CF_enumeration(value_datatype=datatypes.NOTATION) 898 datatypes.NOTATION._CF_pattern = CF_pattern() 899 datatypes.NOTATION._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse) 900 datatypes.NOTATION._CF_length = CF_length() 901 datatypes.NOTATION._InitializeFacetMap(datatypes.NOTATION._CF_minLength, 902 datatypes.NOTATION._CF_maxLength, 903 datatypes.NOTATION._CF_enumeration, 904 datatypes.NOTATION._CF_pattern, 905 datatypes.NOTATION._CF_whiteSpace, 906 datatypes.NOTATION._CF_length) 907 datatypes.Name._CF_pattern = CF_pattern() 908 datatypes.Name._CF_pattern.addPattern(pattern=six.u('\\i\\c*')) 909 datatypes.Name._InitializeFacetMap(datatypes.Name._CF_pattern) 910 datatypes.QName._CF_minLength = CF_minLength() 911 datatypes.QName._CF_maxLength = CF_maxLength() 912 datatypes.QName._CF_enumeration = CF_enumeration(value_datatype=datatypes.QName) 913 datatypes.QName._CF_pattern = CF_pattern() 914 datatypes.QName._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse) 915 datatypes.QName._CF_length = CF_length() 916 datatypes.QName._InitializeFacetMap(datatypes.QName._CF_minLength, 917 datatypes.QName._CF_maxLength, 918 datatypes.QName._CF_enumeration, 919 datatypes.QName._CF_pattern, 920 datatypes.QName._CF_whiteSpace, 921 datatypes.QName._CF_length) 922 datatypes.anyURI._CF_minLength = CF_minLength() 923 datatypes.anyURI._CF_maxLength = CF_maxLength() 924 datatypes.anyURI._CF_enumeration = CF_enumeration(value_datatype=datatypes.anyURI) 925 datatypes.anyURI._CF_pattern = CF_pattern() 926 datatypes.anyURI._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse) 927 datatypes.anyURI._CF_length = CF_length() 928 datatypes.anyURI._InitializeFacetMap(datatypes.anyURI._CF_minLength, 929 datatypes.anyURI._CF_maxLength, 930 datatypes.anyURI._CF_enumeration, 931 datatypes.anyURI._CF_pattern, 932 datatypes.anyURI._CF_whiteSpace, 933 datatypes.anyURI._CF_length) 934 datatypes.base64Binary._CF_minLength = CF_minLength() 935 datatypes.base64Binary._CF_maxLength = CF_maxLength() 936 datatypes.base64Binary._CF_enumeration = CF_enumeration(value_datatype=datatypes.base64Binary) 937 datatypes.base64Binary._CF_pattern = CF_pattern() 938 datatypes.base64Binary._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse) 939 datatypes.base64Binary._CF_length = CF_length() 940 datatypes.base64Binary._InitializeFacetMap(datatypes.base64Binary._CF_minLength, 941 datatypes.base64Binary._CF_maxLength, 942 datatypes.base64Binary._CF_enumeration, 943 datatypes.base64Binary._CF_pattern, 944 datatypes.base64Binary._CF_whiteSpace, 945 datatypes.base64Binary._CF_length) 946 datatypes.boolean._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse) 947 datatypes.boolean._CF_pattern = CF_pattern() 948 datatypes.boolean._InitializeFacetMap(datatypes.boolean._CF_whiteSpace, 949 datatypes.boolean._CF_pattern) 950 datatypes.byte._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.byte, value=datatypes.anySimpleType(six.u('-128'))) 951 datatypes.byte._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.byte, value=datatypes.anySimpleType(six.u('127'))) 952 datatypes.byte._InitializeFacetMap(datatypes.byte._CF_minInclusive, 953 datatypes.byte._CF_maxInclusive) 954 datatypes.date._CF_pattern = CF_pattern() 955 datatypes.date._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.date) 956 datatypes.date._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType) 957 datatypes.date._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType) 958 datatypes.date._CF_enumeration = CF_enumeration(value_datatype=datatypes.date) 959 datatypes.date._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse) 960 datatypes.date._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.date) 961 datatypes.date._InitializeFacetMap(datatypes.date._CF_pattern, 962 datatypes.date._CF_minInclusive, 963 datatypes.date._CF_maxExclusive, 964 datatypes.date._CF_minExclusive, 965 datatypes.date._CF_enumeration, 966 datatypes.date._CF_whiteSpace, 967 datatypes.date._CF_maxInclusive) 968 datatypes.dateTime._CF_pattern = CF_pattern() 969 datatypes.dateTime._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.dateTime) 970 datatypes.dateTime._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType) 971 datatypes.dateTime._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType) 972 datatypes.dateTime._CF_enumeration = CF_enumeration(value_datatype=datatypes.dateTime) 973 datatypes.dateTime._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse) 974 datatypes.dateTime._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.dateTime) 975 datatypes.dateTime._InitializeFacetMap(datatypes.dateTime._CF_pattern, 976 datatypes.dateTime._CF_minInclusive, 977 datatypes.dateTime._CF_maxExclusive, 978 datatypes.dateTime._CF_minExclusive, 979 datatypes.dateTime._CF_enumeration, 980 datatypes.dateTime._CF_whiteSpace, 981 datatypes.dateTime._CF_maxInclusive) 982 datatypes.decimal._CF_totalDigits = CF_totalDigits() 983 datatypes.decimal._CF_pattern = CF_pattern() 984 datatypes.decimal._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.decimal) 985 datatypes.decimal._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType) 986 datatypes.decimal._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType) 987 datatypes.decimal._CF_enumeration = CF_enumeration(value_datatype=datatypes.decimal) 988 datatypes.decimal._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse) 989 datatypes.decimal._CF_fractionDigits = CF_fractionDigits() 990 datatypes.decimal._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.decimal) 991 datatypes.decimal._InitializeFacetMap(datatypes.decimal._CF_totalDigits, 992 datatypes.decimal._CF_pattern, 993 datatypes.decimal._CF_minInclusive, 994 datatypes.decimal._CF_maxExclusive, 995 datatypes.decimal._CF_minExclusive, 996 datatypes.decimal._CF_enumeration, 997 datatypes.decimal._CF_whiteSpace, 998 datatypes.decimal._CF_fractionDigits, 999 datatypes.decimal._CF_maxInclusive) 1000 datatypes.double._CF_pattern = CF_pattern() 1001 datatypes.double._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.double) 1002 datatypes.double._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType) 1003 datatypes.double._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType) 1004 datatypes.double._CF_enumeration = CF_enumeration(value_datatype=datatypes.double) 1005 datatypes.double._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse) 1006 datatypes.double._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.double) 1007 datatypes.double._InitializeFacetMap(datatypes.double._CF_pattern, 1008 datatypes.double._CF_minInclusive, 1009 datatypes.double._CF_maxExclusive, 1010 datatypes.double._CF_minExclusive, 1011 datatypes.double._CF_enumeration, 1012 datatypes.double._CF_whiteSpace, 1013 datatypes.double._CF_maxInclusive) 1014 datatypes.duration._CF_pattern = CF_pattern() 1015 datatypes.duration._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.duration) 1016 datatypes.duration._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType) 1017 datatypes.duration._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType) 1018 datatypes.duration._CF_enumeration = CF_enumeration(value_datatype=datatypes.duration) 1019 datatypes.duration._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse) 1020 datatypes.duration._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.duration) 1021 datatypes.duration._InitializeFacetMap(datatypes.duration._CF_pattern, 1022 datatypes.duration._CF_minInclusive, 1023 datatypes.duration._CF_maxExclusive, 1024 datatypes.duration._CF_minExclusive, 1025 datatypes.duration._CF_enumeration, 1026 datatypes.duration._CF_whiteSpace, 1027 datatypes.duration._CF_maxInclusive) 1028 datatypes.float._CF_pattern = CF_pattern() 1029 datatypes.float._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.float) 1030 datatypes.float._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType) 1031 datatypes.float._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType) 1032 datatypes.float._CF_enumeration = CF_enumeration(value_datatype=datatypes.float) 1033 datatypes.float._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse) 1034 datatypes.float._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.float) 1035 datatypes.float._InitializeFacetMap(datatypes.float._CF_pattern, 1036 datatypes.float._CF_minInclusive, 1037 datatypes.float._CF_maxExclusive, 1038 datatypes.float._CF_minExclusive, 1039 datatypes.float._CF_enumeration, 1040 datatypes.float._CF_whiteSpace, 1041 datatypes.float._CF_maxInclusive) 1042 datatypes.gDay._CF_pattern = CF_pattern() 1043 datatypes.gDay._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.gDay) 1044 datatypes.gDay._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType) 1045 datatypes.gDay._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType) 1046 datatypes.gDay._CF_enumeration = CF_enumeration(value_datatype=datatypes.gDay) 1047 datatypes.gDay._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse) 1048 datatypes.gDay._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.gDay) 1049 datatypes.gDay._InitializeFacetMap(datatypes.gDay._CF_pattern, 1050 datatypes.gDay._CF_minInclusive, 1051 datatypes.gDay._CF_maxExclusive, 1052 datatypes.gDay._CF_minExclusive, 1053 datatypes.gDay._CF_enumeration, 1054 datatypes.gDay._CF_whiteSpace, 1055 datatypes.gDay._CF_maxInclusive) 1056 datatypes.gMonth._CF_pattern = CF_pattern() 1057 datatypes.gMonth._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.gMonth) 1058 datatypes.gMonth._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType) 1059 datatypes.gMonth._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType) 1060 datatypes.gMonth._CF_enumeration = CF_enumeration(value_datatype=datatypes.gMonth) 1061 datatypes.gMonth._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse) 1062 datatypes.gMonth._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.gMonth) 1063 datatypes.gMonth._InitializeFacetMap(datatypes.gMonth._CF_pattern, 1064 datatypes.gMonth._CF_minInclusive, 1065 datatypes.gMonth._CF_maxExclusive, 1066 datatypes.gMonth._CF_minExclusive, 1067 datatypes.gMonth._CF_enumeration, 1068 datatypes.gMonth._CF_whiteSpace, 1069 datatypes.gMonth._CF_maxInclusive) 1070 datatypes.gMonthDay._CF_pattern = CF_pattern() 1071 datatypes.gMonthDay._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.gMonthDay) 1072 datatypes.gMonthDay._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType) 1073 datatypes.gMonthDay._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType) 1074 datatypes.gMonthDay._CF_enumeration = CF_enumeration(value_datatype=datatypes.gMonthDay) 1075 datatypes.gMonthDay._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse) 1076 datatypes.gMonthDay._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.gMonthDay) 1077 datatypes.gMonthDay._InitializeFacetMap(datatypes.gMonthDay._CF_pattern, 1078 datatypes.gMonthDay._CF_minInclusive, 1079 datatypes.gMonthDay._CF_maxExclusive, 1080 datatypes.gMonthDay._CF_minExclusive, 1081 datatypes.gMonthDay._CF_enumeration, 1082 datatypes.gMonthDay._CF_whiteSpace, 1083 datatypes.gMonthDay._CF_maxInclusive) 1084 datatypes.gYear._CF_pattern = CF_pattern() 1085 datatypes.gYear._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.gYear) 1086 datatypes.gYear._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType) 1087 datatypes.gYear._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType) 1088 datatypes.gYear._CF_enumeration = CF_enumeration(value_datatype=datatypes.gYear) 1089 datatypes.gYear._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse) 1090 datatypes.gYear._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.gYear) 1091 datatypes.gYear._InitializeFacetMap(datatypes.gYear._CF_pattern, 1092 datatypes.gYear._CF_minInclusive, 1093 datatypes.gYear._CF_maxExclusive, 1094 datatypes.gYear._CF_minExclusive, 1095 datatypes.gYear._CF_enumeration, 1096 datatypes.gYear._CF_whiteSpace, 1097 datatypes.gYear._CF_maxInclusive) 1098 datatypes.gYearMonth._CF_pattern = CF_pattern() 1099 datatypes.gYearMonth._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.gYearMonth) 1100 datatypes.gYearMonth._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType) 1101 datatypes.gYearMonth._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType) 1102 datatypes.gYearMonth._CF_enumeration = CF_enumeration(value_datatype=datatypes.gYearMonth) 1103 datatypes.gYearMonth._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse) 1104 datatypes.gYearMonth._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.gYearMonth) 1105 datatypes.gYearMonth._InitializeFacetMap(datatypes.gYearMonth._CF_pattern, 1106 datatypes.gYearMonth._CF_minInclusive, 1107 datatypes.gYearMonth._CF_maxExclusive, 1108 datatypes.gYearMonth._CF_minExclusive, 1109 datatypes.gYearMonth._CF_enumeration, 1110 datatypes.gYearMonth._CF_whiteSpace, 1111 datatypes.gYearMonth._CF_maxInclusive) 1112 datatypes.hexBinary._CF_minLength = CF_minLength() 1113 datatypes.hexBinary._CF_maxLength = CF_maxLength() 1114 datatypes.hexBinary._CF_enumeration = CF_enumeration(value_datatype=datatypes.hexBinary) 1115 datatypes.hexBinary._CF_pattern = CF_pattern() 1116 datatypes.hexBinary._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse) 1117 datatypes.hexBinary._CF_length = CF_length() 1118 datatypes.hexBinary._InitializeFacetMap(datatypes.hexBinary._CF_minLength, 1119 datatypes.hexBinary._CF_maxLength, 1120 datatypes.hexBinary._CF_enumeration, 1121 datatypes.hexBinary._CF_pattern, 1122 datatypes.hexBinary._CF_whiteSpace, 1123 datatypes.hexBinary._CF_length) 1124 datatypes.int._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.int, value=datatypes.anySimpleType(six.u('-2147483648'))) 1125 datatypes.int._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.int, value=datatypes.anySimpleType(six.u('2147483647'))) 1126 datatypes.int._InitializeFacetMap(datatypes.int._CF_minInclusive, 1127 datatypes.int._CF_maxInclusive) 1128 datatypes.integer._CF_pattern = CF_pattern() 1129 datatypes.integer._CF_pattern.addPattern(pattern=six.u('[\\-+]?[0-9]+')) 1130 datatypes.integer._CF_fractionDigits = CF_fractionDigits(value=datatypes.nonNegativeInteger(0)) 1131 datatypes.integer._InitializeFacetMap(datatypes.integer._CF_pattern, 1132 datatypes.integer._CF_fractionDigits) 1133 datatypes.language._CF_pattern = CF_pattern() 1134 datatypes.language._CF_pattern.addPattern(pattern=six.u('[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*')) 1135 datatypes.language._InitializeFacetMap(datatypes.language._CF_pattern) 1136 datatypes.long._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.long, value=datatypes.anySimpleType(six.u('-9223372036854775808'))) 1137 datatypes.long._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.long, value=datatypes.anySimpleType(six.u('9223372036854775807'))) 1138 datatypes.long._InitializeFacetMap(datatypes.long._CF_minInclusive, 1139 datatypes.long._CF_maxInclusive) 1140 datatypes.negativeInteger._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.negativeInteger, value=datatypes.anySimpleType(six.u('-1'))) 1141 datatypes.negativeInteger._InitializeFacetMap(datatypes.negativeInteger._CF_maxInclusive) 1142 datatypes.nonNegativeInteger._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.nonNegativeInteger, value=datatypes.anySimpleType(six.u('0'))) 1143 datatypes.nonNegativeInteger._InitializeFacetMap(datatypes.nonNegativeInteger._CF_minInclusive) 1144 datatypes.nonPositiveInteger._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.nonPositiveInteger, value=datatypes.anySimpleType(six.u('0'))) 1145 datatypes.nonPositiveInteger._InitializeFacetMap(datatypes.nonPositiveInteger._CF_maxInclusive) 1146 datatypes.normalizedString._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.replace) 1147 datatypes.normalizedString._InitializeFacetMap(datatypes.normalizedString._CF_whiteSpace) 1148 datatypes.positiveInteger._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.positiveInteger, value=datatypes.anySimpleType(six.u('1'))) 1149 datatypes.positiveInteger._InitializeFacetMap(datatypes.positiveInteger._CF_minInclusive) 1150 datatypes.short._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.short, value=datatypes.anySimpleType(six.u('-32768'))) 1151 datatypes.short._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.short, value=datatypes.anySimpleType(six.u('32767'))) 1152 datatypes.short._InitializeFacetMap(datatypes.short._CF_minInclusive, 1153 datatypes.short._CF_maxInclusive) 1154 datatypes.string._CF_minLength = CF_minLength() 1155 datatypes.string._CF_maxLength = CF_maxLength() 1156 datatypes.string._CF_enumeration = CF_enumeration(value_datatype=datatypes.string) 1157 datatypes.string._CF_pattern = CF_pattern() 1158 datatypes.string._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.preserve) 1159 datatypes.string._CF_length = CF_length() 1160 datatypes.string._InitializeFacetMap(datatypes.string._CF_minLength, 1161 datatypes.string._CF_maxLength, 1162 datatypes.string._CF_enumeration, 1163 datatypes.string._CF_pattern, 1164 datatypes.string._CF_whiteSpace, 1165 datatypes.string._CF_length) 1166 datatypes.time._CF_pattern = CF_pattern() 1167 datatypes.time._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.time) 1168 datatypes.time._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType) 1169 datatypes.time._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType) 1170 datatypes.time._CF_enumeration = CF_enumeration(value_datatype=datatypes.time) 1171 datatypes.time._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse) 1172 datatypes.time._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.time) 1173 datatypes.time._InitializeFacetMap(datatypes.time._CF_pattern, 1174 datatypes.time._CF_minInclusive, 1175 datatypes.time._CF_maxExclusive, 1176 datatypes.time._CF_minExclusive, 1177 datatypes.time._CF_enumeration, 1178 datatypes.time._CF_whiteSpace, 1179 datatypes.time._CF_maxInclusive) 1180 datatypes.token._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse) 1181 datatypes.token._InitializeFacetMap(datatypes.token._CF_whiteSpace) 1182 datatypes.unsignedByte._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.unsignedByte, value=datatypes.anySimpleType(six.u('255'))) 1183 datatypes.unsignedByte._InitializeFacetMap(datatypes.unsignedByte._CF_maxInclusive) 1184 datatypes.unsignedInt._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.unsignedInt, value=datatypes.anySimpleType(six.u('4294967295'))) 1185 datatypes.unsignedInt._InitializeFacetMap(datatypes.unsignedInt._CF_maxInclusive) 1186 datatypes.unsignedLong._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.unsignedLong, value=datatypes.anySimpleType(six.u('18446744073709551615'))) 1187 datatypes.unsignedLong._InitializeFacetMap(datatypes.unsignedLong._CF_maxInclusive) 1188 datatypes.unsignedShort._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.unsignedShort, value=datatypes.anySimpleType(six.u('65535'))) 1189 datatypes.unsignedShort._InitializeFacetMap(datatypes.unsignedShort._CF_maxInclusive) 1190