From 3cc34680f7f4acc8b935e80c5f5b280812cd870f Mon Sep 17 00:00:00 2001
From: Dave Kuhlman <dkuhlman@davekuhlman.org>
Date: Wed, 20 May 2015 19:20:19 -0700
Subject: [PATCH] nested names with unit test first version

---
 README                           |   10 +-
 generateDS.py                    |    2 +-
 generateDS.txt                   |    2 +-
 gui/generateds_gui.py            |    2 +-
 librarytemplate_howto.txt        |    2 +-
 process_includes.py              |   66 +-
 setup.py                         |    2 +-
 tests/gds_inner_name_map.py      |    7 +
 tests/nested_def.xml             |    9 +
 tests/nested_def.xsd             |   38 +
 tests/nested_def1_out.xml        |    9 +
 tests/nested_def1_sub.py         |  200 +++++
 tests/nested_def1_sup.py         | 1216 ++++++++++++++++++++++++++++++
 tests/nested_def2_out.xml        |    9 +
 tests/nested_def2_sub.py         |  200 +++++
 tests/nested_def2_sup.py         | 1216 ++++++++++++++++++++++++++++++
 tests/test.py                    |   37 +-
 tutorial/generateds_tutorial.txt |    2 +-
 18 files changed, 3006 insertions(+), 23 deletions(-)
 create mode 100644 tests/gds_inner_name_map.py
 create mode 100644 tests/nested_def.xml
 create mode 100644 tests/nested_def.xsd
 create mode 100644 tests/nested_def1_out.xml
 create mode 100644 tests/nested_def1_sub.py
 create mode 100644 tests/nested_def1_sup.py
 create mode 100644 tests/nested_def2_out.xml
 create mode 100644 tests/nested_def2_sub.py
 create mode 100644 tests/nested_def2_sup.py

diff --git a/README b/README
index 4d0ff83..4d548c1 100644
--- a/README
+++ b/README
@@ -141,10 +141,16 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 Change history
 --------------
 
-Version 2.16a (05/04/2015)
+Version 2.16a (05/18/2015)
 - Added new command line option ("--preserve-cdata-tags") that
   causes generation of code that contains a special parser to retain
-  CDATA tags.  Thanks to Adrian Cook for reporting this.
+  CDATA tags.  Thanks to Adrian Cook for reporting this, for
+  providing test data and test cases, and for help with testing and
+  feed-back.
+- Added ability for user to specify the names of classes generated
+  from nested xs:complexType definitions, rather than accept the
+  names created in process_includes.py.
+- Added a unit test for the nested definition capability.
 
 Version 2.15b (04/07/2015)
 - Fix to generation of simpleType validation code for list (unbounded)
diff --git a/generateDS.py b/generateDS.py
index 4e27c5b..960e428 100755
--- a/generateDS.py
+++ b/generateDS.py
@@ -187,7 +187,7 @@ logging.disable(logging.INFO)
 # Do not modify the following VERSION comments.
 # Used by updateversion.py.
 ##VERSION##
-VERSION = '2.15b'
+VERSION = '2.16a'
 ##VERSION##
 
 GenerateProperties = 0
diff --git a/generateDS.txt b/generateDS.txt
index 4d90a12..7e0efbf 100644
--- a/generateDS.txt
+++ b/generateDS.txt
@@ -12,7 +12,7 @@ generateDS -- Generate Data Structures from XML Schema
 
 .. version
 
-:revision: 2.15b
+:revision: 2.16a
 
 .. version
 
diff --git a/gui/generateds_gui.py b/gui/generateds_gui.py
index dd14694..41ab05c 100755
--- a/gui/generateds_gui.py
+++ b/gui/generateds_gui.py
@@ -31,7 +31,7 @@ from libgenerateDS.gui import generateds_gui_session
 # Do not modify the following VERSION comments.
 # Used by updateversion.py.
 ##VERSION##
-VERSION = '2.15b'
+VERSION = '2.16a'
 ##VERSION##
 
 
diff --git a/librarytemplate_howto.txt b/librarytemplate_howto.txt
index 3a3f9c2..73dacac 100644
--- a/librarytemplate_howto.txt
+++ b/librarytemplate_howto.txt
@@ -8,7 +8,7 @@ How to package a generateDS.py generated library
 
 .. version
 
-:revision: 2.15b
+:revision: 2.16a
 
 .. version
 
diff --git a/process_includes.py b/process_includes.py
index 62f4fe6..b605ca9 100755
--- a/process_includes.py
+++ b/process_includes.py
@@ -22,6 +22,11 @@ import itertools
 from copy import deepcopy
 from lxml import etree
 
+try:
+    from gds_inner_name_map import Inner_name_map
+except ImportError:
+    Inner_name_map = None
+
 
 #
 # Globals and constants
@@ -30,7 +35,7 @@ from lxml import etree
 # Do not modify the following VERSION comments.
 # Used by updateversion.py.
 ##VERSION##
-VERSION = '2.15b'
+VERSION = '2.16a'
 ##VERSION##
 
 CatalogDict = {}
@@ -38,6 +43,17 @@ CatalogDict = {}
 CatalogBaseUrl = None
 
 
+#
+# Exceptions
+
+class SchemaIOError(IOError):
+    pass
+
+
+class InnerNameMapError(Exception):
+    pass
+
+
 def load_catalog(catalogpath):
     global CatalogBaseUrl
     if catalogpath:
@@ -91,17 +107,10 @@ class Params(object):
     def __setattr__(self, name, value):
         if name not in self.members:
             raise AttributeError('Class %s has no set-able attribute "%s"' % (
-                self.__class__.__name__,  name, ))
+                self.__class__.__name__, name, ))
         self.__dict__[name] = value
 
 
-class SchemaIOError(IOError):
-    pass
-
-
-class RaiseComplexTypesError(Exception):
-    pass
-
 #
 # Functions for internal use and testing
 
@@ -475,7 +484,10 @@ def raise_anon_complextypes(root):
         if not name:
             continue
         type_name = '%sType' % (name, )
-        type_name, def_count = unique_name(type_name, def_names, def_count)
+        if Inner_name_map is None:
+            type_name, def_count = unique_name(type_name, def_names, def_count)
+        else:
+            type_name = map_inner_name(node, Inner_name_map)
         def_names.add(type_name)
         parent.set('type', type_name)
         node.set('name', type_name)
@@ -483,6 +495,35 @@ def raise_anon_complextypes(root):
         root.append(node)
 
 
+def map_inner_name(node, inner_name_map):
+    """Use a user-supplied mapping table to look up a name for this class/type.
+    """
+    # find the name for the enclosing type definition and
+    # the name of the type definition that encloses that.
+    node1 = node
+    name2 = node1.get('name')
+    while name2 is None:
+        node1 = node1.getparent()
+        if node1 is None:
+            raise InnerNameMapError('cannot find parent with "name" attribute')
+        name2 = node1.get('name')
+    node1 = node1.getparent()
+    name1 = node1.get('name')
+    while name1 is None:
+        node1 = node1.getparent()
+        if node1 is None:
+            raise InnerNameMapError('cannot find parent with "name" attribute')
+        name1 = node1.get('name')
+    new_name = inner_name_map.get((name1, name2))
+    if new_name is None:
+        msg1 = '("{}", "{}")'.format(
+            name1, name2)
+        sys.stderr.write('\n*** error.  Must add entry to inner_name_map:\n')
+        sys.stderr.write('\n    {}: "xxxx",\n\n'.format(msg1))
+        raise InnerNameMapError('mapping missing for {}'.format(msg1))
+    return new_name
+
+
 #
 # Collect the names of all currently defined types (complexType,
 #   simpleType, element).
@@ -498,11 +539,10 @@ def collect_type_names(node):
     else:
         pattern = './/complexType|.//simpleType|.//element'
         elements = node.xpath(pattern)
-    names = [
+    names = {
         el.attrib['name'] for el in elements if
         'name' in el.attrib and el.getchildren()
-    ]
-    names = set(names)
+    }
     return names
 
 
