# -*- coding: utf-8 -*-
# Copyright 2009-2013, Peter A. Bigot
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain a
# copy of the License at:
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""Classes related to XMLSchema facets.
The definitions herein are from sections U{4.2<http://www.w3.org/TR/xmlschema-2/index.html#rf-facets>}
and U{4.3<http://www.w3.org/TR/xmlschema-2/index.html#rf-facets>} of
U{XML Schema Part 2: Datatypes<http://www.w3.org/TR/xmlschema-2/>}.
Facets are attributes of a datatype that constrain its lexical and
value spaces.
"""
import logging
import re
import decimal
import pyxb
from . import datatypes
from . import basis
from pyxb.utils import utility, six
_log = logging.getLogger(__name__)
class Facet (pyxb.cscRoot):
"""The base class for facets.
This provides association with STDs, a name, and a value for the facet.
"""
_Name = None
@classmethod
def Name (self):
"""The name of a facet is a class constant."""
return self._Name
__baseTypeDefinition = None
def baseTypeDefinition (self):
"""The SimpleTypeDefinition component restricted by this facet.
Note: this is NOT the STD to which the facet belongs, but is
usually that STD's base type. I.e., this jumps us through all
the containing restrictions and extensions to get to the core
type definition."""
return self.__baseTypeDefinition
__ownerTypeDefinition = None
def ownerTypeDefinition (self):
"""The SimpleTypeDefinition component to which this facet belongs.
I.e., the one in which the hasFacet specification was found.
This value is None if the facet is not associated with an
STD."""
return self.__ownerTypeDefinition
# The default valueDatatype to use for instances of this class.
# This is overridden in subclasses that do not use late value
# datatype bindings.
_ValueDatatype = None
# The datatype used for facet values.
__valueDatatype = None
def valueDatatype (self):
"""Get the datatype used to represent values of the facet.
This usually has nothing to do with the owner datatype; for
example, the length facet may apply to any STD but the value
of the facet is an integer. In generated bindings this is
usually set explicitly in the facet constructor; when
processing a schema, it is derived from the value's type
definition.
"""
if self.__valueDatatype is None:
assert self.baseTypeDefinition() is not None
return self.baseTypeDefinition().pythonSupport()
return self.__valueDatatype
__value = None
def _value (self, v): self.__value = v
def value (self): return self.__value
__annotation = None
def annotation (self): return self.__annotation
def __init__ (self, **kw):
"""Create a facet instance, initializing it from the keyword parameters."""
super(Facet, self).__init__(**kw)
# Can't create base class instances
assert Facet != self.__class__
self.setFromKeywords(_reset=True, _constructor=True, **kw)
def _setFromKeywords_vb (self, **kw):
"""Configure values of the facet from a set of keywords.
This method is pre-extended; subclasses should invoke the
parent method after setting their local configuration.
@keyword _reset: If C{False} or missing, existing values will
be retained if they do not appear in the
keywords. If C{True}, members not defined in
the keywords are set to a default.
@keyword base_type_definition:
@keyword owner_type_definition:
@keyword value_datatype:
"""
if not kw.get('_reset', False):
kw.setdefault('base_type_definition', self.__baseTypeDefinition)
kw.setdefault('owner_type_definition', self.__ownerTypeDefinition)
kw.setdefault('value_datatype', self.__valueDatatype)
self.__baseTypeDefinition = kw.get('base_type_definition')
self.__ownerTypeDefinition = kw.get('owner_type_definition')
self.__valueDatatype = kw.get('value_datatype', self._ValueDatatype)
# Verify that there's enough information that we should be
# able to identify a PST suitable for representing facet
# values.
assert (self.__valueDatatype is not None) or (self.__baseTypeDefinition is not None)
super_fn = getattr(super(Facet, self), '_setFromKeywords_vb', lambda *a,**kw: self)
return super_fn(**kw)
def setFromKeywords (self, **kw):
"""Public entrypoint to the _setFromKeywords_vb call hierarchy."""
return self._setFromKeywords_vb(**kw)
@classmethod
def ClassForFacet (cls, name):
"""Given the name of a facet, return the Facet subclass that represents it."""
assert cls != Facet
if 0 <= name.find(':'):
name = name.split(':', 1)[1]
facet_class = globals().get('%s_%s' % (cls._FacetPrefix, name))
if facet_class is None:
raise pyxb.LogicError('Unrecognized facet name %s: expect %s' % (name, ','.join([_f._Name for _f in cls.Facets])))
assert facet_class is not None
return facet_class
def _valueString (self):
if isinstance(self, _CollectionFacet_mixin):
return six.u(',').join([ six.text_type(_i) for _i in six.iteritems(self) ])
if (self.valueDatatype() is not None) and (self.value() is not None):
try:
return self.valueDatatype().XsdLiteral(self.value())
except Exception:
_log.exception('Stringize facet %s produced exception', self.Name())
raise
return six.text_type(self.value())
def __str__ (self):
rv = []
rv.append('%s="%s"' % (self.Name(), self._valueString()))
if isinstance(self, _Fixed_mixin) and self.fixed():
rv.append('[fixed]')
return ''.join(rv)
class ConstrainingFacet (Facet):
"""One of the facets defined in section 4.3, which provide
constraints on the lexical space of a type definition."""
# The prefix used for Python classes used for a constraining
# facet. Note that this is not the prefix used when generating a
# Python class member that specifies a constraining instance, even
# if it happens to be the same digraph.
_FacetPrefix = 'CF'
def __init__ (self, **kw):
super(ConstrainingFacet, self).__init__(**kw)
def _validateConstraint_vx (self, value):
raise pyxb.LogicError("Facet %s does not implement constraints" % (self.Name(),))
def validateConstraint (self, value):
"""Return True iff the given value satisfies the constraint represented by this facet instance.
The actual test is delegated to the subclasses."""
return self._validateConstraint_vx(value)
def __setFromKeywords(self, **kw):
kwv = kw.get('value')
if kwv is not None:
vdt = self.valueDatatype()
if not isinstance(kwv, vdt):
kwv = vdt(kwv)
self._value(kwv)
def _setFromKeywords_vb (self, **kw):
"""Extend base class.
Additional keywords:
* value
"""
# NB: This uses post-extension because it makes reference to the value_data_type
super_fn = getattr(super(ConstrainingFacet, self), '_setFromKeywords_vb', lambda *a,**kw: self)
rv = super_fn(**kw)
self.__setFromKeywords(**kw)
return rv
class _LateDatatype_mixin (pyxb.cscRoot):
"""Marker class to indicate that the facet instance must be told
its datatype when it is constructed.
This is necessary for facets like L{CF_minInclusive} and
L{CF_minExclusive}, for which the value is determined by the base
type definition of the associated STD. In some cases the value
that must be used in the facet cannot be represented in the Python
type used for the facet; see L{LateDatatypeBindsSuperclass}.
"""
_LateDatatypeBindsSuperclass = None
"""The class variable that indicates that the Subclasses must
override this variable with a value of C{True} or C{False}. The
value is C{True} iff the value used for the facet is not within
the value space of the corresponding value datatype; for example,
L{CF_minExclusive}."""
@classmethod
def LateDatatypeBindsSuperclass (cls):
"""Return true if false if the proposed datatype should be
used, or True if the base type definition of the proposed
datatype should be used."""
if cls._LateDatatypeBindsSuperclass is None:
raise pyxb.LogicError('Class %s did not set _LateDatatypeBindsSuperclass variable.')
return cls._LateDatatypeBindsSuperclass
@classmethod
def BindingValueDatatype (cls, value_type):
"""Find the datatype for facet values when this facet is bound
to the given value_type.
If the C{value_type} is an STD, the associated Python support
datatype from this value_type scanning up through the base
type hierarchy is used.
"""
import pyxb.xmlschema.structures as structures
if isinstance(value_type, structures.SimpleTypeDefinition):
# Back up until we find something that actually has a
# datatype
while not value_type.hasPythonSupport():
value_type = value_type.baseTypeDefinition()
value_type = value_type.pythonSupport()
assert issubclass(value_type, basis.simpleTypeDefinition)
if cls.LateDatatypeBindsSuperclass():
value_type = value_type.XsdSuperType()
return value_type
def bindValueDatatype (self, value_datatype):
self.setFromKeywords(_constructor=True, value_datatype=self.BindingValueDatatype(value_datatype))
class _Fixed_mixin (pyxb.cscRoot):
"""Mix-in to a constraining facet that adds support for the 'fixed' property."""
__fixed = None
def fixed (self): return self.__fixed
def __setFromKeywords (self, **kw):
if kw.get('_reset', False):
self.__fixed = None
kwv = kw.get('fixed')
if kwv is not None:
self.__fixed = datatypes.boolean(kwv)
def _setFromKeywords_vb (self, **kw):
"""Extend base class.
Additional keywords:
* fixed
"""
self.__setFromKeywords(**kw)
super_fn = getattr(super(_Fixed_mixin, self), '_setFromKeywords_vb', lambda *a,**kw: self)
return super_fn(**kw)
class _CollectionFacet_mixin (pyxb.cscRoot):
"""Mix-in to handle facets whose values are collections, not scalars.
For example, the enumeration and pattern facets maintain a list of
enumeration values and patterns, respectively, as their value
space.
Subclasses must define a class variable _CollectionFacet_itemType
which is a reference to a class that is used to construct members
of the collection.
"""
__items = None
def _setFromKeywords_vb (self, **kw):
"""Extend base class.
@keyword _constructor: If C{False} or absent, the object being
set is a member of the collection. If
C{True}, the object being set is the
collection itself.
"""
if kw.get('_reset', False):
self.__items = []
if not kw.get('_constructor', False):
self.__items.append(self._CollectionFacet_itemType(facet_instance=self, **kw))
super_fn = getattr(super(_CollectionFacet_mixin, self), '_setFromKeywords_vb', lambda *a,**kw: self)
return super_fn(**kw)
def _items (self):
"""The members of the collection, as a reference."""
return self.__items
def items (self):
"""The members of the collection, as a copy."""
return self.__items[:]
def iteritems (self):
"""The members of the collection as an iterator"""
return iter(self.__items)
class CF_length (ConstrainingFacet, _Fixed_mixin):
"""A facet that specifies the length of the lexical representation of a value.
See U{http://www.w3.org/TR/xmlschema-2/#rf-length}
"""
_Name = 'length'
_ValueDatatype = datatypes.nonNegativeInteger
def _validateConstraint_vx (self, value):
value_length = value.xsdValueLength()
return (value_length is None) or (self.value() is None) or (value_length == self.value())
class CF_minLength (ConstrainingFacet, _Fixed_mixin):
"""A facet that constrains the length of the lexical representation of a value.
See U{http://www.w3.org/TR/xmlschema-2/#rf-minLength}
"""
_Name = 'minLength'
_ValueDatatype = datatypes.nonNegativeInteger
def _validateConstraint_vx (self, value):
value_length = value.xsdValueLength()
return (value_length is None) or (self.value() is None) or (value_length >= self.value())
class CF_maxLength (ConstrainingFacet, _Fixed_mixin):
"""A facet that constrains the length of the lexical representation of a value.
See U{http://www.w3.org/TR/xmlschema-2/#rf-minLength}
"""
_Name = 'maxLength'
_ValueDatatype = datatypes.nonNegativeInteger
def _validateConstraint_vx (self, value):
value_length = value.xsdValueLength()
return (value_length is None) or (self.value() is None) or (value_length <= self.value())
import pyxb.utils.xmlre
class _PatternElement (utility.PrivateTransient_mixin):
"""This class represents individual patterns that appear within a CF_pattern collection."""
# The compiled regular expression is marked transient because we
# normally do development with Python 2.5, and consequently save
# the pickled namespace archives that go into the distribution
# with that version. Compiled regular expressions in Python 2.5
# include a reference to the re._compile method, which does not
# exist in Python 2.4. As a result, attempts to load a namespace
# which includes types with pattern restrictions fail.
__PrivateTransient = set()
__compiledExpression = None
__PrivateTransient.add('compiledExpression')
__pythonExpression = None
pattern = None
annotation = None
def __init__ (self, pattern=None, value=None, annotation=None, **kw):
if pattern is None:
assert value is not None
pattern = value
assert isinstance(pattern, six.string_types)
self.pattern = pattern
if isinstance(annotation, six.string_types):
self.annotation = annotation
self.__pythonExpression = pyxb.utils.xmlre.XMLToPython(pattern)
super(_PatternElement, self).__init__()
def __str__ (self): return self.pattern
def matches (self, text):
if self.__compiledExpression is None:
self.__compiledExpression = re.compile(self.__pythonExpression)
return self.__compiledExpression.match(text)
class CF_pattern (ConstrainingFacet, _CollectionFacet_mixin):
"""A facet that constrains the lexical representation of a value
to match one of a set of patterns.
See U{http://www.w3.org/TR/xmlschema-2/#rf-pattern}
@note: In PyXB, pattern constraints are ignored for any type with
a Python representation that does not derive from a string type.
This is due to the difficulty in reconstructing the lexical
representation of a non-string type after it has been converted to
its value space.
@todo: On creating new instances of non-string simple types from
string representations, we could apply pattern constraints. That
would mean checking them prior to invoking the Factory method.
"""
_Name = 'pattern'
_CollectionFacet_itemType = _PatternElement
_ValueDatatype = datatypes.string
__patternElements = None
def patternElements (self): return self.__patternElements
def __init__ (self, **kw):
super(CF_pattern, self).__init__(**kw)
self.__patternElements = []
def addPattern (self, **kw):
pattern = self._CollectionFacet_itemType(**kw)
self.__patternElements.append(pattern)
return pattern
def _validateConstraint_vx (self, value):
# If validation is inhibited, or if the facet hasn't had any
# restrictions applied yet, return True.
if 0 == len(self.__patternElements):
return True
if not isinstance(value, six.string_types):
# Ignore pattern constraint when value space and lexical
# space differ.
return True
for pe in self.__patternElements:
if pe.matches(value):
return True
return False
@six.python_2_unicode_compatible
class _EnumerationElement (object):
"""This class represents individual values that appear within a
L{CF_enumeration} collection."""
__value = None
def value (self):
"""The Python value that is used for equality testing
against this enumeration.
This is an instance of L{enumeration.valueDatatype()<CF_enumeration.valueDatatype>},
initialized from the unicodeValue."""
return self.__value
__tag = None
def tag (self):
"""The Python identifier used for the named constant representing
the enumeration value.
This should include any desired prefix, since it must be
unique within its binding class. If C{None}, no enumeration
constant will be generated."""
return self.__tag
def _setTag (self, tag):
"""Set the tag to be used for this enumeration."""
self.__tag = tag
__enumeration = None
def enumeration (self):
"""A reference to the L{CF_enumeration} instance that owns this element."""
return self.__enumeration
__unicodeValue = None
def unicodeValue (self):
"""The unicode string that defines the enumeration value."""
return self.__unicodeValue
def __init__ (self, enumeration=None, unicode_value=None,
description=None, annotation=None, tag=None,
**kw):
# The preferred keyword is "unicode_value", but when being
# generically applied by
# structures.SimpleTypeDefinition.__updateFacets, the unicode
# value comes in through the keyword "value". Similarly for
# "enumeration" and "facet_instance".
value = kw.get('value', unicode_value)
if unicode_value is None:
unicode_value = value
if enumeration is None:
enumeration = kw['facet_instance']
self.__unicodeValue = unicode_value
self.__enumeration = enumeration
self.__description = description
self.__annotation = annotation
self.__tag = tag
assert self.__enumeration is not None
value_datatype = self.enumeration().valueDatatype()
self.__value = value_datatype.Factory(value, _validate_constraints=False, _from_xml=True)
if (self.__description is None) and (self.__annotation is not None):
self.__description = six.text_type(self.__annotation)
def __str__ (self):
return utility.QuotedEscaped(self.unicodeValue())
class CF_enumeration (ConstrainingFacet, _CollectionFacet_mixin, _LateDatatype_mixin):
"""Capture a constraint that restricts valid values to a fixed set.
A STD that has an enumeration restriction should mix-in
L{pyxb.binding.basis.enumeration_mixin}, and should have a class
variable titled C{_CF_enumeration} that is an instance of this
class.
"unicode" refers to the Unicode string by which the value is
represented in XML.
"tag" refers to the Python member reference associated with the
enumeration. The value is derived from the unicode value of the
enumeration element and an optional prefix that identifies the
owning simple type when the tag is promoted to module-level
visibility.
"value" refers to the Python value held in the tag
See U{http://www.w3.org/TR/xmlschema-2/#rf-enumeration}
"""
_Name = 'enumeration'
_CollectionFacet_itemType = _EnumerationElement
_LateDatatypeBindsSuperclass = False
__tagToElement = None
__valueToElement = None
__unicodeToElement = None
# The prefix to be used when making enumeration tags visible at
# the module level. If None, tags are not made visible.
__enumPrefix = None
def __init__ (self, **kw):
super(CF_enumeration, self).__init__(**kw)
self.__enumPrefix = kw.get('enum_prefix', self.__enumPrefix)
self.__tagToElement = { }
self.__valueToElement = { }
self.__unicodeToElement = { }
def enumPrefix (self):
return self.__enumPrefix
def elements (self):
"""@deprecated: Use L{items} or L{iteritems} instead."""
return list(six.iteritems(self))
def values (self):
"""Return a list of enumeration values."""
return [ _ee.value() for _ee in six.iteritems(self) ]
def itervalues (self):
"""Generate the enumeration values."""
for ee in six.iteritems(self):
yield ee.value()
def addEnumeration (self, **kw):
kw['enumeration'] = self
ee = _EnumerationElement(**kw)
assert not (ee.tag in self.__tagToElement)
self.__tagToElement[ee.tag()] = ee
self.__unicodeToElement[ee.unicodeValue()] = ee
value = ee.value()
# Not just issubclass(self.valueDatatype(), basis.STD_list);
# this may be a union with one of those as a member type.
if isinstance(value, list):
value = ' '.join([ _v.xsdLiteral() for _v in value ])
self.__valueToElement[value] = ee
self._items().append(ee)
return value
def elementForValue (self, value):
"""Return the L{_EnumerationElement} instance that has the given value.
@raise KeyError: the value is not valid for the enumeration."""
return self.__valueToElement[value]
def valueForUnicode (self, ustr):
"""Return the enumeration value corresponding to the given unicode string.
If ustr is not a valid option for this enumeration, return None."""
rv = self.__unicodeToElement.get(ustr)
if rv is not None:
rv = rv.value()
return rv
def _validateConstraint_vx (self, value):
# If validation is inhibited, or if the facet hasn't had any
# restrictions applied yet, return True.
if 0 == len(self._items()):
return True
for ee in six.iteritems(self):
if ee.value() == value:
return True
return False
class _Enumeration_mixin (pyxb.cscRoot):
"""Marker class to indicate that the generated binding has enumeration members."""
@classmethod
def valueForUnicode (cls, ustr):
return cls._CF_enumeration.valueForUnicode(ustr)
class _WhiteSpace_enum (datatypes.NMTOKEN, _Enumeration_mixin):
"""The enumeration used to constrain the whiteSpace facet"""
pass
_WhiteSpace_enum._CF_enumeration = CF_enumeration(value_datatype=_WhiteSpace_enum)
_WhiteSpace_enum.preserve = _WhiteSpace_enum._CF_enumeration.addEnumeration(unicode_value=six.u('preserve'), tag='preserve')
_WhiteSpace_enum.replace = _WhiteSpace_enum._CF_enumeration.addEnumeration(unicode_value=six.u('replace'), tag='replace')
_WhiteSpace_enum.collapse = _WhiteSpace_enum._CF_enumeration.addEnumeration(unicode_value=six.u('collapse'), tag='collapse')
# NOTE: For correctness we really need to initialize the facet map for
# WhiteSpace_enum, even though at the moment it isn't necessary. We
# can't right now, because its parent datatypes.NMTOKEN hasn't been
# initialized yet
_WhiteSpace_enum._InitializeFacetMap(_WhiteSpace_enum._CF_enumeration)
class CF_whiteSpace (ConstrainingFacet, _Fixed_mixin):
"""Specify the value-space interpretation of whitespace.
See U{http://www.w3.org/TR/xmlschema-2/#rf-whiteSpace}
"""
_Name = 'whiteSpace'
_ValueDatatype = _WhiteSpace_enum
__TabCRLF_re = re.compile("[\t\n\r]")
__MultiSpace_re = re.compile(" +")
def normalizeString (self, value):
"""Normalize the given string in accordance with the configured whitespace interpretation."""
if self.value() is None:
return value
if self.value() == _WhiteSpace_enum.preserve:
return utility.NormalizeWhitespace(value, preserve=True)
if self.value() == _WhiteSpace_enum.replace:
return utility.NormalizeWhitespace(value, replace=True)
assert self.value() == _WhiteSpace_enum.collapse, 'Unexpected value "%s" for whiteSpace facet' % (self.value(),)
return utility.NormalizeWhitespace(value, collapse=True)
def _validateConstraint_vx (self, value):
"""No validation rules for whitespace facet."""
return True
class CF_minInclusive (ConstrainingFacet, _Fixed_mixin, _LateDatatype_mixin):
"""Specify the minimum legal value for the constrained type.
See U{http://www.w3.org/TR/xmlschema-2/#rf-minInclusive}
"""
_Name = 'minInclusive'
_LateDatatypeBindsSuperclass = False
def _validateConstraint_vx (self, value):
return (self.value() is None) or (self.value() <= value)
class CF_maxInclusive (ConstrainingFacet, _Fixed_mixin, _LateDatatype_mixin):
"""Specify the maximum legal value for the constrained type.
See U{http://www.w3.org/TR/xmlschema-2/#rf-maxInclusive}
"""
_Name = 'maxInclusive'
_LateDatatypeBindsSuperclass = False
def _validateConstraint_vx (self, value):
return (self.value() is None) or (self.value() >= value)
class CF_minExclusive (ConstrainingFacet, _Fixed_mixin, _LateDatatype_mixin):
"""Specify the exclusive lower bound of legal values for the constrained type.
See U{http://www.w3.org/TR/xmlschema-2/#rf-minExclusive}
"""
_Name = 'minExclusive'
_LateDatatypeBindsSuperclass = True
def _validateConstraint_vx (self, value):
return (self.value() is None) or (self.value() < value)
class CF_maxExclusive (ConstrainingFacet, _Fixed_mixin, _LateDatatype_mixin):
"""Specify the exclusive upper bound of legal values for the constrained type.
See U{http://www.w3.org/TR/xmlschema-2/#rf-maxExclusive}
"""
_Name = 'maxExclusive'
_LateDatatypeBindsSuperclass = True
def _validateConstraint_vx (self, value):
return (self.value() is None) or (self.value() > value)
class CF_totalDigits (ConstrainingFacet, _Fixed_mixin):
"""Specify the number of digits in the *value* space of the type.
See U{http://www.w3.org/TR/xmlschema-2/#rf-totalDigits}
"""
_Name = 'totalDigits'
_ValueDatatype = datatypes.positiveInteger
def _validateConstraint_vx (self, value):
if self.value() is None:
return True
if isinstance(value, datatypes.decimal):
(sign, digits, exponent) = value.normalize().as_tuple()
if len(digits) > self.value():
return False
if 0 > exponent:
return -exponent <= self.value()
return (exponent + len(digits)) <= self.value()
n = 0
scale = 1
match = False
v = None
while (n <= self.value()) and (not match):
v = six.long_type(value * scale)
match = ((value * scale) == v)
if self.value() == n:
break
n += 1
scale *= 10
while n < self.value():
n += 1
scale *= 10
return match and (v is not None) and (abs(v) < scale)
class CF_fractionDigits (ConstrainingFacet, _Fixed_mixin):
"""Specify the number of sub-unit digits in the *value* space of the type.
See U{http://www.w3.org/TR/xmlschema-2/#rf-fractionDigits}
"""
_Name = 'fractionDigits'
_ValueDatatype = datatypes.nonNegativeInteger
def _validateConstraint_vx (self, value):
if self.value() is None:
return True
if isinstance(value, datatypes.decimal):
(sign, digits, exponent) = value.normalize().as_tuple()
return (0 <= exponent) or (-exponent <= self.value())
n = 0
scale = 1
while n <= self.value():
if ((value * scale) == six.long_type(value * scale)):
return True
n += 1
scale *= 10
return False
class FundamentalFacet (Facet):
"""A fundamental facet provides information on the value space of the associated type."""
_FacetPrefix = 'FF'
@classmethod
def CreateFromDOM (cls, node, owner_type_definition, base_type_definition=None):
facet_class = cls.ClassForFacet(node.getAttribute('name'))
rv = facet_class(base_type_definition=base_type_definition,
owner_type_definition=owner_type_definition)
rv.updateFromDOM(node)
def updateFromDOM (self, node):
if not node.hasAttribute('name'):
raise pyxb.SchemaValidationError('No name attribute in facet')
assert node.getAttribute('name') == self.Name()
self._updateFromDOM(node)
def _updateFromDOM (self, node):
try:
super(FundamentalFacet, self)._updateFromDOM(node)
except AttributeError:
pass
if (self.valueDatatype() is not None) and node.hasAttribute('value'):
self._value(self.valueDatatype()(node.getAttribute('value')))
# @todo
self.__annotation = None
return self
class FF_equal (FundamentalFacet):
"""Specifies that the associated type supports a notion of equality.
See U{http://www.w3.org/TR/xmlschema-2/#equal}
"""
_Name = 'equal'
class FF_ordered (FundamentalFacet):
"""Specifies that the associated type supports a notion of order.
See U{http://www.w3.org/TR/xmlschema-2/#rf-ordered}
"""
_LegalValues = ( 'false', 'partial', 'total' )
_Name = 'ordered'
_ValueDatatype = datatypes.string
def __init__ (self, **kw):
# @todo: correct value type definition
super(FF_ordered, self).__init__(**kw)
class FF_bounded (FundamentalFacet):
"""Specifies that the associated type supports a notion of bounds.
See U{http://www.w3.org/TR/xmlschema-2/#rf-bounded}
"""
_Name = 'bounded'
_ValueDatatype = datatypes.boolean
class FF_cardinality (FundamentalFacet):
"""Specifies that the associated type supports a notion of length.
See U{http://www.w3.org/TR/xmlschema-2/#rf-cardinality}
"""
_LegalValues = ( 'finite', 'countably infinite' )
_Name = 'cardinality'
_ValueDatatype = datatypes.string
def __init__ (self, **kw):
# @todo correct value type definition
super(FF_cardinality, self).__init__(value_datatype=datatypes.string, **kw)
class FF_numeric (FundamentalFacet):
"""Specifies that the associated type represents a number.
See U{http://www.w3.org/TR/xmlschema-2/#rf-numeric}
"""
_Name = 'numeric'
_ValueDatatype = datatypes.boolean
# The fixed set of expected facets
ConstrainingFacet.Facets = [
CF_length, CF_minLength, CF_maxLength, CF_pattern, CF_enumeration,
CF_whiteSpace, CF_minInclusive, CF_maxInclusive, CF_minExclusive,
CF_maxExclusive, CF_totalDigits, CF_fractionDigits ]
FundamentalFacet.Facets = [
FF_equal, FF_ordered, FF_bounded, FF_cardinality, FF_numeric ]
Facet.Facets = []
Facet.Facets.extend(ConstrainingFacet.Facets)
Facet.Facets.extend(FundamentalFacet.Facets)
# Facet details from a hacked generator reading the normative schema
# and only printing the facet-related code.
datatypes.ENTITIES._CF_pattern = CF_pattern()
datatypes.ENTITIES._CF_maxLength = CF_maxLength()
datatypes.ENTITIES._CF_enumeration = CF_enumeration(value_datatype=datatypes.ENTITIES)
datatypes.ENTITIES._CF_minLength = CF_minLength(value=datatypes.nonNegativeInteger(1))
datatypes.ENTITIES._CF_whiteSpace = CF_whiteSpace()
datatypes.ENTITIES._CF_length = CF_length()
datatypes.ENTITIES._InitializeFacetMap(datatypes.ENTITIES._CF_pattern,
datatypes.ENTITIES._CF_maxLength,
datatypes.ENTITIES._CF_enumeration,
datatypes.ENTITIES._CF_minLength,
datatypes.ENTITIES._CF_whiteSpace,
datatypes.ENTITIES._CF_length)
datatypes.ENTITY._InitializeFacetMap()
datatypes.ID._InitializeFacetMap()
datatypes.IDREF._InitializeFacetMap()
datatypes.IDREFS._CF_pattern = CF_pattern()
datatypes.IDREFS._CF_maxLength = CF_maxLength()
datatypes.IDREFS._CF_enumeration = CF_enumeration(value_datatype=datatypes.IDREFS)
datatypes.IDREFS._CF_minLength = CF_minLength(value=datatypes.nonNegativeInteger(1))
datatypes.IDREFS._CF_whiteSpace = CF_whiteSpace()
datatypes.IDREFS._CF_length = CF_length()
datatypes.IDREFS._InitializeFacetMap(datatypes.IDREFS._CF_pattern,
datatypes.IDREFS._CF_maxLength,
datatypes.IDREFS._CF_enumeration,
datatypes.IDREFS._CF_minLength,
datatypes.IDREFS._CF_whiteSpace,
datatypes.IDREFS._CF_length)
datatypes.NCName._CF_pattern = CF_pattern()
datatypes.NCName._CF_pattern.addPattern(pattern=six.u('[\\i-[:]][\\c-[:]]*'))
datatypes.NCName._InitializeFacetMap(datatypes.NCName._CF_pattern)
datatypes.NMTOKEN._CF_pattern = CF_pattern()
datatypes.NMTOKEN._CF_pattern.addPattern(pattern=six.u('\\c+'))
datatypes.NMTOKEN._InitializeFacetMap(datatypes.NMTOKEN._CF_pattern)
datatypes.NMTOKENS._CF_pattern = CF_pattern()
datatypes.NMTOKENS._CF_maxLength = CF_maxLength()
datatypes.NMTOKENS._CF_enumeration = CF_enumeration(value_datatype=datatypes.NMTOKENS)
datatypes.NMTOKENS._CF_minLength = CF_minLength(value=datatypes.nonNegativeInteger(1))
datatypes.NMTOKENS._CF_whiteSpace = CF_whiteSpace()
datatypes.NMTOKENS._CF_length = CF_length()
datatypes.NMTOKENS._InitializeFacetMap(datatypes.NMTOKENS._CF_pattern,
datatypes.NMTOKENS._CF_maxLength,
datatypes.NMTOKENS._CF_enumeration,
datatypes.NMTOKENS._CF_minLength,
datatypes.NMTOKENS._CF_whiteSpace,
datatypes.NMTOKENS._CF_length)
datatypes.NOTATION._CF_minLength = CF_minLength()
datatypes.NOTATION._CF_maxLength = CF_maxLength()
datatypes.NOTATION._CF_enumeration = CF_enumeration(value_datatype=datatypes.NOTATION)
datatypes.NOTATION._CF_pattern = CF_pattern()
datatypes.NOTATION._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse)
datatypes.NOTATION._CF_length = CF_length()
datatypes.NOTATION._InitializeFacetMap(datatypes.NOTATION._CF_minLength,
datatypes.NOTATION._CF_maxLength,
datatypes.NOTATION._CF_enumeration,
datatypes.NOTATION._CF_pattern,
datatypes.NOTATION._CF_whiteSpace,
datatypes.NOTATION._CF_length)
datatypes.Name._CF_pattern = CF_pattern()
datatypes.Name._CF_pattern.addPattern(pattern=six.u('\\i\\c*'))
datatypes.Name._InitializeFacetMap(datatypes.Name._CF_pattern)
datatypes.QName._CF_minLength = CF_minLength()
datatypes.QName._CF_maxLength = CF_maxLength()
datatypes.QName._CF_enumeration = CF_enumeration(value_datatype=datatypes.QName)
datatypes.QName._CF_pattern = CF_pattern()
datatypes.QName._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse)
datatypes.QName._CF_length = CF_length()
datatypes.QName._InitializeFacetMap(datatypes.QName._CF_minLength,
datatypes.QName._CF_maxLength,
datatypes.QName._CF_enumeration,
datatypes.QName._CF_pattern,
datatypes.QName._CF_whiteSpace,
datatypes.QName._CF_length)
datatypes.anyURI._CF_minLength = CF_minLength()
datatypes.anyURI._CF_maxLength = CF_maxLength()
datatypes.anyURI._CF_enumeration = CF_enumeration(value_datatype=datatypes.anyURI)
datatypes.anyURI._CF_pattern = CF_pattern()
datatypes.anyURI._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse)
datatypes.anyURI._CF_length = CF_length()
datatypes.anyURI._InitializeFacetMap(datatypes.anyURI._CF_minLength,
datatypes.anyURI._CF_maxLength,
datatypes.anyURI._CF_enumeration,
datatypes.anyURI._CF_pattern,
datatypes.anyURI._CF_whiteSpace,
datatypes.anyURI._CF_length)
datatypes.base64Binary._CF_minLength = CF_minLength()
datatypes.base64Binary._CF_maxLength = CF_maxLength()
datatypes.base64Binary._CF_enumeration = CF_enumeration(value_datatype=datatypes.base64Binary)
datatypes.base64Binary._CF_pattern = CF_pattern()
datatypes.base64Binary._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse)
datatypes.base64Binary._CF_length = CF_length()
datatypes.base64Binary._InitializeFacetMap(datatypes.base64Binary._CF_minLength,
datatypes.base64Binary._CF_maxLength,
datatypes.base64Binary._CF_enumeration,
datatypes.base64Binary._CF_pattern,
datatypes.base64Binary._CF_whiteSpace,
datatypes.base64Binary._CF_length)
datatypes.boolean._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse)
datatypes.boolean._CF_pattern = CF_pattern()
datatypes.boolean._InitializeFacetMap(datatypes.boolean._CF_whiteSpace,
datatypes.boolean._CF_pattern)
datatypes.byte._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.byte, value=datatypes.anySimpleType(six.u('-128')))
datatypes.byte._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.byte, value=datatypes.anySimpleType(six.u('127')))
datatypes.byte._InitializeFacetMap(datatypes.byte._CF_minInclusive,
datatypes.byte._CF_maxInclusive)
datatypes.date._CF_pattern = CF_pattern()
datatypes.date._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.date)
datatypes.date._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType)
datatypes.date._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType)
datatypes.date._CF_enumeration = CF_enumeration(value_datatype=datatypes.date)
datatypes.date._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse)
datatypes.date._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.date)
datatypes.date._InitializeFacetMap(datatypes.date._CF_pattern,
datatypes.date._CF_minInclusive,
datatypes.date._CF_maxExclusive,
datatypes.date._CF_minExclusive,
datatypes.date._CF_enumeration,
datatypes.date._CF_whiteSpace,
datatypes.date._CF_maxInclusive)
datatypes.dateTime._CF_pattern = CF_pattern()
datatypes.dateTime._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.dateTime)
datatypes.dateTime._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType)
datatypes.dateTime._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType)
datatypes.dateTime._CF_enumeration = CF_enumeration(value_datatype=datatypes.dateTime)
datatypes.dateTime._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse)
datatypes.dateTime._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.dateTime)
datatypes.dateTime._InitializeFacetMap(datatypes.dateTime._CF_pattern,
datatypes.dateTime._CF_minInclusive,
datatypes.dateTime._CF_maxExclusive,
datatypes.dateTime._CF_minExclusive,
datatypes.dateTime._CF_enumeration,
datatypes.dateTime._CF_whiteSpace,
datatypes.dateTime._CF_maxInclusive)
datatypes.decimal._CF_totalDigits = CF_totalDigits()
datatypes.decimal._CF_pattern = CF_pattern()
datatypes.decimal._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.decimal)
datatypes.decimal._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType)
datatypes.decimal._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType)
datatypes.decimal._CF_enumeration = CF_enumeration(value_datatype=datatypes.decimal)
datatypes.decimal._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse)
datatypes.decimal._CF_fractionDigits = CF_fractionDigits()
datatypes.decimal._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.decimal)
datatypes.decimal._InitializeFacetMap(datatypes.decimal._CF_totalDigits,
datatypes.decimal._CF_pattern,
datatypes.decimal._CF_minInclusive,
datatypes.decimal._CF_maxExclusive,
datatypes.decimal._CF_minExclusive,
datatypes.decimal._CF_enumeration,
datatypes.decimal._CF_whiteSpace,
datatypes.decimal._CF_fractionDigits,
datatypes.decimal._CF_maxInclusive)
datatypes.double._CF_pattern = CF_pattern()
datatypes.double._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.double)
datatypes.double._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType)
datatypes.double._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType)
datatypes.double._CF_enumeration = CF_enumeration(value_datatype=datatypes.double)
datatypes.double._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse)
datatypes.double._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.double)
datatypes.double._InitializeFacetMap(datatypes.double._CF_pattern,
datatypes.double._CF_minInclusive,
datatypes.double._CF_maxExclusive,
datatypes.double._CF_minExclusive,
datatypes.double._CF_enumeration,
datatypes.double._CF_whiteSpace,
datatypes.double._CF_maxInclusive)
datatypes.duration._CF_pattern = CF_pattern()
datatypes.duration._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.duration)
datatypes.duration._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType)
datatypes.duration._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType)
datatypes.duration._CF_enumeration = CF_enumeration(value_datatype=datatypes.duration)
datatypes.duration._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse)
datatypes.duration._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.duration)
datatypes.duration._InitializeFacetMap(datatypes.duration._CF_pattern,
datatypes.duration._CF_minInclusive,
datatypes.duration._CF_maxExclusive,
datatypes.duration._CF_minExclusive,
datatypes.duration._CF_enumeration,
datatypes.duration._CF_whiteSpace,
datatypes.duration._CF_maxInclusive)
datatypes.float._CF_pattern = CF_pattern()
datatypes.float._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.float)
datatypes.float._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType)
datatypes.float._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType)
datatypes.float._CF_enumeration = CF_enumeration(value_datatype=datatypes.float)
datatypes.float._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse)
datatypes.float._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.float)
datatypes.float._InitializeFacetMap(datatypes.float._CF_pattern,
datatypes.float._CF_minInclusive,
datatypes.float._CF_maxExclusive,
datatypes.float._CF_minExclusive,
datatypes.float._CF_enumeration,
datatypes.float._CF_whiteSpace,
datatypes.float._CF_maxInclusive)
datatypes.gDay._CF_pattern = CF_pattern()
datatypes.gDay._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.gDay)
datatypes.gDay._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType)
datatypes.gDay._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType)
datatypes.gDay._CF_enumeration = CF_enumeration(value_datatype=datatypes.gDay)
datatypes.gDay._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse)
datatypes.gDay._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.gDay)
datatypes.gDay._InitializeFacetMap(datatypes.gDay._CF_pattern,
datatypes.gDay._CF_minInclusive,
datatypes.gDay._CF_maxExclusive,
datatypes.gDay._CF_minExclusive,
datatypes.gDay._CF_enumeration,
datatypes.gDay._CF_whiteSpace,
datatypes.gDay._CF_maxInclusive)
datatypes.gMonth._CF_pattern = CF_pattern()
datatypes.gMonth._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.gMonth)
datatypes.gMonth._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType)
datatypes.gMonth._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType)
datatypes.gMonth._CF_enumeration = CF_enumeration(value_datatype=datatypes.gMonth)
datatypes.gMonth._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse)
datatypes.gMonth._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.gMonth)
datatypes.gMonth._InitializeFacetMap(datatypes.gMonth._CF_pattern,
datatypes.gMonth._CF_minInclusive,
datatypes.gMonth._CF_maxExclusive,
datatypes.gMonth._CF_minExclusive,
datatypes.gMonth._CF_enumeration,
datatypes.gMonth._CF_whiteSpace,
datatypes.gMonth._CF_maxInclusive)
datatypes.gMonthDay._CF_pattern = CF_pattern()
datatypes.gMonthDay._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.gMonthDay)
datatypes.gMonthDay._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType)
datatypes.gMonthDay._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType)
datatypes.gMonthDay._CF_enumeration = CF_enumeration(value_datatype=datatypes.gMonthDay)
datatypes.gMonthDay._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse)
datatypes.gMonthDay._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.gMonthDay)
datatypes.gMonthDay._InitializeFacetMap(datatypes.gMonthDay._CF_pattern,
datatypes.gMonthDay._CF_minInclusive,
datatypes.gMonthDay._CF_maxExclusive,
datatypes.gMonthDay._CF_minExclusive,
datatypes.gMonthDay._CF_enumeration,
datatypes.gMonthDay._CF_whiteSpace,
datatypes.gMonthDay._CF_maxInclusive)
datatypes.gYear._CF_pattern = CF_pattern()
datatypes.gYear._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.gYear)
datatypes.gYear._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType)
datatypes.gYear._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType)
datatypes.gYear._CF_enumeration = CF_enumeration(value_datatype=datatypes.gYear)
datatypes.gYear._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse)
datatypes.gYear._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.gYear)
datatypes.gYear._InitializeFacetMap(datatypes.gYear._CF_pattern,
datatypes.gYear._CF_minInclusive,
datatypes.gYear._CF_maxExclusive,
datatypes.gYear._CF_minExclusive,
datatypes.gYear._CF_enumeration,
datatypes.gYear._CF_whiteSpace,
datatypes.gYear._CF_maxInclusive)
datatypes.gYearMonth._CF_pattern = CF_pattern()
datatypes.gYearMonth._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.gYearMonth)
datatypes.gYearMonth._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType)
datatypes.gYearMonth._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType)
datatypes.gYearMonth._CF_enumeration = CF_enumeration(value_datatype=datatypes.gYearMonth)
datatypes.gYearMonth._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse)
datatypes.gYearMonth._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.gYearMonth)
datatypes.gYearMonth._InitializeFacetMap(datatypes.gYearMonth._CF_pattern,
datatypes.gYearMonth._CF_minInclusive,
datatypes.gYearMonth._CF_maxExclusive,
datatypes.gYearMonth._CF_minExclusive,
datatypes.gYearMonth._CF_enumeration,
datatypes.gYearMonth._CF_whiteSpace,
datatypes.gYearMonth._CF_maxInclusive)
datatypes.hexBinary._CF_minLength = CF_minLength()
datatypes.hexBinary._CF_maxLength = CF_maxLength()
datatypes.hexBinary._CF_enumeration = CF_enumeration(value_datatype=datatypes.hexBinary)
datatypes.hexBinary._CF_pattern = CF_pattern()
datatypes.hexBinary._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse)
datatypes.hexBinary._CF_length = CF_length()
datatypes.hexBinary._InitializeFacetMap(datatypes.hexBinary._CF_minLength,
datatypes.hexBinary._CF_maxLength,
datatypes.hexBinary._CF_enumeration,
datatypes.hexBinary._CF_pattern,
datatypes.hexBinary._CF_whiteSpace,
datatypes.hexBinary._CF_length)
datatypes.int._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.int, value=datatypes.anySimpleType(six.u('-2147483648')))
datatypes.int._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.int, value=datatypes.anySimpleType(six.u('2147483647')))
datatypes.int._InitializeFacetMap(datatypes.int._CF_minInclusive,
datatypes.int._CF_maxInclusive)
datatypes.integer._CF_pattern = CF_pattern()
datatypes.integer._CF_pattern.addPattern(pattern=six.u('[\\-+]?[0-9]+'))
datatypes.integer._CF_fractionDigits = CF_fractionDigits(value=datatypes.nonNegativeInteger(0))
datatypes.integer._InitializeFacetMap(datatypes.integer._CF_pattern,
datatypes.integer._CF_fractionDigits)
datatypes.language._CF_pattern = CF_pattern()
datatypes.language._CF_pattern.addPattern(pattern=six.u('[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*'))
datatypes.language._InitializeFacetMap(datatypes.language._CF_pattern)
datatypes.long._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.long, value=datatypes.anySimpleType(six.u('-9223372036854775808')))
datatypes.long._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.long, value=datatypes.anySimpleType(six.u('9223372036854775807')))
datatypes.long._InitializeFacetMap(datatypes.long._CF_minInclusive,
datatypes.long._CF_maxInclusive)
datatypes.negativeInteger._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.negativeInteger, value=datatypes.anySimpleType(six.u('-1')))
datatypes.negativeInteger._InitializeFacetMap(datatypes.negativeInteger._CF_maxInclusive)
datatypes.nonNegativeInteger._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.nonNegativeInteger, value=datatypes.anySimpleType(six.u('0')))
datatypes.nonNegativeInteger._InitializeFacetMap(datatypes.nonNegativeInteger._CF_minInclusive)
datatypes.nonPositiveInteger._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.nonPositiveInteger, value=datatypes.anySimpleType(six.u('0')))
datatypes.nonPositiveInteger._InitializeFacetMap(datatypes.nonPositiveInteger._CF_maxInclusive)
datatypes.normalizedString._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.replace)
datatypes.normalizedString._InitializeFacetMap(datatypes.normalizedString._CF_whiteSpace)
datatypes.positiveInteger._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.positiveInteger, value=datatypes.anySimpleType(six.u('1')))
datatypes.positiveInteger._InitializeFacetMap(datatypes.positiveInteger._CF_minInclusive)
datatypes.short._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.short, value=datatypes.anySimpleType(six.u('-32768')))
datatypes.short._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.short, value=datatypes.anySimpleType(six.u('32767')))
datatypes.short._InitializeFacetMap(datatypes.short._CF_minInclusive,
datatypes.short._CF_maxInclusive)
datatypes.string._CF_minLength = CF_minLength()
datatypes.string._CF_maxLength = CF_maxLength()
datatypes.string._CF_enumeration = CF_enumeration(value_datatype=datatypes.string)
datatypes.string._CF_pattern = CF_pattern()
datatypes.string._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.preserve)
datatypes.string._CF_length = CF_length()
datatypes.string._InitializeFacetMap(datatypes.string._CF_minLength,
datatypes.string._CF_maxLength,
datatypes.string._CF_enumeration,
datatypes.string._CF_pattern,
datatypes.string._CF_whiteSpace,
datatypes.string._CF_length)
datatypes.time._CF_pattern = CF_pattern()
datatypes.time._CF_minInclusive = CF_minInclusive(value_datatype=datatypes.time)
datatypes.time._CF_maxExclusive = CF_maxExclusive(value_datatype=datatypes.anySimpleType)
datatypes.time._CF_minExclusive = CF_minExclusive(value_datatype=datatypes.anySimpleType)
datatypes.time._CF_enumeration = CF_enumeration(value_datatype=datatypes.time)
datatypes.time._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse)
datatypes.time._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.time)
datatypes.time._InitializeFacetMap(datatypes.time._CF_pattern,
datatypes.time._CF_minInclusive,
datatypes.time._CF_maxExclusive,
datatypes.time._CF_minExclusive,
datatypes.time._CF_enumeration,
datatypes.time._CF_whiteSpace,
datatypes.time._CF_maxInclusive)
datatypes.token._CF_whiteSpace = CF_whiteSpace(value=_WhiteSpace_enum.collapse)
datatypes.token._InitializeFacetMap(datatypes.token._CF_whiteSpace)
datatypes.unsignedByte._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.unsignedByte, value=datatypes.anySimpleType(six.u('255')))
datatypes.unsignedByte._InitializeFacetMap(datatypes.unsignedByte._CF_maxInclusive)
datatypes.unsignedInt._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.unsignedInt, value=datatypes.anySimpleType(six.u('4294967295')))
datatypes.unsignedInt._InitializeFacetMap(datatypes.unsignedInt._CF_maxInclusive)
datatypes.unsignedLong._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.unsignedLong, value=datatypes.anySimpleType(six.u('18446744073709551615')))
datatypes.unsignedLong._InitializeFacetMap(datatypes.unsignedLong._CF_maxInclusive)
datatypes.unsignedShort._CF_maxInclusive = CF_maxInclusive(value_datatype=datatypes.unsignedShort, value=datatypes.anySimpleType(six.u('65535')))
datatypes.unsignedShort._InitializeFacetMap(datatypes.unsignedShort._CF_maxInclusive)