Thanks!

>>> msg = objectify.Element(‘msg’)
msg = None [ObjectifiedElement]
>>> msg.s = “somestring”
>>> print etree.tostring(msg, pretty_print=True)

somestring

>>> objectify.deannotate(msg) # strip type annotations
>>> print etree.tostring(msg, pretty_print=True)

somestring

>>> # maybe also strip unused namespaces
>>> etree.cleanup_namespaces(msg)
>>> print etree.tostring(msg, pretty_print=True)

somestring

>>>

Thanks for the link. I didn’t know you could use lxml.objectify to create xml as well. But testing it out, lxml seems to be adding type annotations and schema info (I’m using 2.2 beta 1). Is there a way to suppress that?

“…<name py:pytype=”str”>Ryan</name>…”

>>> xml = “”"<main>
… <object1 attr=”name”>content”</object1>
… <object1 attr=”foo”>contenbar”</object1>
… <test>me”</test>
… </main>”"”

>>> from lxml import objectify

>>> main = objectify.fromstring(xml)

>>> main.object1[0]
‘content’

>>> main.object1[1]
‘contenbar’

>>> main.object1[0].get(“attr”)
‘name’

>>> main.test
‘me’

The problem with your proposal is that you can’t override the assignment operator in Python. Thus you’d need some serious voodoo to stick children under those li nodes.

I’m thinking of syntax along these lines (borrowing from gnosis):

root.nodes.add_node(XmlNode("node", u"spam"))
root.nodes.add_node(XmlNode("node"))
root.nodes.node[1].val = u"egg"

@J. Ruigrok

I think we’re in agreement that this is the quick-and-easy way to create XML, not the enterprise-ready way.

To me, creating XML in Python is a big pain point. With any of the tools out there that I know of, it gets painful and messy really quickly. Sometimes I just want something simple and relatively painless. I could see using lxml or the like under the hood, but I explicitly don’t want to add a lot of complexity to the interface.

div.ul.li = ["first item", "second item"]

Of course that only supports a homogeneous array of child tags.

Anyway, I pointed out that there’s lxml and ElementTree (etree) that might be useful for you without having to roll your own solutions like this.

Since 2.5 Python has xml.etree, but there’s still an external version being updated and maintained.

But then again, for a complex document I’m more likely to use a templating language than to generate the XML tree in code. I guess that’s just me, though.

I think one of the main problems is that the XML standard is easy to understand the basics but the full specification is pretty complicated. I used libxml2 as the main engine since it’s pretty much watertight being the Gnome XML library.

I think you may run into limitations quite quickly using instances as nodes. For example, how would you generate an XHTML list?

div = XmlNode(“container”)
div.ul.li = “First Item”
div.ul.li = “About to overwrite the first item?”

I tinkered with serializing Python objects to XML a while back and came to the conclusion that the limitations outweigh the usefulness.

There are lots of options for escaping XML entities in Python. Here’s a page on it from the Python wiki. I’m not entirely convinced that the module should be escaping xml, but I agree that it would be simpler for the user.

I’m sure the solution you wrote is more correct, but pardon me for saying — it doesn’t look incredibly simple to use.

I just want to do:

prefs = XmlNode("prefs")
prefs.language.val = u"English"
prefs.user.name.val = u"Ryan"
prefs.user.email.val = u"ryan@example.com"
prefs.user["id"] = u"123"
prefs.onions.val = u"extra"