diff --git a/setup.py b/setup.py
index f0bb6dd..8b17964 100644
--- a/setup.py
+++ b/setup.py
@@ -7,7 +7,7 @@ setup(name="generateDS",
 # Do not modify the following VERSION comments.
 # Used by updateversion.py.
 ##VERSION##
-    version="2.15b",
+    version="2.16a",
 ##VERSION##
     author="Dave Kuhlman",
     author_email="dkuhlman@davekuhlman.org",
diff --git a/tests/gds_inner_name_map.py b/tests/gds_inner_name_map.py
new file mode 100644
index 0000000..a883760
--- /dev/null
+++ b/tests/gds_inner_name_map.py
@@ -0,0 +1,7 @@
+
+Inner_name_map = {
+    ("classAType", "inner"): "inner_001",
+    ("classBType", "inner"): "inner_002",
+    #("classAType", "inner"): "class_a_inner",
+    #("classBType", "inner"): "class_b_inner",
+}
diff --git a/tests/nested_def.xml b/tests/nested_def.xml
new file mode 100644
index 0000000..3582540
--- /dev/null
+++ b/tests/nested_def.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<container>
+    <item1>
+        <inner attrA1="attrA1value" attrA2="attrA2value"/>
+    </item1>
+    <item2>
+        <inner attrB1="attrB1value" attrB2="attrB2value"/>
+    </item2>
+</container>
diff --git a/tests/nested_def.xsd b/tests/nested_def.xsd
new file mode 100644
index 0000000..9ad3b50
--- /dev/null
+++ b/tests/nested_def.xsd
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    >
+
+    <xs:element name="container" type="containerType" />
+
+    <xs:complexType name="containerType">
+        <xs:sequence>
+            <xs:element name="item1" type="classAType" />
+            <xs:element name="item2" type="classBType" />
+        </xs:sequence>
+    </xs:complexType>
+
+    <xs:element name="classA" type="classAType" />
+    <xs:complexType name="classAType">
+        <xs:sequence>
+            <xs:element name="inner">
+                <xs:complexType>
+                    <xs:attribute name="attrA1" type="xs:string"/>
+                    <xs:attribute name="attrA2" type="xs:string"/>
+                </xs:complexType>
+            </xs:element>
+        </xs:sequence>
+    </xs:complexType>
+
+    <xs:element name="classB" type="classBType" />
+    <xs:complexType name="classBType">
+        <xs:sequence>
+            <xs:element name="inner">
+                <xs:complexType>
+                    <xs:attribute name="attrB1" type="xs:string"/>
+                    <xs:attribute name="attrB2" type="xs:string"/>
+                </xs:complexType>
+            </xs:element>
+        </xs:sequence>
+    </xs:complexType>
+</xs:schema>
diff --git a/tests/nested_def1_out.xml b/tests/nested_def1_out.xml
new file mode 100644
index 0000000..692c598
--- /dev/null
+++ b/tests/nested_def1_out.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" ?>
+<container>
+    <item1>
+        <inner attrA1="attrA1value" attrA2="attrA2value"/>
+    </item1>
+    <item2>
+        <inner attrB1="attrB1value" attrB2="attrB2value"/>
+    </item2>
+</container>
diff --git a/tests/nested_def1_sub.py b/tests/nested_def1_sub.py
new file mode 100644
index 0000000..0bb693d
--- /dev/null
+++ b/tests/nested_def1_sub.py
@@ -0,0 +1,200 @@
+#!/usr/bin/env python
+
+#
+# Generated  by generateDS.py.
+#
+# Command line options:
+#   ('--no-dates', '')
+#   ('--no-versions', '')
+#   ('--member-specs', 'list')
+#   ('-f', '')
+#   ('-o', 'tests/nested_def2_sup.py')
+#   ('-s', 'tests/nested_def2_sub.py')
+#   ('--super', 'nested_def2_sup')
+#
+# Command line arguments:
+#   tests/nested_def.xsd
+#
+# Command line:
+#   generateDS.py --no-dates --no-versions --member-specs="list" -f -o "tests/nested_def2_sup.py" -s "tests/nested_def2_sub.py" --super="nested_def2_sup" tests/nested_def.xsd
+#
+# Current working directory (os.getcwd()):
+#   generateds
+#
+
+import sys
+from lxml import etree as etree_
+
+import nested_def2_sup as supermod
+
+def parsexml_(infile, parser=None, **kwargs):
+    if parser is None:
+        # Use the lxml ElementTree compatible parser so that, e.g.,
+        #   we ignore comments.
+        parser = etree_.ETCompatXMLParser()
+    doc = etree_.parse(infile, parser=parser, **kwargs)
+    return doc
+
+#
+# Globals
+#
+
+ExternalEncoding = 'ascii'
+
+#
+# Data representation classes
+#
+
+
+class containerTypeSub(supermod.containerType):
+    def __init__(self, item1=None, item2=None):
+        super(containerTypeSub, self).__init__(item1, item2, )
+supermod.containerType.subclass = containerTypeSub
+# end class containerTypeSub
+
+
+class classATypeSub(supermod.classAType):
+    def __init__(self, inner=None):
+        super(classATypeSub, self).__init__(inner, )
+supermod.classAType.subclass = classATypeSub
+# end class classATypeSub
+
+
+class classBTypeSub(supermod.classBType):
+    def __init__(self, inner=None):
+        super(classBTypeSub, self).__init__(inner, )
+supermod.classBType.subclass = classBTypeSub
+# end class classBTypeSub
+
+
+class inner_001Sub(supermod.inner_001):
+    def __init__(self, attrA1=None, attrA2=None):
+        super(inner_001Sub, self).__init__(attrA1, attrA2, )
+supermod.inner_001.subclass = inner_001Sub
+# end class inner_001Sub
+
+
+class inner_002Sub(supermod.inner_002):
+    def __init__(self, attrB1=None, attrB2=None):
+        super(inner_002Sub, self).__init__(attrB1, attrB2, )
+supermod.inner_002.subclass = inner_002Sub
+# end class inner_002Sub
+
+
+def get_root_tag(node):
+    tag = supermod.Tag_pattern_.match(node.tag).groups()[-1]
+    rootClass = None
+    rootClass = supermod.GDSClassesMapping.get(tag)
+    if rootClass is None and hasattr(supermod, tag):
+        rootClass = getattr(supermod, tag)
+    return tag, rootClass
+
+
+def parse(inFilename, silence=False):
+    parser = None
+    doc = parsexml_(inFilename, parser)
+    rootNode = doc.getroot()
+    rootTag, rootClass = get_root_tag(rootNode)
+    if rootClass is None:
+        rootTag = 'containerType'
+        rootClass = supermod.containerType
+    rootObj = rootClass.factory()
+    rootObj.build(rootNode)
+    # Enable Python to collect the space used by the DOM.
+    doc = None
+    if not silence:
+        sys.stdout.write('<?xml version="1.0" ?>\n')
+        rootObj.export(
+            sys.stdout, 0, name_=rootTag,
+            namespacedef_='',
+            pretty_print=True)
+    return rootObj
+
+
+def parseEtree(inFilename, silence=False):
+    parser = None
+    doc = parsexml_(inFilename, parser)
+    rootNode = doc.getroot()
+    rootTag, rootClass = get_root_tag(rootNode)
+    if rootClass is None:
+        rootTag = 'containerType'
+        rootClass = supermod.containerType
+    rootObj = rootClass.factory()
+    rootObj.build(rootNode)
+    # Enable Python to collect the space used by the DOM.
+    doc = None
+    mapping = {}
+    rootElement = rootObj.to_etree(None, name_=rootTag, mapping_=mapping)
+    reverse_mapping = rootObj.gds_reverse_node_mapping(mapping)
+    if not silence:
+        content = etree_.tostring(
+            rootElement, pretty_print=True,
+            xml_declaration=True, encoding="utf-8")
+        sys.stdout.write(content)
+        sys.stdout.write('\n')
+    return rootObj, rootElement, mapping, reverse_mapping
+
+
+def parseString(inString, silence=False):
+    from StringIO import StringIO
+    parser = None
+    doc = parsexml_(StringIO(inString), parser)
+    rootNode = doc.getroot()
+    rootTag, rootClass = get_root_tag(rootNode)
+    if rootClass is None:
+        rootTag = 'containerType'
+        rootClass = supermod.containerType
+    rootObj = rootClass.factory()
+    rootObj.build(rootNode)
+    # Enable Python to collect the space used by the DOM.
+    doc = None
+    if not silence:
+        sys.stdout.write('<?xml version="1.0" ?>\n')
+        rootObj.export(
+            sys.stdout, 0, name_=rootTag,
+            namespacedef_='')
+    return rootObj
+
+
+def parseLiteral(inFilename, silence=False):
+    parser = None
+    doc = parsexml_(inFilename, parser)
+    rootNode = doc.getroot()
+    rootTag, rootClass = get_root_tag(rootNode)
+    if rootClass is None:
+        rootTag = 'containerType'
+        rootClass = supermod.containerType
+    rootObj = rootClass.factory()
+    rootObj.build(rootNode)
+    # Enable Python to collect the space used by the DOM.
+    doc = None
+    if not silence:
+        sys.stdout.write('#from nested_def2_sup import *\n\n')
+        sys.stdout.write('import nested_def2_sup as model_\n\n')
+        sys.stdout.write('rootObj = model_.rootClass(\n')
+        rootObj.exportLiteral(sys.stdout, 0, name_=rootTag)
+        sys.stdout.write(')\n')
+    return rootObj
+
+
+USAGE_TEXT = """
+Usage: python ???.py <infilename>
+"""
+
+
+def usage():
+    print(USAGE_TEXT)
+    sys.exit(1)
+
+
+def main():
+    args = sys.argv[1:]
+    if len(args) != 1:
+        usage()
+    infilename = args[0]
+    parse(infilename)
+
+
+if __name__ == '__main__':
+    #import pdb; pdb.set_trace()
+    main()
diff --git a/tests/nested_def1_sup.py b/tests/nested_def1_sup.py
new file mode 100644
index 0000000..d49c00e
--- /dev/null
+++ b/tests/nested_def1_sup.py
@@ -0,0 +1,1216 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+#
+# Generated  by generateDS.py.
+#
+# Command line options:
+#   ('--no-dates', '')
+#   ('--no-versions', '')
+#   ('--member-specs', 'list')
+#   ('-f', '')
+#   ('-o', 'tests/nested_def2_sup.py')
+#   ('-s', 'tests/nested_def2_sub.py')
+#   ('--super', 'nested_def2_sup')
+#
+# Command line arguments:
+#   tests/nested_def.xsd
+#
+# Command line:
+#   generateDS.py --no-dates --no-versions --member-specs="list" -f -o "tests/nested_def2_sup.py" -s "tests/nested_def2_sub.py" --super="nested_def2_sup" tests/nested_def.xsd
+#
+# Current working directory (os.getcwd()):
+#   generateds
+#
+
+import sys
+import re as re_
+import base64
+import datetime as datetime_
+import warnings as warnings_
+from lxml import etree as etree_
+
+
+Validate_simpletypes_ = True
+
+
+def parsexml_(infile, parser=None, **kwargs):
+    if parser is None:
+        # Use the lxml ElementTree compatible parser so that, e.g.,
+        #   we ignore comments.
+        parser = etree_.ETCompatXMLParser()
+    doc = etree_.parse(infile, parser=parser, **kwargs)
+    return doc
+
+#
+# User methods
+#
+# Calls to the methods in these classes are generated by generateDS.py.
+# You can replace these methods by re-implementing the following class
+#   in a module named generatedssuper.py.
+
+try:
+    from generatedssuper import GeneratedsSuper
+except ImportError as exp:
+
+    class GeneratedsSuper(object):
+        tzoff_pattern = re_.compile(r'(\+|-)((0\d|1[0-3]):[0-5]\d|14:00)$')
+        class _FixedOffsetTZ(datetime_.tzinfo):
+            def __init__(self, offset, name):
+                self.__offset = datetime_.timedelta(minutes=offset)
+                self.__name = name
+            def utcoffset(self, dt):
+                return self.__offset
+            def tzname(self, dt):
+                return self.__name
+            def dst(self, dt):
+                return None
+        def gds_format_string(self, input_data, input_name=''):
+            return input_data
+        def gds_validate_string(self, input_data, node=None, input_name=''):
+            if not input_data:
+                return ''
+            else:
+                return input_data
+        def gds_format_base64(self, input_data, input_name=''):
+            return base64.b64encode(input_data)
+        def gds_validate_base64(self, input_data, node=None, input_name=''):
+            return input_data
+        def gds_format_integer(self, input_data, input_name=''):
+            return '%d' % input_data
+        def gds_validate_integer(self, input_data, node=None, input_name=''):
+            return input_data
+        def gds_format_integer_list(self, input_data, input_name=''):
+            return '%s' % ' '.join(input_data)
+        def gds_validate_integer_list(
+                self, input_data, node=None, input_name=''):
+            values = input_data.split()
+            for value in values:
+                try:
+                    int(value)
+                except (TypeError, ValueError):
+                    raise_parse_error(node, 'Requires sequence of integers')
+            return values
+        def gds_format_float(self, input_data, input_name=''):
+            return ('%.15f' % input_data).rstrip('0')
+        def gds_validate_float(self, input_data, node=None, input_name=''):
+            return input_data
+        def gds_format_float_list(self, input_data, input_name=''):
+            return '%s' % ' '.join(input_data)
+        def gds_validate_float_list(
+                self, input_data, node=None, input_name=''):
+            values = input_data.split()
+            for value in values:
+                try:
+                    float(value)
+                except (TypeError, ValueError):
+                    raise_parse_error(node, 'Requires sequence of floats')
+            return values
+        def gds_format_double(self, input_data, input_name=''):
+            return '%e' % input_data
+        def gds_validate_double(self, input_data, node=None, input_name=''):
+            return input_data
+        def gds_format_double_list(self, input_data, input_name=''):
+            return '%s' % ' '.join(input_data)
+        def gds_validate_double_list(
+                self, input_data, node=None, input_name=''):
+            values = input_data.split()
+            for value in values:
+                try:
+                    float(value)
+                except (TypeError, ValueError):
+                    raise_parse_error(node, 'Requires sequence of doubles')
+            return values
+        def gds_format_boolean(self, input_data, input_name=''):
+            return ('%s' % input_data).lower()
+        def gds_validate_boolean(self, input_data, node=None, input_name=''):
+            return input_data
+        def gds_format_boolean_list(self, input_data, input_name=''):
+            return '%s' % ' '.join(input_data)
+        def gds_validate_boolean_list(
+                self, input_data, node=None, input_name=''):
+            values = input_data.split()
+            for value in values:
+                if value not in ('true', '1', 'false', '0', ):
+                    raise_parse_error(
+                        node,
+                        'Requires sequence of booleans '
+                        '("true", "1", "false", "0")')
+            return values
+        def gds_validate_datetime(self, input_data, node=None, input_name=''):
+            return input_data
+        def gds_format_datetime(self, input_data, input_name=''):
+            if input_data.microsecond == 0:
+                _svalue = '%04d-%02d-%02dT%02d:%02d:%02d' % (
+                    input_data.year,
+                    input_data.month,
+                    input_data.day,
+                    input_data.hour,
+                    input_data.minute,
+                    input_data.second,
+                )
+            else:
+                _svalue = '%04d-%02d-%02dT%02d:%02d:%02d.%s' % (
+                    input_data.year,
+                    input_data.month,
+                    input_data.day,
+                    input_data.hour,
+                    input_data.minute,
+                    input_data.second,
+                    ('%f' % (float(input_data.microsecond) / 1000000))[2:],
+                )
+            if input_data.tzinfo is not None:
+                tzoff = input_data.tzinfo.utcoffset(input_data)
+                if tzoff is not None:
+                    total_seconds = tzoff.seconds + (86400 * tzoff.days)
+                    if total_seconds == 0:
+                        _svalue += 'Z'
+                    else:
+                        if total_seconds < 0:
+                            _svalue += '-'
+                            total_seconds *= -1
+                        else:
+                            _svalue += '+'
+                        hours = total_seconds // 3600
+                        minutes = (total_seconds - (hours * 3600)) // 60
+                        _svalue += '{0:02d}:{1:02d}'.format(hours, minutes)
+            return _svalue
+        @classmethod
+        def gds_parse_datetime(cls, input_data):
+            tz = None
+            if input_data[-1] == 'Z':
+                tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC')
+                input_data = input_data[:-1]
+            else:
+                results = GeneratedsSuper.tzoff_pattern.search(input_data)
+                if results is not None:
+                    tzoff_parts = results.group(2).split(':')
+                    tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1])
+                    if results.group(1) == '-':
+                        tzoff *= -1
+                    tz = GeneratedsSuper._FixedOffsetTZ(
+                        tzoff, results.group(0))
+                    input_data = input_data[:-6]
+            time_parts = input_data.split('.')
+            if len(time_parts) > 1:
+                micro_seconds = int(float('0.' + time_parts[1]) * 1000000)
+                input_data = '%s.%s' % (time_parts[0], micro_seconds, )
+                dt = datetime_.datetime.strptime(
+                    input_data, '%Y-%m-%dT%H:%M:%S.%f')
+            else:
+                dt = datetime_.datetime.strptime(
+                    input_data, '%Y-%m-%dT%H:%M:%S')
+            dt = dt.replace(tzinfo=tz)
+            return dt
+        def gds_validate_date(self, input_data, node=None, input_name=''):
+            return input_data
+        def gds_format_date(self, input_data, input_name=''):
+            _svalue = '%04d-%02d-%02d' % (
+                input_data.year,
+                input_data.month,
+                input_data.day,
+            )
+            try:
+                if input_data.tzinfo is not None:
+                    tzoff = input_data.tzinfo.utcoffset(input_data)
+                    if tzoff is not None:
+                        total_seconds = tzoff.seconds + (86400 * tzoff.days)
+                        if total_seconds == 0:
+                            _svalue += 'Z'
+                        else:
+                            if total_seconds < 0:
+                                _svalue += '-'
+                                total_seconds *= -1
+                            else:
+                                _svalue += '+'
+                            hours = total_seconds // 3600
+                            minutes = (total_seconds - (hours * 3600)) // 60
+                            _svalue += '{0:02d}:{1:02d}'.format(hours, minutes)
+            except AttributeError:
+                pass
+            return _svalue
+        @classmethod
+        def gds_parse_date(cls, input_data):
+            tz = None
+            if input_data[-1] == 'Z':
+                tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC')
+                input_data = input_data[:-1]
+            else:
+                results = GeneratedsSuper.tzoff_pattern.search(input_data)
+                if results is not None:
+                    tzoff_parts = results.group(2).split(':')
+                    tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1])
+                    if results.group(1) == '-':
+                        tzoff *= -1
+                    tz = GeneratedsSuper._FixedOffsetTZ(
+                        tzoff, results.group(0))
+                    input_data = input_data[:-6]
+            dt = datetime_.datetime.strptime(input_data, '%Y-%m-%d')
+            dt = dt.replace(tzinfo=tz)
+            return dt.date()
+        def gds_validate_time(self, input_data, node=None, input_name=''):
+            return input_data
+        def gds_format_time(self, input_data, input_name=''):
+            if input_data.microsecond == 0:
+                _svalue = '%02d:%02d:%02d' % (
+                    input_data.hour,
+                    input_data.minute,
+                    input_data.second,
+                )
+            else:
+                _svalue = '%02d:%02d:%02d.%s' % (
+                    input_data.hour,
+                    input_data.minute,
+                    input_data.second,
+                    ('%f' % (float(input_data.microsecond) / 1000000))[2:],
+                )
+            if input_data.tzinfo is not None:
+                tzoff = input_data.tzinfo.utcoffset(input_data)
+                if tzoff is not None:
+                    total_seconds = tzoff.seconds + (86400 * tzoff.days)
+                    if total_seconds == 0:
+                        _svalue += 'Z'
+                    else:
+                        if total_seconds < 0:
+                            _svalue += '-'
+                            total_seconds *= -1
+                        else:
+                            _svalue += '+'
+                        hours = total_seconds // 3600
+                        minutes = (total_seconds - (hours * 3600)) // 60
+                        _svalue += '{0:02d}:{1:02d}'.format(hours, minutes)
+            return _svalue
+        def gds_validate_simple_patterns(self, patterns, target):
+            # pat is a list of lists of strings/patterns.  We should:
+            # - AND the outer elements
+            # - OR the inner elements
+            found1 = True
+            for patterns1 in patterns:
+                found2 = False
+                for patterns2 in patterns1:
+                    if re_.search(patterns2, target) is not None:
+                        found2 = True
+                        break
+                if not found2:
+                    found1 = False
+                    break
+            return found1
+        @classmethod
+        def gds_parse_time(cls, input_data):
+            tz = None
+            if input_data[-1] == 'Z':
+                tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC')
+                input_data = input_data[:-1]
+            else:
+                results = GeneratedsSuper.tzoff_pattern.search(input_data)
+                if results is not None:
+                    tzoff_parts = results.group(2).split(':')
+                    tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1])
+                    if results.group(1) == '-':
+                        tzoff *= -1
+                    tz = GeneratedsSuper._FixedOffsetTZ(
+                        tzoff, results.group(0))
+                    input_data = input_data[:-6]
+            if len(input_data.split('.')) > 1:
+                dt = datetime_.datetime.strptime(input_data, '%H:%M:%S.%f')
+            else:
+                dt = datetime_.datetime.strptime(input_data, '%H:%M:%S')
+            dt = dt.replace(tzinfo=tz)
+            return dt.time()
+        def gds_str_lower(self, instring):
+            return instring.lower()
+        def get_path_(self, node):
+            path_list = []
+            self.get_path_list_(node, path_list)
+            path_list.reverse()
+            path = '/'.join(path_list)
+            return path
+        Tag_strip_pattern_ = re_.compile(r'\{.*\}')
+        def get_path_list_(self, node, path_list):
+            if node is None:
+                return
+            tag = GeneratedsSuper.Tag_strip_pattern_.sub('', node.tag)
+            if tag:
+                path_list.append(tag)
+            self.get_path_list_(node.getparent(), path_list)
+        def get_class_obj_(self, node, default_class=None):
+            class_obj1 = default_class
+            if 'xsi' in node.nsmap:
+                classname = node.get('{%s}type' % node.nsmap['xsi'])
+                if classname is not None:
+                    names = classname.split(':')
+                    if len(names) == 2:
+                        classname = names[1]
+                    class_obj2 = globals().get(classname)
+                    if class_obj2 is not None:
+                        class_obj1 = class_obj2
+            return class_obj1
+        def gds_build_any(self, node, type_name=None):
+            return None
+        @classmethod
+        def gds_reverse_node_mapping(cls, mapping):
+            return dict(((v, k) for k, v in mapping.iteritems()))
+
+
+#
+# If you have installed IPython you can uncomment and use the following.
+# IPython is available from http://ipython.scipy.org/.
+#
+
+## from IPython.Shell import IPShellEmbed
+## args = ''
+## ipshell = IPShellEmbed(args,
+##     banner = 'Dropping into IPython',
+##     exit_msg = 'Leaving Interpreter, back to program.')
+
+# Then use the following line where and when you want to drop into the
+# IPython shell:
+#    ipshell('<some message> -- Entering ipshell.\nHit Ctrl-D to exit')
+
+#
+# Globals
+#
+
+ExternalEncoding = 'ascii'
+Tag_pattern_ = re_.compile(r'({.*})?(.*)')
+String_cleanup_pat_ = re_.compile(r"[\n\r\s]+")
+Namespace_extract_pat_ = re_.compile(r'{(.*)}(.*)')
+CDATA_pattern_ = re_.compile(r"<!\[CDATA\[.*?\]\]>", re_.DOTALL)
+
+#
+# Support/utility functions.
+#
+
+
+def showIndent(outfile, level, pretty_print=True):
+    if pretty_print:
+        for idx in range(level):
+            outfile.write('    ')
+
+
+def quote_xml(inStr):
+    "Escape markup chars, but do not modify CDATA sections."
+    if not inStr:
+        return ''
+    s1 = (isinstance(inStr, basestring) and inStr or
+          '%s' % inStr)
+    s2 = ''
+    pos = 0
+    matchobjects = CDATA_pattern_.finditer(s1)
+    for mo in matchobjects:
+        s3 = s1[pos:mo.start()]
+        s2 += quote_xml_aux(s3)
+        s2 += s1[mo.start():mo.end()]
+        pos = mo.end()
+    s3 = s1[pos:]
+    s2 += quote_xml_aux(s3)
+    return s2
+
+
+def quote_xml_aux(inStr):
+    s1 = inStr.replace('&', '&amp;')
+    s1 = s1.replace('<', '&lt;')
+    s1 = s1.replace('>', '&gt;')
+    return s1
+
+
+def quote_attrib(inStr):
+    s1 = (isinstance(inStr, basestring) and inStr or
+          '%s' % inStr)
+    s1 = s1.replace('&', '&amp;')
+    s1 = s1.replace('<', '&lt;')
+    s1 = s1.replace('>', '&gt;')
+    if '"' in s1:
+        if "'" in s1:
+            s1 = '"%s"' % s1.replace('"', "&quot;")
+        else:
+            s1 = "'%s'" % s1
+    else:
+        s1 = '"%s"' % s1
+    return s1
+
+
+def quote_python(inStr):
+    s1 = inStr
+    if s1.find("'") == -1:
+        if s1.find('\n') == -1:
+            return "'%s'" % s1
+        else:
+            return "'''%s'''" % s1
+    else:
+        if s1.find('"') != -1:
+            s1 = s1.replace('"', '\\"')
+        if s1.find('\n') == -1:
+            return '"%s"' % s1
+        else:
+            return '"""%s"""' % s1
+
+
+def get_all_text_(node):
+    if node.text is not None:
+        text = node.text
+    else:
+        text = ''
+    for child in node:
+        if child.tail is not None:
+            text += child.tail
+    return text
+
+
+def find_attr_value_(attr_name, node):
+    attrs = node.attrib
+    attr_parts = attr_name.split(':')
+    value = None
+    if len(attr_parts) == 1:
+        value = attrs.get(attr_name)
+    elif len(attr_parts) == 2:
+        prefix, name = attr_parts
+        namespace = node.nsmap.get(prefix)
+        if namespace is not None:
+            value = attrs.get('{%s}%s' % (namespace, name, ))
+    return value
+
+
+class GDSParseError(Exception):
+    pass
+
+
+def raise_parse_error(node, msg):
+    if XMLParser_import_library == XMLParser_import_lxml:
+        msg = '%s (element %s/line %d)' % (
+            msg, node.tag, node.sourceline, )
+    else:
+        msg = '%s (element %s)' % (msg, node.tag, )
+    raise GDSParseError(msg)
+
+
+class MixedContainer:
+    # Constants for category:
+    CategoryNone = 0
+    CategoryText = 1
+    CategorySimple = 2
+    CategoryComplex = 3
+    # Constants for content_type:
+    TypeNone = 0
+    TypeText = 1
+    TypeString = 2
+    TypeInteger = 3
+    TypeFloat = 4
+    TypeDecimal = 5
+    TypeDouble = 6
+    TypeBoolean = 7
+    TypeBase64 = 8
+    def __init__(self, category, content_type, name, value):
+        self.category = category
+        self.content_type = content_type
+        self.name = name
+        self.value = value
+    def getCategory(self):
+        return self.category
+    def getContenttype(self, content_type):
+        return self.content_type
+    def getValue(self):
+        return self.value
+    def getName(self):
+        return self.name
+    def export(self, outfile, level, name, namespace, pretty_print=True):
+        if self.category == MixedContainer.CategoryText:
+            # Prevent exporting empty content as empty lines.
+            if self.value.strip():
+                outfile.write(self.value)
+        elif self.category == MixedContainer.CategorySimple:
+            self.exportSimple(outfile, level, name)
+        else:    # category == MixedContainer.CategoryComplex
+            self.value.export(outfile, level, namespace, name, pretty_print)
+    def exportSimple(self, outfile, level, name):
+        if self.content_type == MixedContainer.TypeString:
+            outfile.write('<%s>%s</%s>' % (
+                self.name, self.value, self.name))
+        elif self.content_type == MixedContainer.TypeInteger or \
+                self.content_type == MixedContainer.TypeBoolean:
+            outfile.write('<%s>%d</%s>' % (
+                self.name, self.value, self.name))
+        elif self.content_type == MixedContainer.TypeFloat or \
+                self.content_type == MixedContainer.TypeDecimal:
+            outfile.write('<%s>%f</%s>' % (
+                self.name, self.value, self.name))
+        elif self.content_type == MixedContainer.TypeDouble:
+            outfile.write('<%s>%g</%s>' % (
+                self.name, self.value, self.name))
+        elif self.content_type == MixedContainer.TypeBase64:
+            outfile.write('<%s>%s</%s>' % (
+                self.name, base64.b64encode(self.value), self.name))
+    def to_etree(self, element):
+        if self.category == MixedContainer.CategoryText:
+            # Prevent exporting empty content as empty lines.
+            if self.value.strip():
+                if len(element) > 0:
+                    if element[-1].tail is None:
+                        element[-1].tail = self.value
+                    else:
+                        element[-1].tail += self.value
+                else:
+                    if element.text is None:
+                        element.text = self.value
+                    else:
+                        element.text += self.value
+        elif self.category == MixedContainer.CategorySimple:
+            subelement = etree_.SubElement(element, '%s' % self.name)
+            subelement.text = self.to_etree_simple()
+        else:    # category == MixedContainer.CategoryComplex
+            self.value.to_etree(element)
+    def to_etree_simple(self):
+        if self.content_type == MixedContainer.TypeString:
+            text = self.value
+        elif (self.content_type == MixedContainer.TypeInteger or
+                self.content_type == MixedContainer.TypeBoolean):
+            text = '%d' % self.value
+        elif (self.content_type == MixedContainer.TypeFloat or
+                self.content_type == MixedContainer.TypeDecimal):
+            text = '%f' % self.value
+        elif self.content_type == MixedContainer.TypeDouble:
+            text = '%g' % self.value
+        elif self.content_type == MixedContainer.TypeBase64:
+            text = '%s' % base64.b64encode(self.value)
+        return text
+    def exportLiteral(self, outfile, level, name):
+        if self.category == MixedContainer.CategoryText:
+            showIndent(outfile, level)
+            outfile.write(
+                'model_.MixedContainer(%d, %d, "%s", "%s"),\n' % (
+                    self.category, self.content_type, self.name, self.value))
+        elif self.category == MixedContainer.CategorySimple:
+            showIndent(outfile, level)
+            outfile.write(
+                'model_.MixedContainer(%d, %d, "%s", "%s"),\n' % (
+                    self.category, self.content_type, self.name, self.value))
+        else:    # category == MixedContainer.CategoryComplex
+            showIndent(outfile, level)
+            outfile.write(
+                'model_.MixedContainer(%d, %d, "%s",\n' % (
+                    self.category, self.content_type, self.name,))
+            self.value.exportLiteral(outfile, level + 1)
+            showIndent(outfile, level)
+            outfile.write(')\n')
+
+
+class MemberSpec_(object):
+    def __init__(self, name='', data_type='', container=0):
+        self.name = name
+        self.data_type = data_type
+        self.container = container
+    def set_name(self, name): self.name = name
+    def get_name(self): return self.name
+    def set_data_type(self, data_type): self.data_type = data_type
+    def get_data_type_chain(self): return self.data_type
+    def get_data_type(self):
+        if isinstance(self.data_type, list):
+            if len(self.data_type) > 0:
+                return self.data_type[-1]
+            else:
+                return 'xs:string'
+        else:
+            return self.data_type
+    def set_container(self, container): self.container = container
+    def get_container(self): return self.container
+
+
+def _cast(typ, value):
+    if typ is None or value is None:
+        return value
+    return typ(value)
+
+#
+# Data representation classes.
+#
+
+
+class containerType(GeneratedsSuper):
+    member_data_items_ = [
+        MemberSpec_('item1', 'classAType', 0),
+        MemberSpec_('item2', 'classBType', 0),
+    ]
+    subclass = None
+    superclass = None
+    def __init__(self, item1=None, item2=None):
+        self.original_tagname_ = None
+        self.item1 = item1
+        self.item2 = item2
+    def factory(*args_, **kwargs_):
+        if containerType.subclass:
+            return containerType.subclass(*args_, **kwargs_)
+        else:
+            return containerType(*args_, **kwargs_)
+    factory = staticmethod(factory)
+    def get_item1(self): return self.item1
+    def set_item1(self, item1): self.item1 = item1
+    def get_item2(self): return self.item2
+    def set_item2(self, item2): self.item2 = item2
+    def hasContent_(self):
+        if (
+            self.item1 is not None or
+            self.item2 is not None
+        ):
+            return True
+        else:
+            return False
+    def export(self, outfile, level, namespace_='', name_='containerType', namespacedef_='', pretty_print=True):
+        if pretty_print:
+            eol_ = '\n'
+        else:
+            eol_ = ''
+        if self.original_tagname_ is not None:
+            name_ = self.original_tagname_
+        showIndent(outfile, level, pretty_print)
+        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
+        already_processed = set()
+        self.exportAttributes(outfile, level, already_processed, namespace_, name_='containerType')
+        if self.hasContent_():
+            outfile.write('>%s' % (eol_, ))
+            self.exportChildren(outfile, level + 1, namespace_='', name_='containerType', pretty_print=pretty_print)
+            showIndent(outfile, level, pretty_print)
+            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
+        else:
+            outfile.write('/>%s' % (eol_, ))
+    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='containerType'):
+        pass
+    def exportChildren(self, outfile, level, namespace_='', name_='containerType', fromsubclass_=False, pretty_print=True):
+        if pretty_print:
+            eol_ = '\n'
+        else:
+            eol_ = ''
+        if self.item1 is not None:
+            self.item1.export(outfile, level, namespace_, name_='item1', pretty_print=pretty_print)
+        if self.item2 is not None:
+            self.item2.export(outfile, level, namespace_, name_='item2', pretty_print=pretty_print)
+    def exportLiteral(self, outfile, level, name_='containerType'):
+        level += 1
+        already_processed = set()
+        self.exportLiteralAttributes(outfile, level, already_processed, name_)
+        if self.hasContent_():
+            self.exportLiteralChildren(outfile, level, name_)
+    def exportLiteralAttributes(self, outfile, level, already_processed, name_):
+        pass
+    def exportLiteralChildren(self, outfile, level, name_):
+        if self.item1 is not None:
+            showIndent(outfile, level)
+            outfile.write('item1=model_.classAType(\n')
+            self.item1.exportLiteral(outfile, level, name_='item1')
+            showIndent(outfile, level)
+            outfile.write('),\n')
+        if self.item2 is not None:
+            showIndent(outfile, level)
+            outfile.write('item2=model_.classBType(\n')
+            self.item2.exportLiteral(outfile, level, name_='item2')
+            showIndent(outfile, level)
+            outfile.write('),\n')
+    def build(self, node):
+        already_processed = set()
+        self.buildAttributes(node, node.attrib, already_processed)
+        for child in node:
+            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
+            self.buildChildren(child, node, nodeName_)
+        return self
+    def buildAttributes(self, node, attrs, already_processed):
+        pass
+    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
+        if nodeName_ == 'item1':
+            obj_ = classAType.factory()
+            obj_.build(child_)
+            self.item1 = obj_
+            obj_.original_tagname_ = 'item1'
+        elif nodeName_ == 'item2':
+            obj_ = classBType.factory()
+            obj_.build(child_)
+            self.item2 = obj_
+            obj_.original_tagname_ = 'item2'
+# end class containerType
+
+
+class classAType(GeneratedsSuper):
+    member_data_items_ = [
+        MemberSpec_('inner', 'inner_001', 0),
+    ]
+    subclass = None
+    superclass = None
+    def __init__(self, inner=None):
+        self.original_tagname_ = None
+        self.inner = inner
+    def factory(*args_, **kwargs_):
+        if classAType.subclass:
+            return classAType.subclass(*args_, **kwargs_)
+        else:
+            return classAType(*args_, **kwargs_)
+    factory = staticmethod(factory)
+    def get_inner(self): return self.inner
+    def set_inner(self, inner): self.inner = inner
+    def hasContent_(self):
+        if (
+            self.inner is not None
+        ):
+            return True
+        else:
+            return False
+    def export(self, outfile, level, namespace_='', name_='classAType', namespacedef_='', pretty_print=True):
+        if pretty_print:
+            eol_ = '\n'
+        else:
+            eol_ = ''
+        if self.original_tagname_ is not None:
+            name_ = self.original_tagname_
+        showIndent(outfile, level, pretty_print)
+        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
+        already_processed = set()
+        self.exportAttributes(outfile, level, already_processed, namespace_, name_='classAType')
+        if self.hasContent_():
+            outfile.write('>%s' % (eol_, ))
+            self.exportChildren(outfile, level + 1, namespace_='', name_='classAType', pretty_print=pretty_print)
+            showIndent(outfile, level, pretty_print)
+            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
+        else:
+            outfile.write('/>%s' % (eol_, ))
+    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='classAType'):
+        pass
+    def exportChildren(self, outfile, level, namespace_='', name_='classAType', fromsubclass_=False, pretty_print=True):
+        if pretty_print:
+            eol_ = '\n'
+        else:
+            eol_ = ''
+        if self.inner is not None:
+            self.inner.export(outfile, level, namespace_, name_='inner', pretty_print=pretty_print)
+    def exportLiteral(self, outfile, level, name_='classAType'):
+        level += 1
+        already_processed = set()
+        self.exportLiteralAttributes(outfile, level, already_processed, name_)
+        if self.hasContent_():
+            self.exportLiteralChildren(outfile, level, name_)
+    def exportLiteralAttributes(self, outfile, level, already_processed, name_):
+        pass
+    def exportLiteralChildren(self, outfile, level, name_):
+        if self.inner is not None:
+            showIndent(outfile, level)
+            outfile.write('inner=model_.inner_001(\n')
+            self.inner.exportLiteral(outfile, level, name_='inner')
+            showIndent(outfile, level)
+            outfile.write('),\n')
+    def build(self, node):
+        already_processed = set()
+        self.buildAttributes(node, node.attrib, already_processed)
+        for child in node:
+            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
+            self.buildChildren(child, node, nodeName_)
+        return self
+    def buildAttributes(self, node, attrs, already_processed):
+        pass
+    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
+        if nodeName_ == 'inner':
+            obj_ = inner_001.factory()
+            obj_.build(child_)
+            self.inner = obj_
+            obj_.original_tagname_ = 'inner'
+# end class classAType
+
+
+class classBType(GeneratedsSuper):
+    member_data_items_ = [
+        MemberSpec_('inner', 'inner_002', 0),
+    ]
+    subclass = None
+    superclass = None
+    def __init__(self, inner=None):
+        self.original_tagname_ = None
+        self.inner = inner
+    def factory(*args_, **kwargs_):
+        if classBType.subclass:
+            return classBType.subclass(*args_, **kwargs_)
+        else:
+            return classBType(*args_, **kwargs_)
+    factory = staticmethod(factory)
+    def get_inner(self): return self.inner
+    def set_inner(self, inner): self.inner = inner
+    def hasContent_(self):
+        if (
+            self.inner is not None
+        ):
+            return True
+        else:
+            return False
+    def export(self, outfile, level, namespace_='', name_='classBType', namespacedef_='', pretty_print=True):
+        if pretty_print:
+            eol_ = '\n'
+        else:
+            eol_ = ''
+        if self.original_tagname_ is not None:
+            name_ = self.original_tagname_
+        showIndent(outfile, level, pretty_print)
+        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
+        already_processed = set()
+        self.exportAttributes(outfile, level, already_processed, namespace_, name_='classBType')
+        if self.hasContent_():
+            outfile.write('>%s' % (eol_, ))
+            self.exportChildren(outfile, level + 1, namespace_='', name_='classBType', pretty_print=pretty_print)
+            showIndent(outfile, level, pretty_print)
+            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
+        else:
+            outfile.write('/>%s' % (eol_, ))
+    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='classBType'):
+        pass
+    def exportChildren(self, outfile, level, namespace_='', name_='classBType', fromsubclass_=False, pretty_print=True):
+        if pretty_print:
+            eol_ = '\n'
+        else:
+            eol_ = ''
+        if self.inner is not None:
+            self.inner.export(outfile, level, namespace_, name_='inner', pretty_print=pretty_print)
+    def exportLiteral(self, outfile, level, name_='classBType'):
+        level += 1
+        already_processed = set()
+        self.exportLiteralAttributes(outfile, level, already_processed, name_)
+        if self.hasContent_():
+            self.exportLiteralChildren(outfile, level, name_)
+    def exportLiteralAttributes(self, outfile, level, already_processed, name_):
+        pass
+    def exportLiteralChildren(self, outfile, level, name_):
+        if self.inner is not None:
+            showIndent(outfile, level)
+            outfile.write('inner=model_.inner_002(\n')
+            self.inner.exportLiteral(outfile, level, name_='inner')
+            showIndent(outfile, level)
+            outfile.write('),\n')
+    def build(self, node):
+        already_processed = set()
+        self.buildAttributes(node, node.attrib, already_processed)
+        for child in node:
+            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
+            self.buildChildren(child, node, nodeName_)
+        return self
+    def buildAttributes(self, node, attrs, already_processed):
+        pass
+    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
+        if nodeName_ == 'inner':
+            obj_ = inner_002.factory()
+            obj_.build(child_)
+            self.inner = obj_
+            obj_.original_tagname_ = 'inner'
+# end class classBType
+
+
+class inner_001(GeneratedsSuper):
+    member_data_items_ = [
+        MemberSpec_('attrA1', 'xs:string', 0),
+        MemberSpec_('attrA2', 'xs:string', 0),
+    ]
+    subclass = None
+    superclass = None
+    def __init__(self, attrA1=None, attrA2=None):
+        self.original_tagname_ = None
+        self.attrA1 = _cast(None, attrA1)
+        self.attrA2 = _cast(None, attrA2)
+    def factory(*args_, **kwargs_):
+        if inner_001.subclass:
+            return inner_001.subclass(*args_, **kwargs_)
+        else:
+            return inner_001(*args_, **kwargs_)
+    factory = staticmethod(factory)
+    def get_attrA1(self): return self.attrA1
+    def set_attrA1(self, attrA1): self.attrA1 = attrA1
+    def get_attrA2(self): return self.attrA2
+    def set_attrA2(self, attrA2): self.attrA2 = attrA2
+    def hasContent_(self):
+        if (
+
+        ):
+            return True
+        else:
+            return False
+    def export(self, outfile, level, namespace_='', name_='inner_001', namespacedef_='', pretty_print=True):
+        if pretty_print:
+            eol_ = '\n'
+        else:
+            eol_ = ''
+        if self.original_tagname_ is not None:
+            name_ = self.original_tagname_
+        showIndent(outfile, level, pretty_print)
+        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
+        already_processed = set()
+        self.exportAttributes(outfile, level, already_processed, namespace_, name_='inner_001')
+        if self.hasContent_():
+            outfile.write('>%s' % (eol_, ))
+            self.exportChildren(outfile, level + 1, namespace_='', name_='inner_001', pretty_print=pretty_print)
+            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
+        else:
+            outfile.write('/>%s' % (eol_, ))
+    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='inner_001'):
+        if self.attrA1 is not None and 'attrA1' not in already_processed:
+            already_processed.add('attrA1')
+            outfile.write(' attrA1=%s' % (self.gds_format_string(quote_attrib(self.attrA1).encode(ExternalEncoding), input_name='attrA1'), ))
+        if self.attrA2 is not None and 'attrA2' not in already_processed:
+            already_processed.add('attrA2')
+            outfile.write(' attrA2=%s' % (self.gds_format_string(quote_attrib(self.attrA2).encode(ExternalEncoding), input_name='attrA2'), ))
+    def exportChildren(self, outfile, level, namespace_='', name_='inner_001', fromsubclass_=False, pretty_print=True):
+        pass
+    def exportLiteral(self, outfile, level, name_='inner_001'):
+        level += 1
+        already_processed = set()
+        self.exportLiteralAttributes(outfile, level, already_processed, name_)
+        if self.hasContent_():
+            self.exportLiteralChildren(outfile, level, name_)
+    def exportLiteralAttributes(self, outfile, level, already_processed, name_):
+        if self.attrA1 is not None and 'attrA1' not in already_processed:
+            already_processed.add('attrA1')
+            showIndent(outfile, level)
+            outfile.write('attrA1="%s",\n' % (self.attrA1,))
+        if self.attrA2 is not None and 'attrA2' not in already_processed:
+            already_processed.add('attrA2')
+            showIndent(outfile, level)
+            outfile.write('attrA2="%s",\n' % (self.attrA2,))
+    def exportLiteralChildren(self, outfile, level, name_):
+        pass
+    def build(self, node):
+        already_processed = set()
+        self.buildAttributes(node, node.attrib, already_processed)
+        for child in node:
+            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
+            self.buildChildren(child, node, nodeName_)
+        return self
+    def buildAttributes(self, node, attrs, already_processed):
+        value = find_attr_value_('attrA1', node)
+        if value is not None and 'attrA1' not in already_processed:
+            already_processed.add('attrA1')
+            self.attrA1 = value
+        value = find_attr_value_('attrA2', node)
+        if value is not None and 'attrA2' not in already_processed:
+            already_processed.add('attrA2')
+            self.attrA2 = value
+    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
+        pass
+# end class inner_001
+
+
+class inner_002(GeneratedsSuper):
+    member_data_items_ = [
+        MemberSpec_('attrB1', 'xs:string', 0),
+        MemberSpec_('attrB2', 'xs:string', 0),
+    ]
+    subclass = None
+    superclass = None
+    def __init__(self, attrB1=None, attrB2=None):
+        self.original_tagname_ = None
+        self.attrB1 = _cast(None, attrB1)
+        self.attrB2 = _cast(None, attrB2)
+    def factory(*args_, **kwargs_):
+        if inner_002.subclass:
+            return inner_002.subclass(*args_, **kwargs_)
+        else:
+            return inner_002(*args_, **kwargs_)
+    factory = staticmethod(factory)
+    def get_attrB1(self): return self.attrB1
+    def set_attrB1(self, attrB1): self.attrB1 = attrB1
+    def get_attrB2(self): return self.attrB2
+    def set_attrB2(self, attrB2): self.attrB2 = attrB2
+    def hasContent_(self):
+        if (
+
+        ):
+            return True
+        else:
+            return False
+    def export(self, outfile, level, namespace_='', name_='inner_002', namespacedef_='', pretty_print=True):
+        if pretty_print:
+            eol_ = '\n'
+        else:
+            eol_ = ''
+        if self.original_tagname_ is not None:
+            name_ = self.original_tagname_
+        showIndent(outfile, level, pretty_print)
+        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
+        already_processed = set()
+        self.exportAttributes(outfile, level, already_processed, namespace_, name_='inner_002')
+        if self.hasContent_():
+            outfile.write('>%s' % (eol_, ))
+            self.exportChildren(outfile, level + 1, namespace_='', name_='inner_002', pretty_print=pretty_print)
+            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
+        else:
+            outfile.write('/>%s' % (eol_, ))
+    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='inner_002'):
+        if self.attrB1 is not None and 'attrB1' not in already_processed:
+            already_processed.add('attrB1')
+            outfile.write(' attrB1=%s' % (self.gds_format_string(quote_attrib(self.attrB1).encode(ExternalEncoding), input_name='attrB1'), ))
+        if self.attrB2 is not None and 'attrB2' not in already_processed:
+            already_processed.add('attrB2')
+            outfile.write(' attrB2=%s' % (self.gds_format_string(quote_attrib(self.attrB2).encode(ExternalEncoding), input_name='attrB2'), ))
+    def exportChildren(self, outfile, level, namespace_='', name_='inner_002', fromsubclass_=False, pretty_print=True):
+        pass
+    def exportLiteral(self, outfile, level, name_='inner_002'):
+        level += 1
+        already_processed = set()
+        self.exportLiteralAttributes(outfile, level, already_processed, name_)
+        if self.hasContent_():
+            self.exportLiteralChildren(outfile, level, name_)
+    def exportLiteralAttributes(self, outfile, level, already_processed, name_):
+        if self.attrB1 is not None and 'attrB1' not in already_processed:
+            already_processed.add('attrB1')
+            showIndent(outfile, level)
+            outfile.write('attrB1="%s",\n' % (self.attrB1,))
+        if self.attrB2 is not None and 'attrB2' not in already_processed:
+            already_processed.add('attrB2')
+            showIndent(outfile, level)
+            outfile.write('attrB2="%s",\n' % (self.attrB2,))
+    def exportLiteralChildren(self, outfile, level, name_):
+        pass
+    def build(self, node):
+        already_processed = set()
+        self.buildAttributes(node, node.attrib, already_processed)
+        for child in node:
+            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
+            self.buildChildren(child, node, nodeName_)
+        return self
+    def buildAttributes(self, node, attrs, already_processed):
+        value = find_attr_value_('attrB1', node)
+        if value is not None and 'attrB1' not in already_processed:
+            already_processed.add('attrB1')
+            self.attrB1 = value
+        value = find_attr_value_('attrB2', node)
+        if value is not None and 'attrB2' not in already_processed:
+            already_processed.add('attrB2')
+            self.attrB2 = value
+    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
+        pass
+# end class inner_002
+
+
+GDSClassesMapping = {
+    'container': containerType,
+    'item2': classBType,
+    'item1': classAType,
+    'classB': classBType,
+    'classA': classAType,
+    'inner': inner_002,
+}
+
+
+USAGE_TEXT = """
+Usage: python <Parser>.py [ -s ] <in_xml_file>
+"""
+
+
+def usage():
+    print(USAGE_TEXT)
+    sys.exit(1)
+
+
+def get_root_tag(node):
+    tag = Tag_pattern_.match(node.tag).groups()[-1]
+    rootClass = GDSClassesMapping.get(tag)
+    if rootClass is None:
+        rootClass = globals().get(tag)
+    return tag, rootClass
+
+
+def parse(inFileName, silence=False):
+    parser = None
+    doc = parsexml_(inFileName, parser)
+    rootNode = doc.getroot()
+    rootTag, rootClass = get_root_tag(rootNode)
+    if rootClass is None:
+        rootTag = 'containerType'
+        rootClass = containerType
+    rootObj = rootClass.factory()
+    rootObj.build(rootNode)
+    # Enable Python to collect the space used by the DOM.
+    doc = None
+    if not silence:
+        sys.stdout.write('<?xml version="1.0" ?>\n')
+        rootObj.export(
+            sys.stdout, 0, name_=rootTag,
+            namespacedef_='',
+            pretty_print=True)
+    return rootObj
+
+
+def parseEtree(inFileName, silence=False):
+    parser = None
+    doc = parsexml_(inFileName, parser)
+    rootNode = doc.getroot()
+    rootTag, rootClass = get_root_tag(rootNode)
+    if rootClass is None:
+        rootTag = 'containerType'
+        rootClass = containerType
+    rootObj = rootClass.factory()
+    rootObj.build(rootNode)
+    # Enable Python to collect the space used by the DOM.
+    doc = None
+    mapping = {}
+    rootElement = rootObj.to_etree(None, name_=rootTag, mapping_=mapping)
+    reverse_mapping = rootObj.gds_reverse_node_mapping(mapping)
+    if not silence:
+        content = etree_.tostring(
+            rootElement, pretty_print=True,
+            xml_declaration=True, encoding="utf-8")
+        sys.stdout.write(content)
+        sys.stdout.write('\n')
+    return rootObj, rootElement, mapping, reverse_mapping
+
+
+def parseString(inString, silence=False):
+    from StringIO import StringIO
+    parser = None
+    doc = parsexml_(StringIO(inString), parser)
+    rootNode = doc.getroot()
+    rootTag, rootClass = get_root_tag(rootNode)
+    if rootClass is None:
+        rootTag = 'containerType'
+        rootClass = containerType
+    rootObj = rootClass.factory()
+    rootObj.build(rootNode)
+    # Enable Python to collect the space used by the DOM.
+    doc = None
+    if not silence:
+        sys.stdout.write('<?xml version="1.0" ?>\n')
+        rootObj.export(
+            sys.stdout, 0, name_=rootTag,
+            namespacedef_='')
+    return rootObj
+
+
+def parseLiteral(inFileName, silence=False):
+    parser = None
+    doc = parsexml_(inFileName, parser)
+    rootNode = doc.getroot()
+    rootTag, rootClass = get_root_tag(rootNode)
+    if rootClass is None:
+        rootTag = 'containerType'
+        rootClass = containerType
+    rootObj = rootClass.factory()
+    rootObj.build(rootNode)
+    # Enable Python to collect the space used by the DOM.
+    doc = None
+    if not silence:
+        sys.stdout.write('#from nested_def2_sup import *\n\n')
+        sys.stdout.write('import nested_def2_sup as model_\n\n')
+        sys.stdout.write('rootObj = model_.rootClass(\n')
+        rootObj.exportLiteral(sys.stdout, 0, name_=rootTag)
+        sys.stdout.write(')\n')
+    return rootObj
+
+
+def main():
+    args = sys.argv[1:]
+    if len(args) == 1:
+        parse(args[0])
+    else:
+        usage()
+
+
+if __name__ == '__main__':
+    #import pdb; pdb.set_trace()
+    main()
+
+
+__all__ = [
+    "classAType",
+    "classBType",
+    "containerType",
+    "inner_001",
+    "inner_002"
+]
diff --git a/tests/nested_def2_out.xml b/tests/nested_def2_out.xml
new file mode 100644
index 0000000..692c598
--- /dev/null
+++ b/tests/nested_def2_out.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" ?>
+<container>
+    <item1>
+        <inner attrA1="attrA1value" attrA2="attrA2value"/>
+    </item1>
+    <item2>
+        <inner attrB1="attrB1value" attrB2="attrB2value"/>
+    </item2>
+</container>
diff --git a/tests/nested_def2_sub.py b/tests/nested_def2_sub.py
new file mode 100644
index 0000000..0bb693d
--- /dev/null
+++ b/tests/nested_def2_sub.py
@@ -0,0 +1,200 @@
+#!/usr/bin/env python
+
+#
+# Generated  by generateDS.py.
+#
+# Command line options:
+#   ('--no-dates', '')
+#   ('--no-versions', '')
+#   ('--member-specs', 'list')
+#   ('-f', '')
+#   ('-o', 'tests/nested_def2_sup.py')
+#   ('-s', 'tests/nested_def2_sub.py')
+#   ('--super', 'nested_def2_sup')
+#
+# Command line arguments:
+#   tests/nested_def.xsd
+#
+# Command line:
+#   generateDS.py --no-dates --no-versions --member-specs="list" -f -o "tests/nested_def2_sup.py" -s "tests/nested_def2_sub.py" --super="nested_def2_sup" tests/nested_def.xsd
+#
+# Current working directory (os.getcwd()):
+#   generateds
+#
+
+import sys
+from lxml import etree as etree_
+
+import nested_def2_sup as supermod
+
+def parsexml_(infile, parser=None, **kwargs):
+    if parser is None:
+        # Use the lxml ElementTree compatible parser so that, e.g.,
+        #   we ignore comments.
+        parser = etree_.ETCompatXMLParser()
+    doc = etree_.parse(infile, parser=parser, **kwargs)
+    return doc
+
+#
+# Globals
+#
+
+ExternalEncoding = 'ascii'
+
+#
+# Data representation classes
+#
+
+
+class containerTypeSub(supermod.containerType):
+    def __init__(self, item1=None, item2=None):
+        super(containerTypeSub, self).__init__(item1, item2, )
+supermod.containerType.subclass = containerTypeSub
+# end class containerTypeSub
+
+
+class classATypeSub(supermod.classAType):
+    def __init__(self, inner=None):
+        super(classATypeSub, self).__init__(inner, )
+supermod.classAType.subclass = classATypeSub
+# end class classATypeSub
+
+
+class classBTypeSub(supermod.classBType):
+    def __init__(self, inner=None):
+        super(classBTypeSub, self).__init__(inner, )
+supermod.classBType.subclass = classBTypeSub
+# end class classBTypeSub
+
+
+class inner_001Sub(supermod.inner_001):
+    def __init__(self, attrA1=None, attrA2=None):
+        super(inner_001Sub, self).__init__(attrA1, attrA2, )
+supermod.inner_001.subclass = inner_001Sub
+# end class inner_001Sub
+
+
+class inner_002Sub(supermod.inner_002):
+    def __init__(self, attrB1=None, attrB2=None):
+        super(inner_002Sub, self).__init__(attrB1, attrB2, )
+supermod.inner_002.subclass = inner_002Sub
+# end class inner_002Sub
+
+
+def get_root_tag(node):
+    tag = supermod.Tag_pattern_.match(node.tag).groups()[-1]
+    rootClass = None
+    rootClass = supermod.GDSClassesMapping.get(tag)
+    if rootClass is None and hasattr(supermod, tag):
+        rootClass = getattr(supermod, tag)
+    return tag, rootClass
+
+
+def parse(inFilename, silence=False):
+    parser = None
+    doc = parsexml_(inFilename, parser)
+    rootNode = doc.getroot()
+    rootTag, rootClass = get_root_tag(rootNode)
+    if rootClass is None:
+        rootTag = 'containerType'
+        rootClass = supermod.containerType
+    rootObj = rootClass.factory()
+    rootObj.build(rootNode)
+    # Enable Python to collect the space used by the DOM.
+    doc = None
+    if not silence:
+        sys.stdout.write('<?xml version="1.0" ?>\n')
+        rootObj.export(
+            sys.stdout, 0, name_=rootTag,
+            namespacedef_='',
+            pretty_print=True)
+    return rootObj
+
+
+def parseEtree(inFilename, silence=False):
+    parser = None
+    doc = parsexml_(inFilename, parser)
+    rootNode = doc.getroot()
+    rootTag, rootClass = get_root_tag(rootNode)
+    if rootClass is None:
+        rootTag = 'containerType'
+        rootClass = supermod.containerType
+    rootObj = rootClass.factory()
+    rootObj.build(rootNode)
+    # Enable Python to collect the space used by the DOM.
+    doc = None
+    mapping = {}
+    rootElement = rootObj.to_etree(None, name_=rootTag, mapping_=mapping)
+    reverse_mapping = rootObj.gds_reverse_node_mapping(mapping)
+    if not silence:
+        content = etree_.tostring(
+            rootElement, pretty_print=True,
+            xml_declaration=True, encoding="utf-8")
+        sys.stdout.write(content)
+        sys.stdout.write('\n')
+    return rootObj, rootElement, mapping, reverse_mapping
+
+
+def parseString(inString, silence=False):
+    from StringIO import StringIO
+    parser = None
+    doc = parsexml_(StringIO(inString), parser)
+    rootNode = doc.getroot()
+    rootTag, rootClass = get_root_tag(rootNode)
+    if rootClass is None:
+        rootTag = 'containerType'
+        rootClass = supermod.containerType
+    rootObj = rootClass.factory()
+    rootObj.build(rootNode)
+    # Enable Python to collect the space used by the DOM.
+    doc = None
+    if not silence:
+        sys.stdout.write('<?xml version="1.0" ?>\n')
+        rootObj.export(
+            sys.stdout, 0, name_=rootTag,
+            namespacedef_='')
+    return rootObj
+
+
+def parseLiteral(inFilename, silence=False):
+    parser = None
+    doc = parsexml_(inFilename, parser)
+    rootNode = doc.getroot()
+    rootTag, rootClass = get_root_tag(rootNode)
+    if rootClass is None:
+        rootTag = 'containerType'
+        rootClass = supermod.containerType
+    rootObj = rootClass.factory()
+    rootObj.build(rootNode)
+    # Enable Python to collect the space used by the DOM.
+    doc = None
+    if not silence:
+        sys.stdout.write('#from nested_def2_sup import *\n\n')
+        sys.stdout.write('import nested_def2_sup as model_\n\n')
+        sys.stdout.write('rootObj = model_.rootClass(\n')
+        rootObj.exportLiteral(sys.stdout, 0, name_=rootTag)
+        sys.stdout.write(')\n')
+    return rootObj
+
+
+USAGE_TEXT = """
+Usage: python ???.py <infilename>
+"""
+
+
+def usage():
+    print(USAGE_TEXT)
+    sys.exit(1)
+
+
+def main():
+    args = sys.argv[1:]
+    if len(args) != 1:
+        usage()
+    infilename = args[0]
+    parse(infilename)
+
+
+if __name__ == '__main__':
+    #import pdb; pdb.set_trace()
+    main()
diff --git a/tests/nested_def2_sup.py b/tests/nested_def2_sup.py
new file mode 100644
index 0000000..d49c00e
--- /dev/null
+++ b/tests/nested_def2_sup.py
@@ -0,0 +1,1216 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+#
+# Generated  by generateDS.py.
+#
+# Command line options:
+#   ('--no-dates', '')
+#   ('--no-versions', '')
+#   ('--member-specs', 'list')
+#   ('-f', '')
+#   ('-o', 'tests/nested_def2_sup.py')
+#   ('-s', 'tests/nested_def2_sub.py')
+#   ('--super', 'nested_def2_sup')
+#
+# Command line arguments:
+#   tests/nested_def.xsd
+#
+# Command line:
+#   generateDS.py --no-dates --no-versions --member-specs="list" -f -o "tests/nested_def2_sup.py" -s "tests/nested_def2_sub.py" --super="nested_def2_sup" tests/nested_def.xsd
+#
+# Current working directory (os.getcwd()):
+#   generateds
+#
+
+import sys
+import re as re_
+import base64
+import datetime as datetime_
+import warnings as warnings_
+from lxml import etree as etree_
+
+
+Validate_simpletypes_ = True
+
+
+def parsexml_(infile, parser=None, **kwargs):
+    if parser is None:
+        # Use the lxml ElementTree compatible parser so that, e.g.,
+        #   we ignore comments.
+        parser = etree_.ETCompatXMLParser()
+    doc = etree_.parse(infile, parser=parser, **kwargs)
+    return doc
+
+#
+# User methods
+#
+# Calls to the methods in these classes are generated by generateDS.py.
+# You can replace these methods by re-implementing the following class
+#   in a module named generatedssuper.py.
+
+try:
+    from generatedssuper import GeneratedsSuper
+except ImportError as exp:
+
+    class GeneratedsSuper(object):
+        tzoff_pattern = re_.compile(r'(\+|-)((0\d|1[0-3]):[0-5]\d|14:00)$')
+        class _FixedOffsetTZ(datetime_.tzinfo):
+            def __init__(self, offset, name):
+                self.__offset = datetime_.timedelta(minutes=offset)
+                self.__name = name
+            def utcoffset(self, dt):
+                return self.__offset
+            def tzname(self, dt):
+                return self.__name
+            def dst(self, dt):
+                return None
+        def gds_format_string(self, input_data, input_name=''):
+            return input_data
+        def gds_validate_string(self, input_data, node=None, input_name=''):
+            if not input_data:
+                return ''
+            else:
+                return input_data
+        def gds_format_base64(self, input_data, input_name=''):
+            return base64.b64encode(input_data)
+        def gds_validate_base64(self, input_data, node=None, input_name=''):
+            return input_data
+        def gds_format_integer(self, input_data, input_name=''):
+            return '%d' % input_data
+        def gds_validate_integer(self, input_data, node=None, input_name=''):
+            return input_data
+        def gds_format_integer_list(self, input_data, input_name=''):
+            return '%s' % ' '.join(input_data)
+        def gds_validate_integer_list(
+                self, input_data, node=None, input_name=''):
+            values = input_data.split()
+            for value in values:
+                try:
+                    int(value)
+                except (TypeError, ValueError):
+                    raise_parse_error(node, 'Requires sequence of integers')
+            return values
+        def gds_format_float(self, input_data, input_name=''):
+            return ('%.15f' % input_data).rstrip('0')
+        def gds_validate_float(self, input_data, node=None, input_name=''):
+            return input_data
+        def gds_format_float_list(self, input_data, input_name=''):
+            return '%s' % ' '.join(input_data)
+        def gds_validate_float_list(
+                self, input_data, node=None, input_name=''):
+            values = input_data.split()
+            for value in values:
+                try:
+                    float(value)
+                except (TypeError, ValueError):
+                    raise_parse_error(node, 'Requires sequence of floats')
+            return values
+        def gds_format_double(self, input_data, input_name=''):
+            return '%e' % input_data
+        def gds_validate_double(self, input_data, node=None, input_name=''):
+            return input_data
+        def gds_format_double_list(self, input_data, input_name=''):
+            return '%s' % ' '.join(input_data)
+        def gds_validate_double_list(
+                self, input_data, node=None, input_name=''):
+            values = input_data.split()
+            for value in values:
+                try:
+                    float(value)
+                except (TypeError, ValueError):
+                    raise_parse_error(node, 'Requires sequence of doubles')
+            return values
+        def gds_format_boolean(self, input_data, input_name=''):
+            return ('%s' % input_data).lower()
+        def gds_validate_boolean(self, input_data, node=None, input_name=''):
+            return input_data
+        def gds_format_boolean_list(self, input_data, input_name=''):
+            return '%s' % ' '.join(input_data)
+        def gds_validate_boolean_list(
+                self, input_data, node=None, input_name=''):
+            values = input_data.split()
+            for value in values:
+                if value not in ('true', '1', 'false', '0', ):
+                    raise_parse_error(
+                        node,
+                        'Requires sequence of booleans '
+                        '("true", "1", "false", "0")')
+            return values
+        def gds_validate_datetime(self, input_data, node=None, input_name=''):
+            return input_data
+        def gds_format_datetime(self, input_data, input_name=''):
+            if input_data.microsecond == 0:
+                _svalue = '%04d-%02d-%02dT%02d:%02d:%02d' % (
+                    input_data.year,
+                    input_data.month,
+                    input_data.day,
+                    input_data.hour,
+                    input_data.minute,
+                    input_data.second,
+                )
+            else:
+                _svalue = '%04d-%02d-%02dT%02d:%02d:%02d.%s' % (
+                    input_data.year,
+                    input_data.month,
+                    input_data.day,
+                    input_data.hour,
+                    input_data.minute,
+                    input_data.second,
+                    ('%f' % (float(input_data.microsecond) / 1000000))[2:],
+                )
+            if input_data.tzinfo is not None:
+                tzoff = input_data.tzinfo.utcoffset(input_data)
+                if tzoff is not None:
+                    total_seconds = tzoff.seconds + (86400 * tzoff.days)
+                    if total_seconds == 0:
+                        _svalue += 'Z'
+                    else:
+                        if total_seconds < 0:
+                            _svalue += '-'
+                            total_seconds *= -1
+                        else:
+                            _svalue += '+'
+                        hours = total_seconds // 3600
+                        minutes = (total_seconds - (hours * 3600)) // 60
+                        _svalue += '{0:02d}:{1:02d}'.format(hours, minutes)
+            return _svalue
+        @classmethod
+        def gds_parse_datetime(cls, input_data):
+            tz = None
+            if input_data[-1] == 'Z':
+                tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC')
+                input_data = input_data[:-1]
+            else:
+                results = GeneratedsSuper.tzoff_pattern.search(input_data)
+                if results is not None:
+                    tzoff_parts = results.group(2).split(':')
+                    tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1])
+                    if results.group(1) == '-':
+                        tzoff *= -1
+                    tz = GeneratedsSuper._FixedOffsetTZ(
+                        tzoff, results.group(0))
+                    input_data = input_data[:-6]
+            time_parts = input_data.split('.')
+            if len(time_parts) > 1:
+                micro_seconds = int(float('0.' + time_parts[1]) * 1000000)
+                input_data = '%s.%s' % (time_parts[0], micro_seconds, )
+                dt = datetime_.datetime.strptime(
+                    input_data, '%Y-%m-%dT%H:%M:%S.%f')
+            else:
+                dt = datetime_.datetime.strptime(
+                    input_data, '%Y-%m-%dT%H:%M:%S')
+            dt = dt.replace(tzinfo=tz)
+            return dt
+        def gds_validate_date(self, input_data, node=None, input_name=''):
+            return input_data
+        def gds_format_date(self, input_data, input_name=''):
+            _svalue = '%04d-%02d-%02d' % (
+                input_data.year,
+                input_data.month,
+                input_data.day,
+            )
+            try:
+                if input_data.tzinfo is not None:
+                    tzoff = input_data.tzinfo.utcoffset(input_data)
+                    if tzoff is not None:
+                        total_seconds = tzoff.seconds + (86400 * tzoff.days)
+                        if total_seconds == 0:
+                            _svalue += 'Z'
+                        else:
+                            if total_seconds < 0:
+                                _svalue += '-'
+                                total_seconds *= -1
+                            else:
+                                _svalue += '+'
+                            hours = total_seconds // 3600
+                            minutes = (total_seconds - (hours * 3600)) // 60
+                            _svalue += '{0:02d}:{1:02d}'.format(hours, minutes)
+            except AttributeError:
+                pass
+            return _svalue
+        @classmethod
+        def gds_parse_date(cls, input_data):
+            tz = None
+            if input_data[-1] == 'Z':
+                tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC')
+                input_data = input_data[:-1]
+            else:
+                results = GeneratedsSuper.tzoff_pattern.search(input_data)
+                if results is not None:
+                    tzoff_parts = results.group(2).split(':')
+                    tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1])
+                    if results.group(1) == '-':
+                        tzoff *= -1
+                    tz = GeneratedsSuper._FixedOffsetTZ(
+                        tzoff, results.group(0))
+                    input_data = input_data[:-6]
+            dt = datetime_.datetime.strptime(input_data, '%Y-%m-%d')
+            dt = dt.replace(tzinfo=tz)
+            return dt.date()
+        def gds_validate_time(self, input_data, node=None, input_name=''):
+            return input_data
+        def gds_format_time(self, input_data, input_name=''):
+            if input_data.microsecond == 0:
+                _svalue = '%02d:%02d:%02d' % (
+                    input_data.hour,
+                    input_data.minute,
+                    input_data.second,
+                )
+            else:
+                _svalue = '%02d:%02d:%02d.%s' % (
+                    input_data.hour,
+                    input_data.minute,
+                    input_data.second,
+                    ('%f' % (float(input_data.microsecond) / 1000000))[2:],
+                )
+            if input_data.tzinfo is not None:
+                tzoff = input_data.tzinfo.utcoffset(input_data)
+                if tzoff is not None:
+                    total_seconds = tzoff.seconds + (86400 * tzoff.days)
+                    if total_seconds == 0:
+                        _svalue += 'Z'
+                    else:
+                        if total_seconds < 0:
+                            _svalue += '-'
+                            total_seconds *= -1
+                        else:
+                            _svalue += '+'
+                        hours = total_seconds // 3600
+                        minutes = (total_seconds - (hours * 3600)) // 60
+                        _svalue += '{0:02d}:{1:02d}'.format(hours, minutes)
+            return _svalue
+        def gds_validate_simple_patterns(self, patterns, target):
+            # pat is a list of lists of strings/patterns.  We should:
+            # - AND the outer elements
+            # - OR the inner elements
+            found1 = True
+            for patterns1 in patterns:
+                found2 = False
+                for patterns2 in patterns1:
+                    if re_.search(patterns2, target) is not None:
+                        found2 = True
+                        break
+                if not found2:
+                    found1 = False
+                    break
+            return found1
+        @classmethod
+        def gds_parse_time(cls, input_data):
+            tz = None
+            if input_data[-1] == 'Z':
+                tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC')
+                input_data = input_data[:-1]
+            else:
+                results = GeneratedsSuper.tzoff_pattern.search(input_data)
+                if results is not None:
+                    tzoff_parts = results.group(2).split(':')
+                    tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1])
+                    if results.group(1) == '-':
+                        tzoff *= -1
+                    tz = GeneratedsSuper._FixedOffsetTZ(
+                        tzoff, results.group(0))
+                    input_data = input_data[:-6]
+            if len(input_data.split('.')) > 1:
+                dt = datetime_.datetime.strptime(input_data, '%H:%M:%S.%f')
+            else:
+                dt = datetime_.datetime.strptime(input_data, '%H:%M:%S')
+            dt = dt.replace(tzinfo=tz)
+            return dt.time()
+        def gds_str_lower(self, instring):
+            return instring.lower()
+        def get_path_(self, node):
+            path_list = []
+            self.get_path_list_(node, path_list)
+            path_list.reverse()
+            path = '/'.join(path_list)
+            return path
+        Tag_strip_pattern_ = re_.compile(r'\{.*\}')
+        def get_path_list_(self, node, path_list):
+            if node is None:
+                return
+            tag = GeneratedsSuper.Tag_strip_pattern_.sub('', node.tag)
+            if tag:
+                path_list.append(tag)
+            self.get_path_list_(node.getparent(), path_list)
+        def get_class_obj_(self, node, default_class=None):
+            class_obj1 = default_class
+            if 'xsi' in node.nsmap:
+                classname = node.get('{%s}type' % node.nsmap['xsi'])
+                if classname is not None:
+                    names = classname.split(':')
+                    if len(names) == 2:
+                        classname = names[1]
+                    class_obj2 = globals().get(classname)
+                    if class_obj2 is not None:
+                        class_obj1 = class_obj2
+            return class_obj1
+        def gds_build_any(self, node, type_name=None):
+            return None
+        @classmethod
+        def gds_reverse_node_mapping(cls, mapping):
+            return dict(((v, k) for k, v in mapping.iteritems()))
+
+
+#
+# If you have installed IPython you can uncomment and use the following.
+# IPython is available from http://ipython.scipy.org/.
+#
+
+## from IPython.Shell import IPShellEmbed
+## args = ''
+## ipshell = IPShellEmbed(args,
+##     banner = 'Dropping into IPython',
+##     exit_msg = 'Leaving Interpreter, back to program.')
+
+# Then use the following line where and when you want to drop into the
+# IPython shell:
+#    ipshell('<some message> -- Entering ipshell.\nHit Ctrl-D to exit')
+
+#
+# Globals
+#
+
+ExternalEncoding = 'ascii'
+Tag_pattern_ = re_.compile(r'({.*})?(.*)')
+String_cleanup_pat_ = re_.compile(r"[\n\r\s]+")
+Namespace_extract_pat_ = re_.compile(r'{(.*)}(.*)')
+CDATA_pattern_ = re_.compile(r"<!\[CDATA\[.*?\]\]>", re_.DOTALL)
+
+#
+# Support/utility functions.
+#
+
+
+def showIndent(outfile, level, pretty_print=True):
+    if pretty_print:
+        for idx in range(level):
+            outfile.write('    ')
+
+
+def quote_xml(inStr):
+    "Escape markup chars, but do not modify CDATA sections."
+    if not inStr:
+        return ''
+    s1 = (isinstance(inStr, basestring) and inStr or
+          '%s' % inStr)
+    s2 = ''
+    pos = 0
+    matchobjects = CDATA_pattern_.finditer(s1)
+    for mo in matchobjects:
+        s3 = s1[pos:mo.start()]
+        s2 += quote_xml_aux(s3)
+        s2 += s1[mo.start():mo.end()]
+        pos = mo.end()
+    s3 = s1[pos:]
+    s2 += quote_xml_aux(s3)
+    return s2
+
+
+def quote_xml_aux(inStr):
+    s1 = inStr.replace('&', '&amp;')
+    s1 = s1.replace('<', '&lt;')
+    s1 = s1.replace('>', '&gt;')
+    return s1
+
+
+def quote_attrib(inStr):
+    s1 = (isinstance(inStr, basestring) and inStr or
+          '%s' % inStr)
+    s1 = s1.replace('&', '&amp;')
+    s1 = s1.replace('<', '&lt;')
+    s1 = s1.replace('>', '&gt;')
+    if '"' in s1:
+        if "'" in s1:
+            s1 = '"%s"' % s1.replace('"', "&quot;")
+        else:
+            s1 = "'%s'" % s1
+    else:
+        s1 = '"%s"' % s1
+    return s1
+
+
+def quote_python(inStr):
+    s1 = inStr
+    if s1.find("'") == -1:
+        if s1.find('\n') == -1:
+            return "'%s'" % s1
+        else:
+            return "'''%s'''" % s1
+    else:
+        if s1.find('"') != -1:
+            s1 = s1.replace('"', '\\"')
+        if s1.find('\n') == -1:
+            return '"%s"' % s1
+        else:
+            return '"""%s"""' % s1
+
+
+def get_all_text_(node):
+    if node.text is not None:
+        text = node.text
+    else:
+        text = ''
+    for child in node:
+        if child.tail is not None:
+            text += child.tail
+    return text
+
+
+def find_attr_value_(attr_name, node):
+    attrs = node.attrib
+    attr_parts = attr_name.split(':')
+    value = None
+    if len(attr_parts) == 1:
+        value = attrs.get(attr_name)
+    elif len(attr_parts) == 2:
+        prefix, name = attr_parts
+        namespace = node.nsmap.get(prefix)
+        if namespace is not None:
+            value = attrs.get('{%s}%s' % (namespace, name, ))
+    return value
+
+
+class GDSParseError(Exception):
+    pass
+
+
+def raise_parse_error(node, msg):
+    if XMLParser_import_library == XMLParser_import_lxml:
+        msg = '%s (element %s/line %d)' % (
+            msg, node.tag, node.sourceline, )
+    else:
+        msg = '%s (element %s)' % (msg, node.tag, )
+    raise GDSParseError(msg)
+
+
+class MixedContainer:
+    # Constants for category:
+    CategoryNone = 0
+    CategoryText = 1
+    CategorySimple = 2
+    CategoryComplex = 3
+    # Constants for content_type:
+    TypeNone = 0
+    TypeText = 1
+    TypeString = 2
+    TypeInteger = 3
+    TypeFloat = 4
+    TypeDecimal = 5
+    TypeDouble = 6
+    TypeBoolean = 7
+    TypeBase64 = 8
+    def __init__(self, category, content_type, name, value):
+        self.category = category
+        self.content_type = content_type
+        self.name = name
+        self.value = value
+    def getCategory(self):
+        return self.category
+    def getContenttype(self, content_type):
+        return self.content_type
+    def getValue(self):
+        return self.value
+    def getName(self):
+        return self.name
+    def export(self, outfile, level, name, namespace, pretty_print=True):
+        if self.category == MixedContainer.CategoryText:
+            # Prevent exporting empty content as empty lines.
+            if self.value.strip():
+                outfile.write(self.value)
+        elif self.category == MixedContainer.CategorySimple:
+            self.exportSimple(outfile, level, name)
+        else:    # category == MixedContainer.CategoryComplex
+            self.value.export(outfile, level, namespace, name, pretty_print)
+    def exportSimple(self, outfile, level, name):
+        if self.content_type == MixedContainer.TypeString:
+            outfile.write('<%s>%s</%s>' % (
+                self.name, self.value, self.name))
+        elif self.content_type == MixedContainer.TypeInteger or \
+                self.content_type == MixedContainer.TypeBoolean:
+            outfile.write('<%s>%d</%s>' % (
+                self.name, self.value, self.name))
+        elif self.content_type == MixedContainer.TypeFloat or \
+                self.content_type == MixedContainer.TypeDecimal:
+            outfile.write('<%s>%f</%s>' % (
+                self.name, self.value, self.name))
+        elif self.content_type == MixedContainer.TypeDouble:
+            outfile.write('<%s>%g</%s>' % (
+                self.name, self.value, self.name))
+        elif self.content_type == MixedContainer.TypeBase64:
+            outfile.write('<%s>%s</%s>' % (
+                self.name, base64.b64encode(self.value), self.name))
+    def to_etree(self, element):
+        if self.category == MixedContainer.CategoryText:
+            # Prevent exporting empty content as empty lines.
+            if self.value.strip():
+                if len(element) > 0:
+                    if element[-1].tail is None:
+                        element[-1].tail = self.value
+                    else:
+                        element[-1].tail += self.value
+                else:
+                    if element.text is None:
+                        element.text = self.value
+                    else:
+                        element.text += self.value
+        elif self.category == MixedContainer.CategorySimple:
+            subelement = etree_.SubElement(element, '%s' % self.name)
+            subelement.text = self.to_etree_simple()
+        else:    # category == MixedContainer.CategoryComplex
+            self.value.to_etree(element)
+    def to_etree_simple(self):
+        if self.content_type == MixedContainer.TypeString:
+            text = self.value
+        elif (self.content_type == MixedContainer.TypeInteger or
+                self.content_type == MixedContainer.TypeBoolean):
+            text = '%d' % self.value
+        elif (self.content_type == MixedContainer.TypeFloat or
+                self.content_type == MixedContainer.TypeDecimal):
+            text = '%f' % self.value
+        elif self.content_type == MixedContainer.TypeDouble:
+            text = '%g' % self.value
+        elif self.content_type == MixedContainer.TypeBase64:
+            text = '%s' % base64.b64encode(self.value)
+        return text
+    def exportLiteral(self, outfile, level, name):
+        if self.category == MixedContainer.CategoryText:
+            showIndent(outfile, level)
+            outfile.write(
+                'model_.MixedContainer(%d, %d, "%s", "%s"),\n' % (
+                    self.category, self.content_type, self.name, self.value))
+        elif self.category == MixedContainer.CategorySimple:
+            showIndent(outfile, level)
+            outfile.write(
+                'model_.MixedContainer(%d, %d, "%s", "%s"),\n' % (
+                    self.category, self.content_type, self.name, self.value))
+        else:    # category == MixedContainer.CategoryComplex
+            showIndent(outfile, level)
+            outfile.write(
+                'model_.MixedContainer(%d, %d, "%s",\n' % (
+                    self.category, self.content_type, self.name,))
+            self.value.exportLiteral(outfile, level + 1)
+            showIndent(outfile, level)
+            outfile.write(')\n')
+
+
+class MemberSpec_(object):
+    def __init__(self, name='', data_type='', container=0):
+        self.name = name
+        self.data_type = data_type
+        self.container = container
+    def set_name(self, name): self.name = name
+    def get_name(self): return self.name
+    def set_data_type(self, data_type): self.data_type = data_type
+    def get_data_type_chain(self): return self.data_type
+    def get_data_type(self):
+        if isinstance(self.data_type, list):
+            if len(self.data_type) > 0:
+                return self.data_type[-1]
+            else:
+                return 'xs:string'
+        else:
+            return self.data_type
+    def set_container(self, container): self.container = container
+    def get_container(self): return self.container
+
+
+def _cast(typ, value):
+    if typ is None or value is None:
+        return value
+    return typ(value)
+
+#
+# Data representation classes.
+#
+
+
+class containerType(GeneratedsSuper):
+    member_data_items_ = [
+        MemberSpec_('item1', 'classAType', 0),
+        MemberSpec_('item2', 'classBType', 0),
+    ]
+    subclass = None
+    superclass = None
+    def __init__(self, item1=None, item2=None):
+        self.original_tagname_ = None
+        self.item1 = item1
+        self.item2 = item2
+    def factory(*args_, **kwargs_):
+        if containerType.subclass:
+            return containerType.subclass(*args_, **kwargs_)
+        else:
+            return containerType(*args_, **kwargs_)
+    factory = staticmethod(factory)
+    def get_item1(self): return self.item1
+    def set_item1(self, item1): self.item1 = item1
+    def get_item2(self): return self.item2
+    def set_item2(self, item2): self.item2 = item2
+    def hasContent_(self):
+        if (
+            self.item1 is not None or
+            self.item2 is not None
+        ):
+            return True
+        else:
+            return False
+    def export(self, outfile, level, namespace_='', name_='containerType', namespacedef_='', pretty_print=True):
+        if pretty_print:
+            eol_ = '\n'
+        else:
+            eol_ = ''
+        if self.original_tagname_ is not None:
+            name_ = self.original_tagname_
+        showIndent(outfile, level, pretty_print)
+        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
+        already_processed = set()
+        self.exportAttributes(outfile, level, already_processed, namespace_, name_='containerType')
+        if self.hasContent_():
+            outfile.write('>%s' % (eol_, ))
+            self.exportChildren(outfile, level + 1, namespace_='', name_='containerType', pretty_print=pretty_print)
+            showIndent(outfile, level, pretty_print)
+            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
+        else:
+            outfile.write('/>%s' % (eol_, ))
+    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='containerType'):
+        pass
+    def exportChildren(self, outfile, level, namespace_='', name_='containerType', fromsubclass_=False, pretty_print=True):
+        if pretty_print:
+            eol_ = '\n'
+        else:
+            eol_ = ''
+        if self.item1 is not None:
+            self.item1.export(outfile, level, namespace_, name_='item1', pretty_print=pretty_print)
+        if self.item2 is not None:
+            self.item2.export(outfile, level, namespace_, name_='item2', pretty_print=pretty_print)
+    def exportLiteral(self, outfile, level, name_='containerType'):
+        level += 1
+        already_processed = set()
+        self.exportLiteralAttributes(outfile, level, already_processed, name_)
+        if self.hasContent_():
+            self.exportLiteralChildren(outfile, level, name_)
+    def exportLiteralAttributes(self, outfile, level, already_processed, name_):
+        pass
+    def exportLiteralChildren(self, outfile, level, name_):
+        if self.item1 is not None:
+            showIndent(outfile, level)
+            outfile.write('item1=model_.classAType(\n')
+            self.item1.exportLiteral(outfile, level, name_='item1')
+            showIndent(outfile, level)
+            outfile.write('),\n')
+        if self.item2 is not None:
+            showIndent(outfile, level)
+            outfile.write('item2=model_.classBType(\n')
+            self.item2.exportLiteral(outfile, level, name_='item2')
+            showIndent(outfile, level)
+            outfile.write('),\n')
+    def build(self, node):
+        already_processed = set()
+        self.buildAttributes(node, node.attrib, already_processed)
+        for child in node:
+            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
+            self.buildChildren(child, node, nodeName_)
+        return self
+    def buildAttributes(self, node, attrs, already_processed):
+        pass
+    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
+        if nodeName_ == 'item1':
+            obj_ = classAType.factory()
+            obj_.build(child_)
+            self.item1 = obj_
+            obj_.original_tagname_ = 'item1'
+        elif nodeName_ == 'item2':
+            obj_ = classBType.factory()
+            obj_.build(child_)
+            self.item2 = obj_
+            obj_.original_tagname_ = 'item2'
+# end class containerType
+
+
+class classAType(GeneratedsSuper):
+    member_data_items_ = [
+        MemberSpec_('inner', 'inner_001', 0),
+    ]
+    subclass = None
+    superclass = None
+    def __init__(self, inner=None):
+        self.original_tagname_ = None
+        self.inner = inner
+    def factory(*args_, **kwargs_):
+        if classAType.subclass:
+            return classAType.subclass(*args_, **kwargs_)
+        else:
+            return classAType(*args_, **kwargs_)
+    factory = staticmethod(factory)
+    def get_inner(self): return self.inner
+    def set_inner(self, inner): self.inner = inner
+    def hasContent_(self):
+        if (
+            self.inner is not None
+        ):
+            return True
+        else:
+            return False
+    def export(self, outfile, level, namespace_='', name_='classAType', namespacedef_='', pretty_print=True):
+        if pretty_print:
+            eol_ = '\n'
+        else:
+            eol_ = ''
+        if self.original_tagname_ is not None:
+            name_ = self.original_tagname_
+        showIndent(outfile, level, pretty_print)
+        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
+        already_processed = set()
+        self.exportAttributes(outfile, level, already_processed, namespace_, name_='classAType')
+        if self.hasContent_():
+            outfile.write('>%s' % (eol_, ))
+            self.exportChildren(outfile, level + 1, namespace_='', name_='classAType', pretty_print=pretty_print)
+            showIndent(outfile, level, pretty_print)
+            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
+        else:
+            outfile.write('/>%s' % (eol_, ))
+    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='classAType'):
+        pass
+    def exportChildren(self, outfile, level, namespace_='', name_='classAType', fromsubclass_=False, pretty_print=True):
+        if pretty_print:
+            eol_ = '\n'
+        else:
+            eol_ = ''
+        if self.inner is not None:
+            self.inner.export(outfile, level, namespace_, name_='inner', pretty_print=pretty_print)
+    def exportLiteral(self, outfile, level, name_='classAType'):
+        level += 1
+        already_processed = set()
+        self.exportLiteralAttributes(outfile, level, already_processed, name_)
+        if self.hasContent_():
+            self.exportLiteralChildren(outfile, level, name_)
+    def exportLiteralAttributes(self, outfile, level, already_processed, name_):
+        pass
+    def exportLiteralChildren(self, outfile, level, name_):
+        if self.inner is not None:
+            showIndent(outfile, level)
+            outfile.write('inner=model_.inner_001(\n')
+            self.inner.exportLiteral(outfile, level, name_='inner')
+            showIndent(outfile, level)
+            outfile.write('),\n')
+    def build(self, node):
+        already_processed = set()
+        self.buildAttributes(node, node.attrib, already_processed)
+        for child in node:
+            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
+            self.buildChildren(child, node, nodeName_)
+        return self
+    def buildAttributes(self, node, attrs, already_processed):
+        pass
+    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
+        if nodeName_ == 'inner':
+            obj_ = inner_001.factory()
+            obj_.build(child_)
+            self.inner = obj_
+            obj_.original_tagname_ = 'inner'
+# end class classAType
+
+
+class classBType(GeneratedsSuper):
+    member_data_items_ = [
+        MemberSpec_('inner', 'inner_002', 0),
+    ]
+    subclass = None
+    superclass = None
+    def __init__(self, inner=None):
+        self.original_tagname_ = None
+        self.inner = inner
+    def factory(*args_, **kwargs_):
+        if classBType.subclass:
+            return classBType.subclass(*args_, **kwargs_)
+        else:
+            return classBType(*args_, **kwargs_)
+    factory = staticmethod(factory)
+    def get_inner(self): return self.inner
+    def set_inner(self, inner): self.inner = inner
+    def hasContent_(self):
+        if (
+            self.inner is not None
+        ):
+            return True
+        else:
+            return False
+    def export(self, outfile, level, namespace_='', name_='classBType', namespacedef_='', pretty_print=True):
+        if pretty_print:
+            eol_ = '\n'
+        else:
+            eol_ = ''
+        if self.original_tagname_ is not None:
+            name_ = self.original_tagname_
+        showIndent(outfile, level, pretty_print)
+        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
+        already_processed = set()
+        self.exportAttributes(outfile, level, already_processed, namespace_, name_='classBType')
+        if self.hasContent_():
+            outfile.write('>%s' % (eol_, ))
+            self.exportChildren(outfile, level + 1, namespace_='', name_='classBType', pretty_print=pretty_print)
+            showIndent(outfile, level, pretty_print)
+            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
+        else:
+            outfile.write('/>%s' % (eol_, ))
+    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='classBType'):
+        pass
+    def exportChildren(self, outfile, level, namespace_='', name_='classBType', fromsubclass_=False, pretty_print=True):
+        if pretty_print:
+            eol_ = '\n'
+        else:
+            eol_ = ''
+        if self.inner is not None:
+            self.inner.export(outfile, level, namespace_, name_='inner', pretty_print=pretty_print)
+    def exportLiteral(self, outfile, level, name_='classBType'):
+        level += 1
+        already_processed = set()
+        self.exportLiteralAttributes(outfile, level, already_processed, name_)
+        if self.hasContent_():
+            self.exportLiteralChildren(outfile, level, name_)
+    def exportLiteralAttributes(self, outfile, level, already_processed, name_):
+        pass
+    def exportLiteralChildren(self, outfile, level, name_):
+        if self.inner is not None:
+            showIndent(outfile, level)
+            outfile.write('inner=model_.inner_002(\n')
+            self.inner.exportLiteral(outfile, level, name_='inner')
+            showIndent(outfile, level)
+            outfile.write('),\n')
+    def build(self, node):
+        already_processed = set()
+        self.buildAttributes(node, node.attrib, already_processed)
+        for child in node:
+            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
+            self.buildChildren(child, node, nodeName_)
+        return self
+    def buildAttributes(self, node, attrs, already_processed):
+        pass
+    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
+        if nodeName_ == 'inner':
+            obj_ = inner_002.factory()
+            obj_.build(child_)
+            self.inner = obj_
+            obj_.original_tagname_ = 'inner'
+# end class classBType
+
+
+class inner_001(GeneratedsSuper):
+    member_data_items_ = [
+        MemberSpec_('attrA1', 'xs:string', 0),
+        MemberSpec_('attrA2', 'xs:string', 0),
+    ]
+    subclass = None
+    superclass = None
+    def __init__(self, attrA1=None, attrA2=None):
+        self.original_tagname_ = None
+        self.attrA1 = _cast(None, attrA1)
+        self.attrA2 = _cast(None, attrA2)
+    def factory(*args_, **kwargs_):
+        if inner_001.subclass:
+            return inner_001.subclass(*args_, **kwargs_)
+        else:
+            return inner_001(*args_, **kwargs_)
+    factory = staticmethod(factory)
+    def get_attrA1(self): return self.attrA1
+    def set_attrA1(self, attrA1): self.attrA1 = attrA1
+    def get_attrA2(self): return self.attrA2
+    def set_attrA2(self, attrA2): self.attrA2 = attrA2
+    def hasContent_(self):
+        if (
+
+        ):
+            return True
+        else:
+            return False
+    def export(self, outfile, level, namespace_='', name_='inner_001', namespacedef_='', pretty_print=True):
+        if pretty_print:
+            eol_ = '\n'
+        else:
+            eol_ = ''
+        if self.original_tagname_ is not None:
+            name_ = self.original_tagname_
+        showIndent(outfile, level, pretty_print)
+        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
+        already_processed = set()
+        self.exportAttributes(outfile, level, already_processed, namespace_, name_='inner_001')
+        if self.hasContent_():
+            outfile.write('>%s' % (eol_, ))
+            self.exportChildren(outfile, level + 1, namespace_='', name_='inner_001', pretty_print=pretty_print)
+            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
+        else:
+            outfile.write('/>%s' % (eol_, ))
+    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='inner_001'):
+        if self.attrA1 is not None and 'attrA1' not in already_processed:
+            already_processed.add('attrA1')
+            outfile.write(' attrA1=%s' % (self.gds_format_string(quote_attrib(self.attrA1).encode(ExternalEncoding), input_name='attrA1'), ))
+        if self.attrA2 is not None and 'attrA2' not in already_processed:
+            already_processed.add('attrA2')
+            outfile.write(' attrA2=%s' % (self.gds_format_string(quote_attrib(self.attrA2).encode(ExternalEncoding), input_name='attrA2'), ))
+    def exportChildren(self, outfile, level, namespace_='', name_='inner_001', fromsubclass_=False, pretty_print=True):
+        pass
+    def exportLiteral(self, outfile, level, name_='inner_001'):
+        level += 1
+        already_processed = set()
+        self.exportLiteralAttributes(outfile, level, already_processed, name_)
+        if self.hasContent_():
+            self.exportLiteralChildren(outfile, level, name_)
+    def exportLiteralAttributes(self, outfile, level, already_processed, name_):
+        if self.attrA1 is not None and 'attrA1' not in already_processed:
+            already_processed.add('attrA1')
+            showIndent(outfile, level)
+            outfile.write('attrA1="%s",\n' % (self.attrA1,))
+        if self.attrA2 is not None and 'attrA2' not in already_processed:
+            already_processed.add('attrA2')
+            showIndent(outfile, level)
+            outfile.write('attrA2="%s",\n' % (self.attrA2,))
+    def exportLiteralChildren(self, outfile, level, name_):
+        pass
+    def build(self, node):
+        already_processed = set()
+        self.buildAttributes(node, node.attrib, already_processed)
+        for child in node:
+            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
+            self.buildChildren(child, node, nodeName_)
+        return self
+    def buildAttributes(self, node, attrs, already_processed):
+        value = find_attr_value_('attrA1', node)
+        if value is not None and 'attrA1' not in already_processed:
+            already_processed.add('attrA1')
+            self.attrA1 = value
+        value = find_attr_value_('attrA2', node)
+        if value is not None and 'attrA2' not in already_processed:
+            already_processed.add('attrA2')
+            self.attrA2 = value
+    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
+        pass
+# end class inner_001
+
+
+class inner_002(GeneratedsSuper):
+    member_data_items_ = [
+        MemberSpec_('attrB1', 'xs:string', 0),
+        MemberSpec_('attrB2', 'xs:string', 0),
+    ]
+    subclass = None
+    superclass = None
+    def __init__(self, attrB1=None, attrB2=None):
+        self.original_tagname_ = None
+        self.attrB1 = _cast(None, attrB1)
+        self.attrB2 = _cast(None, attrB2)
+    def factory(*args_, **kwargs_):
+        if inner_002.subclass:
+            return inner_002.subclass(*args_, **kwargs_)
+        else:
+            return inner_002(*args_, **kwargs_)
+    factory = staticmethod(factory)
+    def get_attrB1(self): return self.attrB1
+    def set_attrB1(self, attrB1): self.attrB1 = attrB1
+    def get_attrB2(self): return self.attrB2
+    def set_attrB2(self, attrB2): self.attrB2 = attrB2
+    def hasContent_(self):
+        if (
+
+        ):
+            return True
+        else:
+            return False
+    def export(self, outfile, level, namespace_='', name_='inner_002', namespacedef_='', pretty_print=True):
+        if pretty_print:
+            eol_ = '\n'
+        else:
+            eol_ = ''
+        if self.original_tagname_ is not None:
+            name_ = self.original_tagname_
+        showIndent(outfile, level, pretty_print)
+        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
+        already_processed = set()
+        self.exportAttributes(outfile, level, already_processed, namespace_, name_='inner_002')
+        if self.hasContent_():
+            outfile.write('>%s' % (eol_, ))
+            self.exportChildren(outfile, level + 1, namespace_='', name_='inner_002', pretty_print=pretty_print)
+            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
+        else:
+            outfile.write('/>%s' % (eol_, ))
+    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='inner_002'):
+        if self.attrB1 is not None and 'attrB1' not in already_processed:
+            already_processed.add('attrB1')
+            outfile.write(' attrB1=%s' % (self.gds_format_string(quote_attrib(self.attrB1).encode(ExternalEncoding), input_name='attrB1'), ))
+        if self.attrB2 is not None and 'attrB2' not in already_processed:
+            already_processed.add('attrB2')
+            outfile.write(' attrB2=%s' % (self.gds_format_string(quote_attrib(self.attrB2).encode(ExternalEncoding), input_name='attrB2'), ))
+    def exportChildren(self, outfile, level, namespace_='', name_='inner_002', fromsubclass_=False, pretty_print=True):
+        pass
+    def exportLiteral(self, outfile, level, name_='inner_002'):
+        level += 1
+        already_processed = set()
+        self.exportLiteralAttributes(outfile, level, already_processed, name_)
+        if self.hasContent_():
+            self.exportLiteralChildren(outfile, level, name_)
+    def exportLiteralAttributes(self, outfile, level, already_processed, name_):
+        if self.attrB1 is not None and 'attrB1' not in already_processed:
+            already_processed.add('attrB1')
+            showIndent(outfile, level)
+            outfile.write('attrB1="%s",\n' % (self.attrB1,))
+        if self.attrB2 is not None and 'attrB2' not in already_processed:
+            already_processed.add('attrB2')
+            showIndent(outfile, level)
+            outfile.write('attrB2="%s",\n' % (self.attrB2,))
+    def exportLiteralChildren(self, outfile, level, name_):
+        pass
+    def build(self, node):
+        already_processed = set()
+        self.buildAttributes(node, node.attrib, already_processed)
+        for child in node:
+            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
+            self.buildChildren(child, node, nodeName_)
+        return self
+    def buildAttributes(self, node, attrs, already_processed):
+        value = find_attr_value_('attrB1', node)
+        if value is not None and 'attrB1' not in already_processed:
+            already_processed.add('attrB1')
+            self.attrB1 = value
+        value = find_attr_value_('attrB2', node)
+        if value is not None and 'attrB2' not in already_processed:
+            already_processed.add('attrB2')
+            self.attrB2 = value
+    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
+        pass
+# end class inner_002
+
+
+GDSClassesMapping = {
+    'container': containerType,
+    'item2': classBType,
+    'item1': classAType,
+    'classB': classBType,
+    'classA': classAType,
+    'inner': inner_002,
+}
+
+
+USAGE_TEXT = """
+Usage: python <Parser>.py [ -s ] <in_xml_file>
+"""
+
+
+def usage():
+    print(USAGE_TEXT)
+    sys.exit(1)
+
+
+def get_root_tag(node):
+    tag = Tag_pattern_.match(node.tag).groups()[-1]
+    rootClass = GDSClassesMapping.get(tag)
+    if rootClass is None:
+        rootClass = globals().get(tag)
+    return tag, rootClass
+
+
+def parse(inFileName, silence=False):
+    parser = None
+    doc = parsexml_(inFileName, parser)
+    rootNode = doc.getroot()
+    rootTag, rootClass = get_root_tag(rootNode)
+    if rootClass is None:
+        rootTag = 'containerType'
+        rootClass = containerType
+    rootObj = rootClass.factory()
+    rootObj.build(rootNode)
+    # Enable Python to collect the space used by the DOM.
+    doc = None
+    if not silence:
+        sys.stdout.write('<?xml version="1.0" ?>\n')
+        rootObj.export(
+            sys.stdout, 0, name_=rootTag,
+            namespacedef_='',
+            pretty_print=True)
+    return rootObj
+
+
+def parseEtree(inFileName, silence=False):
+    parser = None
+    doc = parsexml_(inFileName, parser)
+    rootNode = doc.getroot()
+    rootTag, rootClass = get_root_tag(rootNode)
+    if rootClass is None:
+        rootTag = 'containerType'
+        rootClass = containerType
+    rootObj = rootClass.factory()
+    rootObj.build(rootNode)
+    # Enable Python to collect the space used by the DOM.
+    doc = None
+    mapping = {}
+    rootElement = rootObj.to_etree(None, name_=rootTag, mapping_=mapping)
+    reverse_mapping = rootObj.gds_reverse_node_mapping(mapping)
+    if not silence:
+        content = etree_.tostring(
+            rootElement, pretty_print=True,
+            xml_declaration=True, encoding="utf-8")
+        sys.stdout.write(content)
+        sys.stdout.write('\n')
+    return rootObj, rootElement, mapping, reverse_mapping
+
+
+def parseString(inString, silence=False):
+    from StringIO import StringIO
+    parser = None
+    doc = parsexml_(StringIO(inString), parser)
+    rootNode = doc.getroot()
+    rootTag, rootClass = get_root_tag(rootNode)
+    if rootClass is None:
+        rootTag = 'containerType'
+        rootClass = containerType
+    rootObj = rootClass.factory()
+    rootObj.build(rootNode)
+    # Enable Python to collect the space used by the DOM.
+    doc = None
+    if not silence:
+        sys.stdout.write('<?xml version="1.0" ?>\n')
+        rootObj.export(
+            sys.stdout, 0, name_=rootTag,
+            namespacedef_='')
+    return rootObj
+
+
+def parseLiteral(inFileName, silence=False):
+    parser = None
+    doc = parsexml_(inFileName, parser)
+    rootNode = doc.getroot()
+    rootTag, rootClass = get_root_tag(rootNode)
+    if rootClass is None:
+        rootTag = 'containerType'
+        rootClass = containerType
+    rootObj = rootClass.factory()
+    rootObj.build(rootNode)
+    # Enable Python to collect the space used by the DOM.
+    doc = None
+    if not silence:
+        sys.stdout.write('#from nested_def2_sup import *\n\n')
+        sys.stdout.write('import nested_def2_sup as model_\n\n')
+        sys.stdout.write('rootObj = model_.rootClass(\n')
+        rootObj.exportLiteral(sys.stdout, 0, name_=rootTag)
+        sys.stdout.write(')\n')
+    return rootObj
+
+
+def main():
+    args = sys.argv[1:]
+    if len(args) == 1:
+        parse(args[0])
+    else:
+        usage()
+
+
+if __name__ == '__main__':
+    #import pdb; pdb.set_trace()
+    main()
+
+
+__all__ = [
+    "classAType",
+    "classBType",
+    "containerType",
+    "inner_001",
+    "inner_002"
+]
diff --git a/tests/test.py b/tests/test.py
index f242360..d94418f 100755
--- a/tests/test.py
+++ b/tests/test.py
@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 
 import sys
