<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Using Binding Classes — PyXB 1.2.6 documentation</title>
<link rel="stylesheet" href="_static/classic.css" type="text/css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: './',
VERSION: '1.2.6',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true,
SOURCELINK_SUFFIX: '.txt'
};
</script>
<script type="text/javascript" src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script>
<link rel="index" title="Index" href="genindex.html" />
<link rel="search" title="Search" href="search.html" />
<link rel="next" title="Debugging Validation Errors" href="userref_validating.html" />
<link rel="prev" title="Generating Binding Classes" href="userref_pyxbgen.html" />
</head>
<body role="document">
<div class="related" role="navigation" aria-label="related navigation">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="py-modindex.html" title="Python Module Index"
>modules</a> |</li>
<li class="right" >
<a href="userref_validating.html" title="Debugging Validation Errors"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="userref_pyxbgen.html" title="Generating Binding Classes"
accesskey="P">previous</a> |</li>
<li class="nav-item nav-item-0"><a href="index.html">PyXB 1.2.6 documentation</a> »</li>
<li class="nav-item nav-item-1"><a href="userref_index.html" accesskey="U">User Reference</a> »</li>
<li style="margin-left: 20px">PyXB hosted on <a href="http://sourceforge.net/projects/pyxb"><img src="http://sflogo.sourceforge.net/sflogo.php?group_id=263147&type=9"
width="80" height="15" alt="Get PyXB: Python XML Schema Bindings at SourceForge.net. Fast, secure and Free Open Source software downloads"/></a></li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body" role="main">
<div class="section" id="using-binding-classes">
<span id="usebind"></span><h1>Using Binding Classes<a class="headerlink" href="#using-binding-classes" title="Permalink to this headline">¶</a></h1>
<p>Python instances corresponding to XML structures can be created in two
primary ways: from XML documents, and directly within Python code.
Generating XML documents from bindings can also be controlled.</p>
<div class="section" id="creating-instances-from-xml-documents">
<span id="from-xml"></span><h2>Creating Instances from XML Documents<a class="headerlink" href="#creating-instances-from-xml-documents" title="Permalink to this headline">¶</a></h2>
<p>XML documents are converted into Python bindings by invoking the
<code class="docutils literal"><span class="pre">CreateFromDocument</span></code> function in a binding module. For example:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">print_function</span>
<span class="kn">import</span> <span class="nn">po3</span>
<span class="n">order</span> <span class="o">=</span> <span class="n">po3</span><span class="o">.</span><span class="n">CreateFromDocument</span><span class="p">(</span><span class="nb">open</span><span class="p">(</span><span class="s1">'po3.xml'</span><span class="p">)</span><span class="o">.</span><span class="n">read</span><span class="p">())</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">'</span><span class="si">%s</span><span class="s1"> is sending </span><span class="si">%s</span><span class="s1"> </span><span class="si">%d</span><span class="s1"> thing(s):'</span> <span class="o">%</span> <span class="p">(</span><span class="n">order</span><span class="o">.</span><span class="n">billTo</span><span class="o">.</span><span class="n">name</span><span class="p">,</span> <span class="n">order</span><span class="o">.</span><span class="n">shipTo</span><span class="o">.</span><span class="n">name</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">order</span><span class="o">.</span><span class="n">items</span><span class="o">.</span><span class="n">item</span><span class="p">)))</span>
<span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="n">order</span><span class="o">.</span><span class="n">items</span><span class="o">.</span><span class="n">item</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">' Quantity </span><span class="si">%d</span><span class="s1"> of </span><span class="si">%s</span><span class="s1"> at $</span><span class="si">%s</span><span class="s1">'</span> <span class="o">%</span> <span class="p">(</span><span class="n">item</span><span class="o">.</span><span class="n">quantity</span><span class="p">,</span> <span class="n">item</span><span class="o">.</span><span class="n">productName</span><span class="p">,</span> <span class="n">item</span><span class="o">.</span><span class="n">USPrice</span><span class="p">))</span>
</pre></div>
</div>
<p>The <code class="docutils literal"><span class="pre">CreateFromDocument</span></code> function in a given binding module is configured
so that documents with no default namespace are assumed to be in the
namespace from which the binding was generated.</p>
<div class="section" id="locating-invalid-content">
<span id="invalid-content"></span><h3>Locating Invalid Content<a class="headerlink" href="#locating-invalid-content" title="Permalink to this headline">¶</a></h3>
<p>If a document does not validate, PyXB will generally through an
<code class="xref py py-obj docutils literal"><span class="pre">pyxb.UnrecognizedContentError</span></code> exception. You can determine where the
problem lies, and what was not recognized, by examining attributes present
on the exception as shown in this example:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">print_function</span>
<span class="kn">import</span> <span class="nn">pyxb</span>
<span class="kn">import</span> <span class="nn">po1</span>
<span class="n">xml</span> <span class="o">=</span> <span class="nb">open</span><span class="p">(</span><span class="s1">'badcontent.xml'</span><span class="p">)</span><span class="o">.</span><span class="n">read</span><span class="p">()</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">order</span> <span class="o">=</span> <span class="n">po1</span><span class="o">.</span><span class="n">CreateFromDocument</span><span class="p">(</span><span class="n">xml</span><span class="p">,</span> <span class="n">location_base</span><span class="o">=</span><span class="s1">'badcontent.xml'</span><span class="p">)</span>
<span class="k">except</span> <span class="n">pyxb</span><span class="o">.</span><span class="n">ValidationError</span> <span class="k">as</span> <span class="n">e</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="n">e</span><span class="o">.</span><span class="n">details</span><span class="p">())</span>
</pre></div>
</div>
<p>which produces:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">The</span> <span class="n">containing</span> <span class="n">element</span> <span class="n">shipTo</span> <span class="ow">is</span> <span class="n">defined</span> <span class="n">at</span> <span class="n">po1</span><span class="o">.</span><span class="n">xsd</span><span class="p">[</span><span class="mi">6</span><span class="p">:</span><span class="mi">6</span><span class="p">]</span><span class="o">.</span>
<span class="n">The</span> <span class="n">containing</span> <span class="n">element</span> <span class="nb">type</span> <span class="n">USAddress</span> <span class="ow">is</span> <span class="n">defined</span> <span class="n">at</span> <span class="n">po1</span><span class="o">.</span><span class="n">xsd</span><span class="p">[</span><span class="mi">13</span><span class="p">:</span><span class="mi">2</span><span class="p">]</span>
<span class="n">The</span> <span class="n">unrecognized</span> <span class="n">content</span> <span class="n">streeet</span> <span class="n">begins</span> <span class="n">at</span> <span class="n">badcontent</span><span class="o">.</span><span class="n">xml</span><span class="p">[</span><span class="mi">5</span><span class="p">:</span><span class="mi">4</span><span class="p">]</span>
<span class="n">The</span> <span class="n">USAddress</span> <span class="n">automaton</span> <span class="ow">is</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">an</span> <span class="n">accepting</span> <span class="n">state</span><span class="o">.</span>
<span class="n">The</span> <span class="n">following</span> <span class="n">element</span> <span class="ow">and</span> <span class="n">wildcard</span> <span class="n">content</span> <span class="n">would</span> <span class="n">be</span> <span class="n">accepted</span><span class="p">:</span>
<span class="n">An</span> <span class="n">element</span> <span class="n">street</span> <span class="n">per</span> <span class="n">po1</span><span class="o">.</span><span class="n">xsd</span><span class="p">[</span><span class="mi">16</span><span class="p">:</span><span class="mi">6</span><span class="p">]</span>
</pre></div>
</div>
</div>
<div class="section" id="coping-with-wrong-xsi-type-attributes">
<h3>Coping With Wrong <code class="docutils literal"><span class="pre">xsi:type</span></code> Attributes<a class="headerlink" href="#coping-with-wrong-xsi-type-attributes" title="Permalink to this headline">¶</a></h3>
<p>Some web services and binding tools mis-use <a class="reference external" href="http://www.w3.org/TR/xmlschema-1/#xsi_type">xsi:type</a>, providing attribute values
that either are not types, or do not specify a type that is derived from an
abstract type. The
<a class="reference internal" href="pyxb.namespace.html#pyxb.namespace.builtin._XMLSchema_instance.ProcessTypeAttribute" title="pyxb.namespace.builtin._XMLSchema_instance.ProcessTypeAttribute"><code class="xref py py-obj docutils literal"><span class="pre">pyxb.namespace.builtin.XMLSchema_instance.ProcessTypeAttribute</span></code></a> method
can be used to relax how PyXB processes those attributes.</p>
</div>
</div>
<div class="section" id="creating-instances-in-python-code">
<span id="from-python"></span><h2>Creating Instances in Python Code<a class="headerlink" href="#creating-instances-in-python-code" title="Permalink to this headline">¶</a></h2>
<p>Creating bindings from XML documents is straightforward, because the
documents contain enough information to identify each element and attribute,
locate the corresponding use in the binding class, and store a value that is
converted to the appropriate type. Creating values in Python is inherently
more complex, because native Python objects like strings and integers do not
contain this information.</p>
<p>As described in <a class="reference internal" href="arch_binding.html#bindingmodel"><span class="std std-ref">Binding Model</span></a>, binding classes corresponding to simple
types extend the underlying Python type (such as <code class="docutils literal"><span class="pre">str</span></code> or <code class="docutils literal"><span class="pre">int</span></code>), and
add XML-specific information like the canonical representation of the value
in <a class="reference external" href="http://www.unicode.org/">Unicode</a>, which is the natural representation
as XML text. These classes also maintain a set of facets that constrain the
values that can be stored as instances when validation is active. Binding
classes for complex types have constructors that parse positional and
keyword parameters to determine the appropriate element or attribute to
which the value belongs. Attributes are assigned using keyword parameters.
Content is assigned using positional parameters. The order of the
positional parameters must be consistent with the order expected by the
content model.</p>
<p>Using the schema in the <a class="reference internal" href="userref_pyxbgen.html#nsaddress-xsd"><span class="std std-ref">namespace-aware address schema</span></a>, we can begin to construct the example document in Python:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">print_function</span>
<span class="kn">import</span> <span class="nn">address</span>
<span class="n">addr</span> <span class="o">=</span> <span class="n">address</span><span class="o">.</span><span class="n">USAddress</span><span class="p">()</span>
<span class="n">addr</span><span class="o">.</span><span class="n">name</span> <span class="o">=</span> <span class="s1">'Robert Smith'</span>
<span class="n">addr</span><span class="o">.</span><span class="n">street</span> <span class="o">=</span> <span class="s1">'8 Oak Avenue'</span>
<span class="n">addr</span><span class="o">.</span><span class="n">city</span> <span class="o">=</span> <span class="s1">'Anytown'</span>
<span class="n">addr</span><span class="o">.</span><span class="n">state</span> <span class="o">=</span> <span class="s1">'AK'</span>
<span class="n">addr</span><span class="o">.</span><span class="n">zip</span> <span class="o">=</span> <span class="mi">12341</span>
<span class="nb">print</span><span class="p">(</span><span class="n">addr</span><span class="o">.</span><span class="n">toxml</span><span class="p">(</span><span class="s2">"utf-8"</span><span class="p">,</span> <span class="n">element_name</span><span class="o">=</span><span class="s1">'USAddress'</span><span class="p">)</span><span class="o">.</span><span class="n">decode</span><span class="p">(</span><span class="s1">'utf-8'</span><span class="p">))</span>
</pre></div>
</div>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p class="last">It is necessary to provide an <code class="docutils literal"><span class="pre">element_name</span></code> parameter to <code class="docutils literal"><span class="pre">to_xml</span></code>
because in this case <code class="docutils literal"><span class="pre">USAddress</span></code> is the name of a complex type, not an
top-level schema element. PyXB cannot generate XML for an instance unless
it knows the name to use for the root element. In most situations PyXB can
figure out what element the instance belongs to, as when the instance is
created through an element binding instead of a type binding and when it is
assigned into another instance, both of which are seen in <a class="reference internal" href="#demo4c">demo4c</a>.</p>
</div>
<p>This produces:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><?xml version="1.0" encoding="utf-8"?><USAddress><name>Robert Smith</name><street>8 Oak Avenue</street><city>Anytown</city><state>AK</state><zip>12341</zip></USAddress>
</pre></div>
</div>
<p>Assigning to individual fields like this bypasses the complex type content
model, although each field itself is validated. For example, the address
schema does not include New York as a state, so the following assignment:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">addr</span><span class="o">.</span><span class="n">state</span> <span class="o">=</span> <span class="s1">'NY'</span>
</pre></div>
</div>
<p>will cause a <code class="xref py py-obj docutils literal"><span class="pre">pyxb.exceptions_.BadTypeValueError</span></code> exception to be raised:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span>
</pre></div>
</div>
<p>However, the order of the field assignments does not matter, as long as all
required fields are present by the time the XML document is generated.</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">print_function</span>
<span class="kn">import</span> <span class="nn">address</span>
<span class="n">addr</span> <span class="o">=</span> <span class="n">address</span><span class="o">.</span><span class="n">USAddress</span><span class="p">()</span>
<span class="n">addr</span><span class="o">.</span><span class="n">street</span> <span class="o">=</span> <span class="s1">'8 Oak Avenue'</span>
<span class="n">addr</span><span class="o">.</span><span class="n">state</span> <span class="o">=</span> <span class="s1">'AK'</span>
<span class="n">addr</span><span class="o">.</span><span class="n">city</span> <span class="o">=</span> <span class="s1">'Anytown'</span>
<span class="n">addr</span><span class="o">.</span><span class="n">zip</span> <span class="o">=</span> <span class="mi">12341</span>
<span class="n">addr</span><span class="o">.</span><span class="n">name</span> <span class="o">=</span> <span class="s1">'Robert Smith'</span>
<span class="nb">print</span><span class="p">(</span><span class="n">addr</span><span class="o">.</span><span class="n">toxml</span><span class="p">(</span><span class="s2">"utf-8"</span><span class="p">,</span> <span class="n">element_name</span><span class="o">=</span><span class="s1">'USAddress'</span><span class="p">)</span><span class="o">.</span><span class="n">decode</span><span class="p">(</span><span class="s1">'utf-8'</span><span class="p">))</span>
</pre></div>
</div>
<p>Alternatively, you can provide the content as positional parameters in the
object creation call:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="c1"># examples/manual/demo4b.py</span>
<span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">print_function</span>
<span class="kn">import</span> <span class="nn">address</span>
<span class="n">addr</span> <span class="o">=</span> <span class="n">address</span><span class="o">.</span><span class="n">USAddress</span><span class="p">(</span><span class="s1">'Robert Smith'</span><span class="p">,</span> <span class="s1">'8 Oak Avenue'</span><span class="p">,</span> <span class="s1">'Anytown'</span><span class="p">,</span> <span class="s1">'AK'</span><span class="p">,</span> <span class="mi">12341</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="n">addr</span><span class="o">.</span><span class="n">toxml</span><span class="p">(</span><span class="s2">"utf-8"</span><span class="p">,</span> <span class="n">element_name</span><span class="o">=</span><span class="s1">'USAddress'</span><span class="p">)</span><span class="o">.</span><span class="n">decode</span><span class="p">(</span><span class="s1">'utf-8'</span><span class="p">))</span>
</pre></div>
</div>
<p>This has the same effect, and is much more compact, but it does require that
the order match the content model.</p>
<p id="demo4c">Attributes are set using keyword parameters:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="c1"># examples/manual/demo4c.py</span>
<span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">print_function</span>
<span class="kn">import</span> <span class="nn">pyxb</span>
<span class="kn">import</span> <span class="nn">po4</span>
<span class="kn">import</span> <span class="nn">address</span>
<span class="kn">import</span> <span class="nn">pyxb.binding.datatypes</span> <span class="k">as</span> <span class="nn">xs</span>
<span class="n">po</span> <span class="o">=</span> <span class="n">po4</span><span class="o">.</span><span class="n">purchaseOrder</span><span class="p">(</span><span class="n">orderDate</span><span class="o">=</span><span class="n">xs</span><span class="o">.</span><span class="n">date</span><span class="p">(</span><span class="mi">1999</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">20</span><span class="p">))</span>
<span class="n">po</span><span class="o">.</span><span class="n">shipTo</span> <span class="o">=</span> <span class="n">address</span><span class="o">.</span><span class="n">USAddress</span><span class="p">(</span><span class="s1">'Alice Smith'</span><span class="p">,</span> <span class="s1">'123 Maple Street'</span><span class="p">,</span> <span class="s1">'Anytown'</span><span class="p">,</span> <span class="s1">'AK'</span><span class="p">,</span> <span class="mi">12341</span><span class="p">)</span>
<span class="n">po</span><span class="o">.</span><span class="n">billTo</span> <span class="o">=</span> <span class="n">address</span><span class="o">.</span><span class="n">USAddress</span><span class="p">(</span><span class="s1">'Robert Smith'</span><span class="p">,</span> <span class="s1">'8 Oak Avenue'</span><span class="p">,</span> <span class="s1">'Anytown'</span><span class="p">,</span> <span class="s1">'AK'</span><span class="p">,</span> <span class="mi">12341</span><span class="p">)</span>
<span class="c1"># Disable validation since content is incomplete.</span>
<span class="n">pyxb</span><span class="o">.</span><span class="n">RequireValidWhenGenerating</span><span class="p">(</span><span class="kc">False</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="n">po</span><span class="o">.</span><span class="n">toxml</span><span class="p">(</span><span class="s2">"utf-8"</span><span class="p">)</span><span class="o">.</span><span class="n">decode</span><span class="p">(</span><span class="s1">'utf-8'</span><span class="p">))</span>
</pre></div>
</div>
<p>This example produces (after reformatting):</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><?xml version="1.0" encoding="utf-8"?>
<ns1:purchaseOrder xmlns:ns1="URN:purchase-order" orderDate="1999-10-20">
<ns1:billTo>
<city>Anytown</city>
<state>AK</state>
<street>8 Oak Avenue</street>
<name>Robert Smith</name>
<zip>12341</zip>
</ns1:billTo>
<ns1:shipTo>
<city>Anytown</city>
<state>AK</state>
<street>123 Maple Street</street>
<name>Alice Smith</name>
<zip>12341</zip>
</ns1:shipTo>
</ns1:purchaseOrder>
</pre></div>
</div>
<p id="index-0">Note that, because we’re in the middle of the example and have not provided
the <code class="docutils literal"><span class="pre">items</span></code> element that the content model requires, the code
<a class="reference internal" href="pyxb.html#pyxb.RequireValidWhenGenerating" title="pyxb.RequireValidWhenGenerating"><code class="xref py py-obj docutils literal"><span class="pre">explicitly</span> <span class="pre">disables</span> <span class="pre">the</span> <span class="pre">requirement</span> <span class="pre">for</span>
<span class="pre">validation</span></code></a> when generating XML from a
binding instance. A consequence of this is that the generated XML is not
valid, and validation must be <a class="reference internal" href="pyxb.html#pyxb.RequireValidWhenParsing" title="pyxb.RequireValidWhenParsing"><code class="xref py py-obj docutils literal"><span class="pre">disabled</span> <span class="pre">for</span> <span class="pre">parsing</span></code></a> as well if the resulting document is to be
re-converted into a binding with <code class="docutils literal"><span class="pre">CreateFromDocument</span></code>.</p>
<div class="section" id="creating-instances-of-anonymous-types">
<span id="pyxb-bind"></span><h3>Creating Instances of Anonymous Types<a class="headerlink" href="#creating-instances-of-anonymous-types" title="Permalink to this headline">¶</a></h3>
<p>The style of XML schema used for purchase orders uses anonymous types for
the deeper elements of the purchase order:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
targetNamespace="URN:purchase-order"
xmlns:tns="URN:purchase-order"
xmlns:address="URN:address"
elementFormDefault="qualified">
<xsd:import namespace="URN:address" schemaLocation="nsaddress.xsd"/>
<xsd:element name="purchaseOrder" type="tns:PurchaseOrderType"/>
<xsd:element name="comment" type="xsd:string"/>
<xsd:complexType name="PurchaseOrderType">
<xsd:sequence>
<xsd:element name="shipTo" type="address:USAddress"/>
<xsd:element name="billTo" type="address:USAddress"/>
<xsd:element ref="tns:comment" minOccurs="0"/>
<xsd:element name="items" type="tns:Items"/>
</xsd:sequence>
<xsd:attribute name="orderDate" type="xsd:date"/>
</xsd:complexType>
<xsd:complexType name="Items">
<xsd:sequence>
<xsd:element name="item" minOccurs="0" maxOccurs="unbounded">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="productName" type="xsd:string"/>
<xsd:element name="quantity">
<xsd:simpleType>
<xsd:restriction base="xsd:positiveInteger">
<xsd:maxExclusive value="100"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>
<xsd:element name="USPrice" type="xsd:decimal"/>
<xsd:element ref="tns:comment" minOccurs="0"/>
<xsd:element name="shipDate" type="xsd:date" minOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="partNum" type="tns:SKU" use="required"/>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
<!-- Stock Keeping Unit, a code for identifying products -->
<xsd:simpleType name="SKU">
<xsd:restriction base="xsd:string">
<xsd:pattern value="\d{3}-[A-Z]{2}"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:schema>
</pre></div>
</div>
<p id="index-1">In particular, there is no global <code class="docutils literal"><span class="pre">item</span></code> element that can be used to
create the individual items. For situations like this, we use
<a class="reference internal" href="pyxb.html#pyxb.BIND" title="pyxb.BIND"><code class="xref py py-obj docutils literal"><span class="pre">pyxb.BIND</span></code></a>:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">print_function</span>
<span class="kn">import</span> <span class="nn">pyxb</span>
<span class="kn">import</span> <span class="nn">po4</span>
<span class="kn">import</span> <span class="nn">address</span>
<span class="kn">import</span> <span class="nn">pyxb.binding.datatypes</span> <span class="k">as</span> <span class="nn">xs</span>
<span class="n">po</span> <span class="o">=</span> <span class="n">po4</span><span class="o">.</span><span class="n">purchaseOrder</span><span class="p">(</span><span class="n">orderDate</span><span class="o">=</span><span class="n">xs</span><span class="o">.</span><span class="n">date</span><span class="p">(</span><span class="mi">1999</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">20</span><span class="p">))</span>
<span class="n">po</span><span class="o">.</span><span class="n">shipTo</span> <span class="o">=</span> <span class="n">address</span><span class="o">.</span><span class="n">USAddress</span><span class="p">(</span><span class="s1">'Alice Smith'</span><span class="p">,</span> <span class="s1">'123 Maple Street'</span><span class="p">,</span> <span class="s1">'Anytown'</span><span class="p">,</span> <span class="s1">'AK'</span><span class="p">,</span> <span class="mi">12341</span><span class="p">)</span>
<span class="n">po</span><span class="o">.</span><span class="n">billTo</span> <span class="o">=</span> <span class="n">address</span><span class="o">.</span><span class="n">USAddress</span><span class="p">(</span><span class="s1">'Robert Smith'</span><span class="p">,</span> <span class="s1">'8 Oak Avenue'</span><span class="p">,</span> <span class="s1">'Anytown'</span><span class="p">,</span> <span class="s1">'AK'</span><span class="p">,</span> <span class="mi">12341</span><span class="p">)</span>
<span class="n">po</span><span class="o">.</span><span class="n">items</span> <span class="o">=</span> <span class="n">pyxb</span><span class="o">.</span><span class="n">BIND</span><span class="p">(</span><span class="n">pyxb</span><span class="o">.</span><span class="n">BIND</span><span class="p">(</span><span class="s1">'Lapis necklace'</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mf">99.95</span><span class="p">,</span> <span class="n">partNum</span><span class="o">=</span><span class="s1">'833-AA'</span><span class="p">),</span>
<span class="n">pyxb</span><span class="o">.</span><span class="n">BIND</span><span class="p">(</span><span class="s1">'Plastic necklace'</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mf">3.95</span><span class="p">,</span> <span class="n">partNum</span><span class="o">=</span><span class="s1">'833-AB'</span><span class="p">))</span>
<span class="nb">print</span><span class="p">(</span><span class="n">po</span><span class="o">.</span><span class="n">toxml</span><span class="p">(</span><span class="s2">"utf-8"</span><span class="p">)</span><span class="o">.</span><span class="n">decode</span><span class="p">(</span><span class="s1">'utf-8'</span><span class="p">))</span>
</pre></div>
</div>
<p>The <a class="reference internal" href="pyxb.html#pyxb.BIND" title="pyxb.BIND"><code class="xref py py-obj docutils literal"><span class="pre">pyxb.BIND</span></code></a> reference wraps the content of the inner elements, and
is a cue to PyXB to attempt to build an instance of whatever type of object
would satisfy the content model at that point. The resulting document
(after reformatting) is:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><?xml version="1.0" encoding="utf-8"?>
<ns1:purchaseOrder xmlns:ns1="URN:purchase-order" orderDate="1999-10-20">
<ns1:shipTo>
<name>Alice Smith</name>
<street>123 Maple Street</street>
<city>Anytown</city>
<state>AK</state>
<zip>12341</zip>
</ns1:shipTo>
<ns1:billTo>
<name>Robert Smith</name>
<street>8 Oak Avenue</street>
<city>Anytown</city>
<state>AK</state>
<zip>12341</zip>
</ns1:billTo>
<ns1:items>
<ns1:item partNum="833-AA">
<ns1:productName>Lapis necklace</ns1:productName>
<ns1:quantity>1</ns1:quantity>
<ns1:USPrice>99.95</ns1:USPrice>
</ns1:item>
<ns1:item partNum="833-AB">
<ns1:productName>Plastic necklace</ns1:productName>
<ns1:quantity>4</ns1:quantity>
<ns1:USPrice>3.95</ns1:USPrice>
</ns1:item>
</ns1:items>
</ns1:purchaseOrder>
</pre></div>
</div>
<p>The complete document is generated by the following program:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">print_function</span>
<span class="kn">import</span> <span class="nn">pyxb</span>
<span class="kn">import</span> <span class="nn">po4</span>
<span class="kn">import</span> <span class="nn">address</span>
<span class="kn">import</span> <span class="nn">pyxb.binding.datatypes</span> <span class="k">as</span> <span class="nn">xs</span>
<span class="kn">import</span> <span class="nn">datetime</span>
<span class="n">po</span> <span class="o">=</span> <span class="n">po4</span><span class="o">.</span><span class="n">purchaseOrder</span><span class="p">(</span><span class="n">orderDate</span><span class="o">=</span><span class="n">xs</span><span class="o">.</span><span class="n">date</span><span class="p">(</span><span class="mi">1999</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">20</span><span class="p">))</span>
<span class="n">po</span><span class="o">.</span><span class="n">shipTo</span> <span class="o">=</span> <span class="n">address</span><span class="o">.</span><span class="n">USAddress</span><span class="p">(</span><span class="s1">'Alice Smith'</span><span class="p">,</span> <span class="s1">'123 Maple Street'</span><span class="p">,</span> <span class="s1">'Anytown'</span><span class="p">,</span> <span class="s1">'AK'</span><span class="p">,</span> <span class="mi">12341</span><span class="p">)</span>
<span class="n">po</span><span class="o">.</span><span class="n">billTo</span> <span class="o">=</span> <span class="n">address</span><span class="o">.</span><span class="n">USAddress</span><span class="p">(</span><span class="s1">'Robert Smith'</span><span class="p">,</span> <span class="s1">'8 Oak Avenue'</span><span class="p">,</span> <span class="s1">'Anytown'</span><span class="p">,</span> <span class="s1">'AK'</span><span class="p">,</span> <span class="mi">12341</span><span class="p">)</span>
<span class="n">po</span><span class="o">.</span><span class="n">items</span> <span class="o">=</span> <span class="n">pyxb</span><span class="o">.</span><span class="n">BIND</span><span class="p">(</span><span class="n">pyxb</span><span class="o">.</span><span class="n">BIND</span><span class="p">(</span><span class="s1">'Lapis necklace'</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mf">99.95</span><span class="p">,</span> <span class="n">partNum</span><span class="o">=</span><span class="s1">'833-AA'</span><span class="p">),</span>
<span class="n">pyxb</span><span class="o">.</span><span class="n">BIND</span><span class="p">(</span><span class="s1">'Plastic necklace'</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mf">3.95</span><span class="p">,</span> <span class="n">partNum</span><span class="o">=</span><span class="s1">'833-AB'</span><span class="p">))</span>
<span class="n">po</span><span class="o">.</span><span class="n">shipTo</span><span class="o">.</span><span class="n">country</span> <span class="o">=</span> <span class="n">po</span><span class="o">.</span><span class="n">billTo</span><span class="o">.</span><span class="n">country</span> <span class="o">=</span> <span class="n">po</span><span class="o">.</span><span class="n">shipTo</span><span class="o">.</span><span class="n">country</span>
<span class="n">lapis</span> <span class="o">=</span> <span class="n">po</span><span class="o">.</span><span class="n">items</span><span class="o">.</span><span class="n">item</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="n">lapis</span><span class="o">.</span><span class="n">shipDate</span> <span class="o">=</span> <span class="n">po</span><span class="o">.</span><span class="n">orderDate</span> <span class="o">+</span> <span class="n">datetime</span><span class="o">.</span><span class="n">timedelta</span><span class="p">(</span><span class="n">days</span><span class="o">=</span><span class="mi">46</span><span class="p">)</span>
<span class="n">lapis</span><span class="o">.</span><span class="n">comment</span> <span class="o">=</span> <span class="s1">'Want this for the holidays!'</span>
<span class="n">po</span><span class="o">.</span><span class="n">items</span><span class="o">.</span><span class="n">item</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">shipDate</span> <span class="o">=</span> <span class="n">po</span><span class="o">.</span><span class="n">items</span><span class="o">.</span><span class="n">item</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">shipDate</span> <span class="o">+</span> <span class="n">datetime</span><span class="o">.</span><span class="n">timedelta</span><span class="p">(</span><span class="n">days</span><span class="o">=</span><span class="mi">19</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="n">po</span><span class="o">.</span><span class="n">toxml</span><span class="p">(</span><span class="s2">"utf-8"</span><span class="p">)</span><span class="o">.</span><span class="n">decode</span><span class="p">(</span><span class="s1">'utf-8'</span><span class="p">))</span>
</pre></div>
</div>
<p>The additional code demonstrates a couple additional features:</p>
<blockquote>
<div><ul class="simple">
<li>Fixed attribute values (such as <code class="docutils literal"><span class="pre">country</span></code>) are present in the bindings,
even though they are only printed if they are set explicitly</li>
<li>The PyXB types for representing dates and times are extensions of those
used by Python for the same purpose, including the ability to use them in
expressions</li>
</ul>
</div></blockquote>
</div>
</div>
<div class="section" id="creating-xml-documents-from-binding-instances">
<span id="to-xml"></span><h2>Creating XML Documents from Binding Instances<a class="headerlink" href="#creating-xml-documents-from-binding-instances" title="Permalink to this headline">¶</a></h2>
<p>All along we’ve been seeing how to generate XML from a binding instance.
The <code class="docutils literal"><span class="pre">toxml</span></code> method is short-hand for a sequence that converts the binding
to a DOM instance using <code class="docutils literal"><span class="pre">xml.dom.minidom</span></code>, then uses the DOM interface to
generate the XML document.</p>
<p>The <a class="reference internal" href="pyxb.utils.html#pyxb.utils.domutils.BindingDOMSupport" title="pyxb.utils.domutils.BindingDOMSupport"><code class="xref py py-obj docutils literal"><span class="pre">pyxb.utils.domutils.BindingDOMSupport</span></code></a> class provides ways to
control this generation. In particular, you may want to use something more
informative than <code class="docutils literal"><span class="pre">ns#</span></code> to denote namespaces in the generated documents.
This can be done using the following code:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span>
<span class="kn">import</span> <span class="nn">pyxb.utils.domutils</span>
<span class="n">pyxb</span><span class="o">.</span><span class="n">utils</span><span class="o">.</span><span class="n">domutils</span><span class="o">.</span><span class="n">BindingDOMSupport</span><span class="o">.</span><span class="n">DeclareNamespace</span><span class="p">(</span><span class="n">address</span><span class="o">.</span><span class="n">Namespace</span><span class="p">,</span> <span class="s1">'addr'</span><span class="p">)</span>
<span class="n">pyxb</span><span class="o">.</span><span class="n">utils</span><span class="o">.</span><span class="n">domutils</span><span class="o">.</span><span class="n">BindingDOMSupport</span><span class="o">.</span><span class="n">DeclareNamespace</span><span class="p">(</span><span class="n">po4</span><span class="o">.</span><span class="n">Namespace</span><span class="p">,</span> <span class="s1">'po'</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="n">po</span><span class="o">.</span><span class="n">toxml</span><span class="p">(</span><span class="s2">"utf-8"</span><span class="p">)</span><span class="o">.</span><span class="n">decode</span><span class="p">(</span><span class="s1">'utf-8'</span><span class="p">))</span>
</pre></div>
</div>
<p>With this, the final document produced is:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><?xml version="1.0" encoding="utf-8"?>
<po:purchaseOrder xmlns:po="URN:purchase-order" orderDate="1999-10-20">
<po:shipTo country="US">
<name>Alice Smith</name>
<street>123 Maple Street</street>
<city>Anytown</city>
<state>AK</state>
<zip>12341</zip>
</po:shipTo>
<po:billTo country="US">
<name>Robert Smith</name>
<street>8 Oak Avenue</street>
<city>Anytown</city>
<state>AK</state>
<zip>12341</zip>
</po:billTo>
<po:items>
<po:item partNum="833-AA">
<po:productName>Lapis necklace</po:productName>
<po:quantity>1</po:quantity>
<po:USPrice>99.95</po:USPrice>
<po:comment>Want this for the holidays!</po:comment>
<po:shipDate>1999-12-05</po:shipDate>
</po:item>
<po:item partNum="833-AB">
<po:productName>Plastic necklace</po:productName>
<po:quantity>4</po:quantity>
<po:USPrice>3.95</po:USPrice>
<po:shipDate>1999-12-24</po:shipDate>
</po:item>
</po:items>
</po:purchaseOrder>
</pre></div>
</div>
<p>(Surprise: <code class="docutils literal"><span class="pre">addr</span></code> does not appear, because the <code class="docutils literal"><span class="pre">nsaddress.xsd</span></code> schema
uses the default element form <code class="docutils literal"><span class="pre">unqualified</span></code>, so none of the address
components in the document have a namespace.)</p>
<div class="section" id="influencing-element-and-mixed-content-order">
<span id="mixed-content"></span><h3>Influencing Element and Mixed Content Order<a class="headerlink" href="#influencing-element-and-mixed-content-order" title="Permalink to this headline">¶</a></h3>
<p>PyXB generally expects that any information reflected in the order of elements
is controlled by the content model in the schema. Where content includes
multiple instances of the same element, they are maintained in order within
the binding attribute corresponding to the name. Historically relative order
with other elements or with mixed content historically was not rigorously
maintained, and generated documents applied only the order enforced by the
content model.</p>
<p>The following example from <code class="docutils literal"><span class="pre">examples/xhtml/generate.py</span></code> hints at the difficulty:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="c1"># -*- coding: utf-8 -*-</span>
<span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">print_function</span>
<span class="kn">import</span> <span class="nn">pyxb.bundles.common.xhtml1</span> <span class="k">as</span> <span class="nn">xhtml</span>
<span class="kn">import</span> <span class="nn">pyxb.utils.domutils</span>
<span class="n">pyxb</span><span class="o">.</span><span class="n">utils</span><span class="o">.</span><span class="n">domutils</span><span class="o">.</span><span class="n">BindingDOMSupport</span><span class="o">.</span><span class="n">SetDefaultNamespace</span><span class="p">(</span><span class="n">xhtml</span><span class="o">.</span><span class="n">Namespace</span><span class="p">)</span>
<span class="n">head</span> <span class="o">=</span> <span class="n">xhtml</span><span class="o">.</span><span class="n">head</span><span class="p">(</span><span class="n">title</span><span class="o">=</span><span class="s1">'A Test Document'</span><span class="p">)</span>
<span class="n">body</span> <span class="o">=</span> <span class="n">xhtml</span><span class="o">.</span><span class="n">body</span><span class="p">()</span>
<span class="n">body</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">xhtml</span><span class="o">.</span><span class="n">h1</span><span class="p">(</span><span class="s1">'Contents'</span><span class="p">))</span>
<span class="n">body</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">xhtml</span><span class="o">.</span><span class="n">p</span><span class="p">(</span><span class="s1">'''Here is some text.</span>
<span class="s1">It doesn't do anything special.'''</span><span class="p">))</span>
<span class="n">p2</span> <span class="o">=</span> <span class="n">xhtml</span><span class="o">.</span><span class="n">p</span><span class="p">(</span><span class="s1">'Here is more text. It has '</span><span class="p">,</span>
<span class="n">xhtml</span><span class="o">.</span><span class="n">b</span><span class="p">(</span><span class="s1">'bold'</span><span class="p">),</span>
<span class="s1">' and '</span><span class="p">,</span>
<span class="n">xhtml</span><span class="o">.</span><span class="n">em</span><span class="p">(</span><span class="s1">'emphasized'</span><span class="p">),</span>
<span class="s1">' content with '</span><span class="p">,</span>
<span class="n">xhtml</span><span class="o">.</span><span class="n">b</span><span class="p">(</span><span class="s1">'more bold'</span><span class="p">),</span>
<span class="s1">' just to complicate things.'</span><span class="p">)</span>
<span class="n">body</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">p2</span><span class="p">)</span>
<span class="c1"># Verify we have two b's and an em</span>
<span class="k">assert</span> <span class="mi">2</span> <span class="o">==</span> <span class="nb">len</span><span class="p">(</span><span class="n">p2</span><span class="o">.</span><span class="n">b</span><span class="p">)</span>
<span class="k">assert</span> <span class="mi">1</span> <span class="o">==</span> <span class="nb">len</span><span class="p">(</span><span class="n">p2</span><span class="o">.</span><span class="n">em</span><span class="p">)</span>
<span class="c1"># Generate the document and externally verify that the em is between the two bs.</span>
<span class="n">doc</span> <span class="o">=</span> <span class="n">xhtml</span><span class="o">.</span><span class="n">html</span><span class="p">(</span><span class="n">head</span><span class="p">,</span> <span class="n">body</span><span class="p">)</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">xmls</span> <span class="o">=</span> <span class="n">doc</span><span class="o">.</span><span class="n">toDOM</span><span class="p">()</span><span class="o">.</span><span class="n">toprettyxml</span><span class="p">()</span>
<span class="k">except</span> <span class="n">pyxb</span><span class="o">.</span><span class="n">ValidationError</span> <span class="k">as</span> <span class="n">e</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="n">e</span><span class="o">.</span><span class="n">details</span><span class="p">())</span>
<span class="k">raise</span>
<span class="nb">open</span><span class="p">(</span><span class="s1">'genout.xhtml'</span><span class="p">,</span> <span class="s1">'w'</span><span class="p">)</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="n">xmls</span><span class="p">)</span>
</pre></div>
</div>
<p>If the relative order of elements and mixed content were not maintained, this
might produce something like:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><?xml version="1.0" ?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title/>
</head>
<body>
<h1/>
<p/>
<p>
<b/>
<b/>
<em/>
</p>
</body>
</html>
</pre></div>
</div>
<p>Here mixed content is lost, and element content is emitted in the order that
elements appear in the original schema.</p>
<p>As of release 1.2.1 <a class="footnote-reference" href="#content" id="id1">[1]</a>, PyXB appends both element and non-element content to a
list in each complex binding instance. The list may be obtained using the
<a class="reference internal" href="pyxb.binding.html#pyxb.binding.basis.complexTypeDefinition.orderedContent" title="pyxb.binding.basis.complexTypeDefinition.orderedContent"><code class="xref py py-obj docutils literal"><span class="pre">orderedContent</span></code></a> method. The list
comprises instances of <a class="reference internal" href="pyxb.binding.html#pyxb.binding.basis.ElementContent" title="pyxb.binding.basis.ElementContent"><code class="xref py py-obj docutils literal"><span class="pre">pyxb.binding.basis.ElementContent</span></code></a> and
<a class="reference internal" href="pyxb.binding.html#pyxb.binding.basis.NonElementContent" title="pyxb.binding.basis.NonElementContent"><code class="xref py py-obj docutils literal"><span class="pre">pyxb.binding.basis.NonElementContent</span></code></a> added in the order in which they were
added to the binding instance: when creating the instance from a document or
through a constructor, or by invoking the
<a class="reference internal" href="pyxb.binding.html#pyxb.binding.basis.complexTypeDefinition.append" title="pyxb.binding.basis.complexTypeDefinition.append"><code class="xref py py-obj docutils literal"><span class="pre">append</span></code></a> or
<a class="reference internal" href="pyxb.binding.html#pyxb.binding.basis.complexTypeDefinition.extend" title="pyxb.binding.basis.complexTypeDefinition.extend"><code class="xref py py-obj docutils literal"><span class="pre">extend</span></code></a> methods to add
content consistent with the content model.</p>
<p>The <a class="reference internal" href="pyxb.html#pyxb.ValidationConfig.contentInfluencesGeneration" title="pyxb.ValidationConfig.contentInfluencesGeneration"><code class="xref py py-obj docutils literal"><span class="pre">contentInfluencesGeneration</span></code></a> flag of
<a class="reference internal" href="pyxb.html#pyxb.ValidationConfig" title="pyxb.ValidationConfig"><code class="xref py py-obj docutils literal"><span class="pre">pyxb.ValidationConfig</span></code></a> controls how the <code class="docutils literal"><span class="pre">orderedContent</span></code> list affects
generation of documents (both DOM directly and XML indirectly). With the
default value of <a class="reference internal" href="pyxb.html#pyxb.ValidationConfig.MIXED_ONLY" title="pyxb.ValidationConfig.MIXED_ONLY"><code class="xref py py-obj docutils literal"><span class="pre">MIXED_ONLY</span></code></a> the
<code class="docutils literal"><span class="pre">orderedContent</span></code> list is only consulted when a complex type allows both
element and non-element content.</p>
<p>The bundle for XHTML has been modified to use:</p>
<ul class="simple">
<li><a class="reference internal" href="pyxb.html#pyxb.ValidationConfig.ALWAYS" title="pyxb.ValidationConfig.ALWAYS"><code class="xref py py-obj docutils literal"><span class="pre">ALWAYS</span></code></a> for <a class="reference internal" href="pyxb.html#pyxb.ValidationConfig.contentInfluencesGeneration" title="pyxb.ValidationConfig.contentInfluencesGeneration"><code class="xref py py-obj docutils literal"><span class="pre">contentInfluencesGeneration</span></code></a></li>
<li><a class="reference internal" href="pyxb.html#pyxb.ValidationConfig.RAISE_EXCEPTION" title="pyxb.ValidationConfig.RAISE_EXCEPTION"><code class="xref py py-obj docutils literal"><span class="pre">RAISE_EXCEPTION</span></code></a> for
<a class="reference internal" href="pyxb.html#pyxb.ValidationConfig.orphanElementInContent" title="pyxb.ValidationConfig.orphanElementInContent"><code class="xref py py-obj docutils literal"><span class="pre">orphanElementInContent</span></code></a></li>
<li><a class="reference internal" href="pyxb.html#pyxb.ValidationConfig.RAISE_EXCEPTION" title="pyxb.ValidationConfig.RAISE_EXCEPTION"><code class="xref py py-obj docutils literal"><span class="pre">RAISE_EXCEPTION</span></code></a> for
<a class="reference internal" href="pyxb.html#pyxb.ValidationConfig.invalidElementInContent" title="pyxb.ValidationConfig.invalidElementInContent"><code class="xref py py-obj docutils literal"><span class="pre">invalidElementInContent</span></code></a></li>
</ul>
<p>for all binding classes in that module. (See
<code class="docutils literal"><span class="pre">pyxb/bundles/common/xhtml1.py</span></code> for the technique used.) This ensures
preservation of element order in cases where no non-element content may appear
(such as the top-level <code class="docutils literal"><span class="pre">body</span></code> element).</p>
<p>With this capability the following document is generated:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><?xml version="1.0" ?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>A Test Document</title>
</head>
<body>
<h1>Contents</h1>
<p>Here is some text.
It doesn't do anything special.</p>
<p>
Here is more text. It has
<b>bold</b>
and
<em>emphasized</em>
content with
<b>more bold</b>
just to complicate things.
</p>
</body>
</html>
</pre></div>
</div>
<p>Be aware that the automatically-maintained <code class="docutils literal"><span class="pre">orderedContent</span></code> list will be
incorrect in at least two cases:</p>
<ul>
<li><p class="first">When the elements of an instance are mutated through Python code, the list
no longer reflects the correct order;</p>
</li>
<li><p class="first">When elements are appended directly to sub-elements as with:</p>
<div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">p2</span><span class="o">.</span><span class="n">b</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="s1">'another bit of bold'</span><span class="p">)</span>
</pre></div>
</div>
<p>the newly added elements do not appear in the <code class="docutils literal"><span class="pre">orderedContent</span></code> list.</p>
</li>
</ul>
<p>The value returned by <a class="reference internal" href="pyxb.binding.html#pyxb.binding.basis.complexTypeDefinition.orderedContent" title="pyxb.binding.basis.complexTypeDefinition.orderedContent"><code class="xref py py-obj docutils literal"><span class="pre">orderedContent</span></code></a> is a mutable list
so that you can manipulate it to reflect the content you wish to have
generated.</p>
<p>Where the <code class="docutils literal"><span class="pre">orderedContent</span></code> list is not consistent with the content model
(e.g., references elements that are no longer part of the binding instance, or
proposes an order that is not valid) various exceptions may arise. To some
extent this can be controlled through the <a class="reference internal" href="pyxb.html#pyxb.ValidationConfig.orphanElementInContent" title="pyxb.ValidationConfig.orphanElementInContent"><code class="xref py py-obj docutils literal"><span class="pre">orphanElementInContent</span></code></a> and
<a class="reference internal" href="pyxb.html#pyxb.ValidationConfig.invalidElementInContent" title="pyxb.ValidationConfig.invalidElementInContent"><code class="xref py py-obj docutils literal"><span class="pre">invalidElementInContent</span></code></a>
flags.</p>
<table class="docutils footnote" frame="void" id="content" rules="none">
<colgroup><col class="label" /><col /></colgroup>
<tbody valign="top">
<tr><td class="label"><a class="fn-backref" href="#id1">[1]</a></td><td>Though previous versions also provided this information through
a <code class="docutils literal"><span class="pre">content</span></code> list, the list did not associate content with the element to
which it belonged making it difficult to reconstruct a valid document.</td></tr>
</tbody>
</table>
</div>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper">
<h3><a href="index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">Using Binding Classes</a><ul>
<li><a class="reference internal" href="#creating-instances-from-xml-documents">Creating Instances from XML Documents</a><ul>
<li><a class="reference internal" href="#locating-invalid-content">Locating Invalid Content</a></li>
<li><a class="reference internal" href="#coping-with-wrong-xsi-type-attributes">Coping With Wrong <code class="docutils literal"><span class="pre">xsi:type</span></code> Attributes</a></li>
</ul>
</li>
<li><a class="reference internal" href="#creating-instances-in-python-code">Creating Instances in Python Code</a><ul>
<li><a class="reference internal" href="#creating-instances-of-anonymous-types">Creating Instances of Anonymous Types</a></li>
</ul>
</li>
<li><a class="reference internal" href="#creating-xml-documents-from-binding-instances">Creating XML Documents from Binding Instances</a><ul>
<li><a class="reference internal" href="#influencing-element-and-mixed-content-order">Influencing Element and Mixed Content Order</a></li>
</ul>
</li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="userref_pyxbgen.html"
title="previous chapter">Generating Binding Classes</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="userref_validating.html"
title="next chapter">Debugging Validation Errors</a></p>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="_sources/userref_usebind.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3>
<form class="search" action="search.html" method="get">
<div><input type="text" name="q" /></div>
<div><input type="submit" value="Go" /></div>
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related" role="navigation" aria-label="related navigation">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="py-modindex.html" title="Python Module Index"
>modules</a> |</li>
<li class="right" >
<a href="userref_validating.html" title="Debugging Validation Errors"
>next</a> |</li>
<li class="right" >
<a href="userref_pyxbgen.html" title="Generating Binding Classes"
>previous</a> |</li>
<li class="nav-item nav-item-0"><a href="index.html">PyXB 1.2.6 documentation</a> »</li>
<li class="nav-item nav-item-1"><a href="userref_index.html" >User Reference</a> »</li>
<li style="margin-left: 20px">PyXB hosted on <a href="http://sourceforge.net/projects/pyxb"><img src="http://sflogo.sourceforge.net/sflogo.php?group_id=263147&type=9"
width="80" height="15" alt="Get PyXB: Python XML Schema Bindings at SourceForge.net. Fast, secure and Free Open Source software downloads"/></a></li>
</ul>
</div>
<div class="footer" role="contentinfo">
© Copyright 2009-2017, Peter A. Bigot.
Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.5.5.
</div>
</body>
</html>
