1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 """Classes supporting U{XMLSchema Part 2: Datatypes<http://www/Documentation/W3C/www.w3.org/TR/xmlschema-2/index.html>}.
16
17 Each L{simple type definition<pyxb.xmlschema.structures.SimpleTypeDefinition>} component
18 instance is paired with at most one L{basis.simpleTypeDefinition}
19 class, which is a subclass of a Python type augmented with facets and
20 other constraining information. This file contains the definitions of
21 these types.
22
23 We want the simple datatypes to be efficient Python values, but to
24 also hold specific constraints that don't apply to the Python types.
25 To do this, we subclass each PST. Primitive PSTs inherit from the
26 Python type that represents them, and from a
27 pyxb.binding.basis.simpleTypeDefinition class which adds in the
28 constraint infrastructure. Derived PSTs inherit from the parent PST.
29
30 There is an exception to this when the Python type best suited for a
31 derived SimpleTypeDefinition differs from the type associated with its
32 parent STD: for example, L{xsd:integer<integer>} has a value range
33 that requires it be represented by a Python C{long}, but
34 L{xsd:int<int>} allows representation by a Python C{int}. In this
35 case, the derived PST class is structured like a primitive type, but
36 the PST associated with the STD superclass is recorded in a class
37 variable C{_XsdBaseType}.
38
39 Note the strict terminology: "datatype" refers to a class which is a
40 subclass of a Python type, while "type definition" refers to an
41 instance of either SimpleTypeDefinition or ComplexTypeDefinition.
42
43 """
44
45 from pyxb.exceptions_ import *
46 import types
47 import pyxb.namespace
48 import pyxb.utils.domutils as domutils
49 import pyxb.utils.utility as utility
50 import basis
51 import re
52
53 _PrimitiveDatatypes = []
54 _DerivedDatatypes = []
55 _ListDatatypes = []
56
57
58
59
60 -class anySimpleType (basis.simpleTypeDefinition, unicode):
68
69
70
71 -class string (basis.simpleTypeDefinition, unicode):
86
87 _PrimitiveDatatypes.append(string)
88
89
90
91 -class boolean (basis.simpleTypeDefinition, types.IntType):
92 """boolean.
93
94 U{http://www.w3.org/TR/xmlschema-2/#boolean}"""
95 _XsdBaseType = anySimpleType
96 _ExpandedName = pyxb.namespace.XMLSchema.createExpandedName('boolean')
97
98 @classmethod
100 if value:
101 return 'true'
102 return 'false'
103
105 if self:
106 return 'true'
107 return 'false'
108
110 args = cls._ConvertArguments(args, kw)
111 if 0 < len(args):
112 value = args[0]
113 args = args[1:]
114 if value in (1, 0, '1', '0', 'true', 'false'):
115 if value in (1, '1', 'true'):
116 iv = True
117 else:
118 iv = False
119 return super(boolean, cls).__new__(cls, iv, *args, **kw)
120 raise BadTypeValueError('[xsd:boolean] Initializer "%s" not valid for type' % (value,))
121 return super(boolean, cls).__new__(cls, *args, **kw)
122
123 _PrimitiveDatatypes.append(boolean)
124
125 -class decimal (basis.simpleTypeDefinition, types.FloatType):
140
141 _PrimitiveDatatypes.append(decimal)
142
143 -class float (basis.simpleTypeDefinition, types.FloatType):
153
154 _PrimitiveDatatypes.append(float)
155
156 -class double (basis.simpleTypeDefinition, types.FloatType):
166
167 _PrimitiveDatatypes.append(double)
168
169 import time as python_time
170 import datetime
171
172 -class duration (basis.simpleTypeDefinition, datetime.timedelta):
173 """U{http://www.w3.org/TR/xmlschema-2/#duration}
174
175 This class uses the Python C{datetime.timedelta} class as its
176 underlying representation. This works fine as long as no months
177 or years are involved, and no negative durations are involved.
178 Because the XML Schema value space is so much larger, it is kept
179 distinct from the Python value space, which reduces to integral
180 days, seconds, and microseconds.
181
182 In other words, the implementation of this type is a little
183 shakey.
184
185 """
186
187 _XsdBaseType = anySimpleType
188 _ExpandedName = pyxb.namespace.XMLSchema.createExpandedName('duration')
189
190 __Lexical_re = re.compile('^(?P<neg>-?)P((?P<years>\d+)Y)?((?P<months>\d+)M)?((?P<days>\d+)D)?(?P<Time>T((?P<hours>\d+)H)?((?P<minutes>\d+)M)?(((?P<seconds>\d+)(?P<fracsec>\.\d+)?)S)?)?$')
191
192
193 __XSDFields = ( 'years', 'months', 'days', 'hours', 'minutes', 'seconds' )
194 __PythonFields = ( 'days', 'seconds', 'microseconds', 'minutes', 'hours' )
195
198 __negativeDuration = None
199
202 __durationData = None
203
205 args = cls._ConvertArguments(args, kw)
206 text = args[0]
207 have_kw_update = False
208 if isinstance(text, (str, unicode)):
209 match = cls.__Lexical_re.match(text)
210 if match is None:
211 raise BadTypeValueError('Value "%s" not in %s lexical space' % (text, cls._ExpandedName))
212 match_map = match.groupdict()
213 if 'T' == match_map.get('Time', None):
214
215 raise BadTypeValueError('Value "%s" not in %s lexical space' % (text, cls._ExpandedName))
216
217 negative_duration = ('-' == match_map.get('neg', None))
218
219 fractional_seconds = 0.0
220 if match_map.get('fracsec', None) is not None:
221 fractional_seconds = types.FloatType('0%s' % (match_map['fracsec'],))
222 usec = types.IntType(1000000 * fractional_seconds)
223 if negative_duration:
224 kw['microseconds'] = - usec
225 else:
226 kw['microseconds'] = usec
227 else:
228
229 kw.pop('microsecond', None)
230
231 data = { }
232 for fn in cls.__XSDFields:
233 v = match_map.get(fn, 0)
234 if v is None:
235 v = 0
236 data[fn] = types.IntType(v)
237 if fn in cls.__PythonFields:
238 if negative_duration:
239 kw[fn] = - data[fn]
240 else:
241 kw[fn] = data[fn]
242 data['seconds'] += fractional_seconds
243 have_kw_update = True
244 elif isinstance(text, cls):
245 data = text.durationData()
246 negative_duration = text.negativeDuration()
247 elif isinstance(text, datetime.timedelta):
248 data = { 'days' : text.days,
249 'seconds' : text.seconds + (text.microseconds / 1000000.0) }
250 negative_duration = (0 > data['days'])
251 if negative_duration:
252 data['days'] = 1 - data['days']
253 data['seconds'] = 24 * 60 * 60.0 - data['seconds']
254 data['minutes'] = 0
255 data['hours'] = 0
256 if not have_kw_update:
257 rem_time = data['seconds']
258 use_seconds = rem_time
259 if (0 != (rem_time % 1)):
260 data['microseconds'] = types.IntType(1000000 * (rem_time % 1))
261 rem_time = rem_time // 1
262 if 60 <= rem_time:
263 data['seconds'] = rem_time % 60
264 rem_time = data['minutes'] + (rem_time // 60)
265 if 60 <= rem_time:
266 data['minutes'] = rem_time % 60
267 rem_time = data['hours'] + (rem_time // 60)
268 data['hours'] = rem_time % 24
269 data['days'] += (rem_time // 24)
270 for fn in cls.__PythonFields:
271 if fn in data:
272 if negative_duration:
273 kw[fn] = - data[fn]
274 else:
275 kw[fn] = data[fn]
276 else:
277 kw.pop(fn, None)
278 kw['microseconds'] = data.pop('microseconds', 0)
279 data['seconds'] += kw['microseconds'] / 1000000.0
280
281 rv = super(duration, cls).__new__(cls, **kw)
282 rv.__durationData = data
283 rv.__negativeDuration = negative_duration
284 return rv
285
286 @classmethod
308
309 _PrimitiveDatatypes.append(duration)
312
313 __PatternMap = { '%Y' : '(?P<negYear>-?)(?P<year>\d{4,})'
314 , '%m' : '(?P<month>\d{2})'
315 , '%d' : '(?P<day>\d{2})'
316 , '%H' : '(?P<hour>\d{2})'
317 , '%M' : '(?P<minute>\d{2})'
318 , '%S' : '(?P<second>\d{2})(?P<fracsec>\.\d+)?'
319 , '%Z' : '(?P<tzinfo>Z|[-+]\d\d:\d\d)' }
320 @classmethod
325
326 __Fields = ( 'year', 'month', 'day', 'hour', 'minute', 'second' )
327
328 _DefaultYear = 1983
329 _DefaultMonth = 6
330 _DefaultDay = 18
331
332 @classmethod
334 match = lexical_re.match(text)
335 if match is None:
336 raise BadTypeValueError('Value "%s" not in %s lexical space' % (text, cls._ExpandedName))
337 match_map = match.groupdict()
338 kw = { }
339 for (k, v) in match_map.iteritems():
340 if (k in cls.__Fields) and (v is not None):
341 kw[k] = types.IntType(v)
342 if '-' == match_map.get('negYear', None):
343 kw['year'] = - kw['year']
344 if match_map.get('fracsec', None) is not None:
345 kw['microsecond'] = types.IntType(1000000 * types.FloatType('0%s' % (match_map['fracsec'],)))
346 else:
347
348 kw.pop('microsecond', None)
349 if match_map.get('tzinfo', None) is not None:
350 kw['tzinfo'] = pyxb.utils.utility.UTCOffsetTimeZone(match_map['tzinfo'], flip=True)
351 else:
352 kw.pop('tzinfo', None)
353 return kw
354
355 @classmethod
357 for f in fields:
358 kw[f] = getattr(python_value, f)
359 return getattr(super(_PyXBDateTime_base, cls), '_SetKeysFromPython_csc', lambda *a,**kw: None)(python_value, kw, fields)
360
361 @classmethod
364
367 """True iff the time represented included time zone information.
368
369 Whether True or not, the moment denoted by an instance is
370 assumed to be in UTC. That state is expressed in the lexical
371 space iff hasTimeZone is True.
372 """
373 return self.__hasTimeZone
376 __hasTimeZone = False
377
378 @classmethod
380 tzoffs = kw.pop('tzinfo', None)
381 has_time_zone = kw.pop('_force_timezone', False)
382 if tzoffs is not None:
383 use_kw = kw.copy()
384 use_kw.setdefault('year', cls._DefaultYear)
385 use_kw.setdefault('month', cls._DefaultMonth)
386 use_kw.setdefault('day', cls._DefaultDay)
387 dt = datetime.datetime(tzinfo=tzoffs, **use_kw)
388 dt = tzoffs.fromutc(dt)
389 for k in kw.iterkeys():
390 kw[k] = getattr(dt, k)
391 has_time_zone = True
392 return has_time_zone
393
394 @classmethod
402 -class dateTime (_PyXBDateTimeZone_base, datetime.datetime):
403 """U{http://www.w3.org/TR/xmlschema-2/index.html#dateTime}
404
405 This class uses the Python C{datetime.datetime} class as its
406 underlying representation. Note that per the XMLSchema spec, all
407 dateTime objects are in UTC, and that timezone information in the
408 string representation in XML is an indication of the local time
409 zone's offset from UTC. Presence of time zone information in the
410 lexical space is preserved through the value of the L{hasTimeZone()}
411 field.
412
413 @warning: The value space of Python's C{datetime.datetime} class
414 is more restricted than that of C{xs:datetime}. As a specific
415 example, Python does not support negative years or years with more
416 than four digits. For now, the convenience of having an object
417 that is compatible with Python is more important than supporting
418 the full value space. In the future, the choice may be left up to
419 the developer.
420 """
421
422 _XsdBaseType = anySimpleType
423 _ExpandedName = pyxb.namespace.XMLSchema.createExpandedName('dateTime')
424
425 __Lexical_re = re.compile(_PyXBDateTime_base._DateTimePattern('^%Y-%m-%dT%H:%M:%S%Z?$'))
426 __Fields = ( 'year', 'month', 'day', 'hour', 'minute', 'second', 'microsecond', 'tzinfo' )
427
429 args = cls._ConvertArguments(args, kw)
430 ctor_kw = { }
431 if 1 == len(args):
432 value = args[0]
433 if isinstance(value, types.StringTypes):
434 ctor_kw.update(cls._LexicalToKeywords(value, cls.__Lexical_re))
435 elif isinstance(value, (datetime.datetime, datetime.date, datetime.time)):
436 cls._SetKeysFromPython(value, ctor_kw, cls.__Fields)
437 if isinstance(value, _PyXBDateTimeZone_base):
438 ctor_kw['_force_timezone'] = True
439 elif isinstance(value, (types.IntType, types.LongType)):
440 raise TypeError('function takes at least 3 arguments (%d given)' % (len(args),))
441 else:
442 raise BadTypeValueError('Unexpected type %s in %s' % (type(value), cls._ExpandedName))
443 elif 3 <= len(args):
444 for fi in range(len(cls.__Fields)):
445 fn = cls.__Fields[fi]
446 if fi < len(args):
447 ctor_kw[fn] = args[fi]
448 elif fn in kw:
449 ctor_kw[fn] = kw[fn]
450 kw.pop(fn, None)
451 fi += 1
452 else:
453 raise TypeError('function takes at least 3 arguments (%d given)' % (len(args),))
454
455 has_time_zone = cls._AdjustForTimezone(ctor_kw)
456 kw.update(ctor_kw)
457 year = kw.pop('year')
458 month = kw.pop('month')
459 day = kw.pop('day')
460 rv = super(dateTime, cls).__new__(cls, year, month, day, **kw)
461 rv._setHasTimeZone(has_time_zone)
462 return rv
463
464 @classmethod
466 iso = value.isoformat()
467 if 0 <= iso.find('.'):
468 iso = iso.rstrip('0')
469 if value.hasTimeZone():
470 iso += 'Z'
471 return iso
472
473 __UTCZone = pyxb.utils.utility.UTCOffsetTimeZone(0)
474 __LocalZone = pyxb.utils.utility.LocalTimeZone()
475
476 @classmethod
478 """Return today.
479
480 Just like datetime.datetime.today(), except this one sets a
481 tzinfo field so it's clear the value is UTC."""
482 return cls(datetime.datetime.now(cls.__UTCZone))
483
485 """Returns a C{datetime.datetime} instance denoting the same
486 time as this instance but adjusted to be in the local time
487 zone.
488
489 @rtype: C{datetime.datetime} (B{NOT} C{xsd.dateTime})
490 """
491 return self.replace(tzinfo=self.__UTCZone).astimezone(self.__LocalZone)
492
493 _PrimitiveDatatypes.append(dateTime)
494
495 -class time (_PyXBDateTimeZone_base, datetime.time):
496 """U{http://www.w3.org/TR/xmlschema-2/index.html#time}
497
498 This class uses the Python C{datetime.time} class as its
499 underlying representation. Note that per the XMLSchema spec, all
500 dateTime objects are in UTC, and that timezone information in the
501 string representation in XML is an indication of the local time
502 zone's offset from UTC. Presence of time zone information in the
503 lexical space is preserved through the value of the
504 L{hasTimeZone()} field.
505 """
506
507 _XsdBaseType = anySimpleType
508 _ExpandedName = pyxb.namespace.XMLSchema.createExpandedName('time')
509
510 __Lexical_re = re.compile(_PyXBDateTime_base._DateTimePattern('^%H:%M:%S%Z?$'))
511 __Fields = ( 'hour', 'minute', 'second', 'microsecond' )
512
514 args = cls._ConvertArguments(args, kw)
515 ctor_kw = { }
516 if 1 <= len(args):
517 value = args[0]
518 if isinstance(value, types.StringTypes):
519 ctor_kw.update(cls._LexicalToKeywords(value, cls.__Lexical_re))
520 elif isinstance(value, datetime.time):
521 cls._SetKeysFromPython(value, ctor_kw, cls.__Fields)
522 elif isinstance(value, (types.IntType, types.LongType)):
523 for fn in range(min(len(args), len(cls.__Fields))):
524 ctor_kw[cls.__Fields[fn]] = args[fn]
525 else:
526 raise BadTypeValueError('Unexpected type %s' % (type(value),))
527
528 has_time_zone = cls._AdjustForTimezone(ctor_kw)
529 kw.update(ctor_kw)
530 rv = super(time, cls).__new__(cls, **kw)
531 rv._setHasTimeZone(has_time_zone)
532 return rv
533
534 @classmethod
536 iso = value.isoformat()
537 if 0 <= iso.find('.'):
538 iso = iso.rstrip('0')
539 if value.hasTimeZone():
540 iso += 'Z'
541 return iso
542
543 _PrimitiveDatatypes.append(time)
546 _XsdBaseType = anySimpleType
547
548 __DateFields = ( 'year', 'month', 'day' )
549 _ISO_beginYear = 0
550 _ISO_endYear = 4
551 _ISO_beginMonth = 5
552 _ISO_endMonth = 7
553 _ISO_beginDay = 8
554 _ISO_endDay = 10
555 _ISOBegin = _ISO_beginYear
556 _ISOEnd = _ISO_endDay
557
564
566 args = cls._ConvertArguments(args, kw)
567 ctor_kw = { }
568 ctor_kw['year'] = cls._DefaultYear
569 ctor_kw['month'] = cls._DefaultMonth
570 ctor_kw['day'] = cls._DefaultDay
571 if 1 == len(args):
572 value = args[0]
573 if isinstance(value, types.StringTypes):
574 ctor_kw.update(cls._LexicalToKeywords(value, cls._Lexical_re))
575 elif isinstance(value, datetime.date):
576 cls._SetKeysFromPython(value, ctor_kw, cls._Fields)
577 elif isinstance(value, (types.IntType, types.LongType)):
578 if (1 != len(cls._Fields)):
579 raise TypeError('function takes exactly %d arguments (%d given)' % (len(cls._Fields), len(args)))
580 ctor_kw[cls._Fields[0]] = value
581 else:
582 raise BadTypeValueError('Unexpected type %s' % (type(value),))
583 elif len(cls._Fields) == len(args):
584 for fi in range(len(cls._Fields)):
585 ctor_kw[cls._Fields[fi]] = args[fi]
586 else:
587 raise TypeError('function takes exactly %d arguments (%d given)' % (len(cls._Fields), len(args)))
588
589 kw.update(ctor_kw)
590 argv = []
591 for f in cls.__DateFields:
592 argv.append(kw.pop(f))
593 return super(_PyXBDateOnly_base, cls).__new__(cls, *argv, **kw)
594
595 @classmethod
598
599 -class date (_PyXBDateOnly_base):
609
610 _PrimitiveDatatypes.append(date)
622
623 _PrimitiveDatatypes.append(gYearMonth)
624
625 -class gYear (_PyXBDateOnly_base):
635 _PrimitiveDatatypes.append(gYear)
647 _PrimitiveDatatypes.append(gMonthDay)
648
649 -class gDay (_PyXBDateOnly_base):
659 _PrimitiveDatatypes.append(gDay)
660
661 -class gMonth (_PyXBDateOnly_base):
672 _PrimitiveDatatypes.append(gMonth)
673
674 -class hexBinary (basis.simpleTypeDefinition, types.LongType):
675 _XsdBaseType = anySimpleType
676 _ExpandedName = pyxb.namespace.XMLSchema.createExpandedName('hexBinary')
677
678 __length = None
680 """Return the length of the value, in octets."""
681 return self.__length
682
683 @classmethod
685 """Convert a sequence of pairs of hex digits into a length (in
686 octets) and a binary value."""
687 assert isinstance(text, types.StringTypes)
688 value = 0L
689 length = 0
690 while (length < len(text)):
691 v = ord(text[length].lower())
692 if (ord('0') <= v) and (v <= ord('9')):
693 value = (value << 4) + v - ord('0')
694 elif (ord('a') <= v) and (v <= ord('f')):
695 value = (value << 4) + v - ord('a') + 10
696 else:
697 raise BadTypeValueError('Non-hexadecimal values in %s' % (cls.__class__.__name__,))
698 length += 1
699 if 0 == length:
700 raise BadTypeValueError('%s must be non-empty string' % (cls.__class__.__name__,))
701 if (length & 0x01):
702 raise BadTypeValueError('%s value ends mid-octet' % (cls.__class__.__name__,))
703 return (length >> 1, value)
704
705 @classmethod
707 """Given an integral value, return a pair consisting of the
708 number of octets required to represent the value, and the
709 value."""
710 length = 0
711 if 0 == value:
712 length = 1
713 else:
714 mv = value
715 while (0 != mv):
716 length += 1
717 mv = mv >> 4
718 length = (length+1) >> 1
719 return (length, value)
720
732
733 @classmethod
735 mv = value
736 length = value.length()
737 pieces = []
738 while (0 < length):
739 pieces.append('%2.2X' % (mv & 0xFF,))
740 mv = mv >> 8
741 length -= 1
742 pieces.reverse()
743 return ''.join(pieces)
744
745 @classmethod
748
749 _PrimitiveDatatypes.append(hexBinary)
759
760 _PrimitiveDatatypes.append(base64Binary)
761
762 -class anyURI (basis.simpleTypeDefinition, unicode):
773
774 _PrimitiveDatatypes.append(anyURI)
775
776 -class QName (basis.simpleTypeDefinition, unicode):
777 _XsdBaseType = anySimpleType
778 _ExpandedName = pyxb.namespace.XMLSchema.createExpandedName('QName')
779
780 @classmethod
782 """Section 4.3.1.3: Legacy length return None to indicate no check"""
783 return None
784
785 __localName = None
786 __prefix = None
787
789 """Return the prefix portion of the QName, or None if the name is not qualified."""
790 if self.__localName is None:
791 self.__resolveLocals()
792 return self.__prefix
793
799
805
806 @classmethod
809
810 @classmethod
812 if not isinstance(value, types.StringTypes):
813 raise BadTypeValueError('%s value must be a string' % (cls.__name__,))
814 if 0 <= value.find(':'):
815 (prefix, local) = value.split(':', 1)
816 if (NCName._ValidRE.match(prefix) is None) or (NCName._ValidRE.match(local) is None):
817 raise BadTypeValueError('%s lexical/value space violation for "%s"' % (cls.__name__, value))
818 else:
819 if NCName._ValidRE.match(value) is None:
820 raise BadTypeValueError('%s lexical/value space violation for "%s"' % (cls.__name__, value))
821 super_fn = getattr(super(QName, cls), '_XsdConstraintsPreCheck_vb', lambda *a,**kw: True)
822 return super_fn(value)
823
824
825 _PrimitiveDatatypes.append(QName)
826
827 -class NOTATION (basis.simpleTypeDefinition):
835
836 _PrimitiveDatatypes.append(NOTATION)
839 """See http:///www.w3.org/TR/xmlschema-2/index.html#normalizedString
840
841 Normalized strings can't have carriage returns, linefeeds, or
842 tabs in them."""
843
844
845
846
847
848
849
850
851
852
853 _ExpandedName = pyxb.namespace.XMLSchema.createExpandedName('normalizedString')
854
855
856
857
858 __BadChars = re.compile("[\r\n\t]")
859
860 _ValidRE = None
861 _InvalidRE = None
862
863 @classmethod
879
880 @classmethod
882 """Post-extended method to validate that a string matches a given pattern.
883
884 If you can express the valid strings as a compiled regular
885 expression in the class variable _ValidRE, or the invalid
886 strings as a compiled regular expression in the class variable
887 _InvalidRE, you can just use those. If the acceptable matches
888 are any trickier, you should invoke the superclass
889 implementation, and if it returns True then perform additional
890 tests."""
891 super_fn = getattr(super(normalizedString, cls), '_ValidateString_va', lambda *a,**kw: True)
892 if not super_fn(value):
893 return False
894 return cls.__ValidateString(value)
895
896 @classmethod
904
905 _DerivedDatatypes.append(normalizedString)
906 assert normalizedString.XsdSuperType() == string
907
908 -class token (normalizedString):
909 """See http:///www.w3.org/TR/xmlschema-2/index.html#token
910
911 Tokens cannot leading or trailing space characters; any
912 carriage return, line feed, or tab characters; nor any occurrence
913 of two or more consecutive space characters."""
914
915 _ExpandedName = pyxb.namespace.XMLSchema.createExpandedName('token')
916
917 @classmethod
919 super_fn = getattr(super(token, cls), '_ValidateString_va', lambda *a,**kw: True)
920 if not super_fn(value):
921 return False
922 if value.startswith(" "):
923 raise BadTypeValueError('Leading spaces in token')
924 if value.endswith(" "):
925 raise BadTypeValueError('Trailing spaces in token')
926 if 0 <= value.find(' '):
927 raise BadTypeValueError('Multiple internal spaces in token')
928 return True
929 _DerivedDatatypes.append(token)
935 _DerivedDatatypes.append(language)
944 _DerivedDatatypes.append(NMTOKEN)
948 _ListDatatypes.append(NMTOKENS)
949
950 -class Name (token):
954 _DerivedDatatypes.append(Name)
960 _DerivedDatatypes.append(NCName)
961
962 -class ID (NCName):
966 _DerivedDatatypes.append(ID)
967
968 -class IDREF (NCName):
972 _DerivedDatatypes.append(IDREF)
973
974 -class IDREFS (basis.STD_list):
977 _ListDatatypes.append(IDREFS)
988 _DerivedDatatypes.append(ENTITY)
993 _ListDatatypes.append(ENTITIES)
994
995 -class integer (basis.simpleTypeDefinition, types.LongType):
1005
1006 _DerivedDatatypes.append(integer)
1010 _DerivedDatatypes.append(nonPositiveInteger)
1014 _DerivedDatatypes.append(negativeInteger)
1015
1016 -class long (integer):
1018 _DerivedDatatypes.append(long)
1019
1020 -class int (basis.simpleTypeDefinition, types.IntType):
1029 _DerivedDatatypes.append(int)
1033 _DerivedDatatypes.append(short)
1034
1035 -class byte (short):
1037 _DerivedDatatypes.append(byte)
1041 _DerivedDatatypes.append(nonNegativeInteger)
1045 _DerivedDatatypes.append(unsignedLong)
1049 _DerivedDatatypes.append(unsignedInt)
1053 _DerivedDatatypes.append(unsignedShort)
1057 _DerivedDatatypes.append(unsignedByte)
1061 _DerivedDatatypes.append(positiveInteger)
1062
1063 import datatypes_facets
1064 import content
1065
1066 -class anyType (basis.complexTypeDefinition):
1080