+import os
 import subprocess
 import getopt
 import unittest
@@ -8,11 +9,12 @@ from lxml import etree
 
 
 class GenTest(unittest.TestCase):
-    def execute(self, cmd, cwd=None):
+    def execute(self, cmd, cwd=None, env=None):
         p = subprocess.Popen(
             cmd, cwd=cwd,
             stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-            shell=True)
+            shell=True,
+            env=env)
         stdout, stderr = p.communicate()
         return stdout, stderr
 
@@ -675,6 +677,37 @@ class GenTest(unittest.TestCase):
         result, err = self.execute(cmd)
         self.check_result(result, err, ())
 
+    def test_030_nested_def(self):
+        cmdTempl = (
+            'python generateDS.py --no-dates --no-versions '
+            '--member-specs=list -f '
+            '-o tests/%s2_sup.py -s tests/%s2_sub.py '
+            '--super=%s2_sup '
+            'tests/%s.xsd'
+        )
+        t_ = 'nested_def'
+        cmd = cmdTempl % (t_, t_, t_, t_, )
+        env = os.environ
+        directory = os.getcwd()
+        env['PYTHONPATH'] = directory
+        result, stderr = self.execute(cmd, cwd='..', env=env)
+        if stderr:
+            sys.stderr.write(stderr)
+            sys.stderr.write('\n')
+            raise RuntimeError('error while generating nested_def modules')
+        cmd = 'diff %s1_sup.py %s2_sup.py' % (t_, t_, )
+        result, err = self.execute(cmd)
+        self.check_result(result, err, ('sys.stdout.write',))
+        cmd = 'diff %s1_sub.py %s2_sub.py' % (t_, t_, )
+        result, err = self.execute(cmd)
+        self.check_result(result, err, ())
+        cmdTempl = 'python tests/%s2_sup.py tests/%s.xml > tests/%s2_out.xml'
+        cmd = cmdTempl % (t_, t_, t_, )
+        result, _ = self.execute(cmd, cwd='..')
+        cmd = 'diff %s1_out.xml %s2_out.xml' % (t_, t_, )
+        result, err = self.execute(cmd)
+        self.check_result(result, err, ())
+
     def check_result(self, result, err, ignore_strings):
         self.failUnlessEqual(len(result), 0)
         self.failUnlessEqual(len(err), 0)
diff --git a/tutorial/generateds_tutorial.txt b/tutorial/generateds_tutorial.txt
index adf2b8b..03b01e7 100644
--- a/tutorial/generateds_tutorial.txt
+++ b/tutorial/generateds_tutorial.txt
@@ -11,7 +11,7 @@ generateDS -- Introduction and Tutorial
 
 .. version
 
-:revision: 2.15b
+:revision: 2.16a
 
 .. version
 
-- 
GitLab