Proposal for new operators to python that add syntactic sugar for hierarcical data.

[glomde]

i I would like to extend python so that you could create hiercical
tree structures (XML, HTML etc) easier and that resulting code would be
more readable than how you write today with packages like elementtree
and xist.
I dont want to replace the packages but the packages could be used with
the
new operators and the resulting IMHO is much more readable.

The syntax i would like is something like the below:

# Example creating html tree

'*!*' is an operator that creates an new node,
'*=*' is an operator that sets an attribute.

So if you take an example to build a smalle web page
and compare with how it looks with in element tree now
and how it would look like when the abover operators would exist.

With element tree package.

# build a tree structure
root = ET.Element("htm l")
head = ET.SubElement(r oot, "head")
title = ET.SubElement(h ead, "title")
title.text = "Page Title"
body = ET.SubElement(r oot, "body")
body.set("bgcol or", "#ffffff")
body.text = "Hello, World!"

With syntactical sugar:

# build a tree structure
root = ET.Element("htm l")
*!*root:
*!*head("head") :
*!*title("title ):
*=*text = "Page Title"
*!*body("body") :
*=*bgcolor = "#ffffff"
*=*text = "Hello, World!"

I think that with the added syntax you get better view of the html
page.
Repeating things dissapears and you get indentation that corresponds to
the tree.
I think it is very pythonic IMHO.

It could be done quite generic. If the variable, object after '*!*'
must support append
method and if you use '*=*' it must support __setitem__

Any comments?

[George Sakkis]

glomde wrote:

i I would like to extend python so that you could create hiercical
tree structures (XML, HTML etc) easier and that resulting code would be
more readable than how you write today with packages like elementtree
and xist.

Given that python doesn't have syntactic sugar for something as
prevalent as regular expressions, it's not that hard to predict the
luck of this proposal. Good luck pushing it forward.

George

[Diez B. Roggisch]

glomde schrieb:

i I would like to extend python so that you could create hiercical
tree structures (XML, HTML etc) easier and that resulting code would be
more readable than how you write today with packages like elementtree
and xist.
I dont want to replace the packages but the packages could be used with
the
new operators and the resulting IMHO is much more readable.

The syntax i would like is something like the below:

# Example creating html tree

'*!*' is an operator that creates an new node,
'*=*' is an operator that sets an attribute.

So if you take an example to build a smalle web page
and compare with how it looks with in element tree now
and how it would look like when the abover operators would exist.

With element tree package.

# build a tree structure
root = ET.Element("htm l")
head = ET.SubElement(r oot, "head")
title = ET.SubElement(h ead, "title")
title.text = "Page Title"
body = ET.SubElement(r oot, "body")
body.set("bgcol or", "#ffffff")
body.text = "Hello, World!"

With syntactical sugar:

# build a tree structure
root = ET.Element("htm l")
*!*root:
*!*head("head") :
*!*title("title ):
*=*text = "Page Title"
*!*body("body") :
*=*bgcolor = "#ffffff"
*=*text = "Hello, World!"

I think that with the added syntax you get better view of the html
page.
Repeating things dissapears and you get indentation that corresponds to
the tree.
I think it is very pythonic IMHO.

It could be done quite generic. If the variable, object after '*!*'
must support append
method and if you use '*=*' it must support __setitem__

Any comments?

It's ugly, and could easily achieved using the built-in tupels, lists
and dictionaries together with a simple traversing function.

Like this (untested):

class Node(object):
def __init__(self, value):
self.value = vallue
self._childs = []
def append(self, child):
self._childs.ap pend(child)
t = ('root',
('child1,
('grandchild', ()),
'child2',
()
)
)

def create_node(t):
value, childs = t
n = Node(value)
if childs:
for ch in childs:
n.append(create _node(ch))
return n
IMHO that tuple-based tree is waaay more readable than your proposal -
and no need to come up with new syntax.

Diez

[Ben Finney]

"glomde" <tb****@yahoo.c om> writes:

With element tree package.

# build a tree structure
root = ET.Element("htm l")
head = ET.SubElement(r oot, "head")
title = ET.SubElement(h ead, "title")
title.text = "Page Title"
body = ET.SubElement(r oot, "body")
body.set("bgcol or", "#ffffff")
body.text = "Hello, World!"

With syntactical sugar:

# build a tree structure
root = ET.Element("htm l")
*!*root:
*!*head("head") :
*!*title("title ):
*=*text = "Page Title"
*!*body("body") :
*=*bgcolor = "#ffffff"
*=*text = "Hello, World!"
We already have syntax for building hierarchical data structures:
lists and/or tuples. If you want to define Node and Attribute classes,
you can already do so without adding new syntax.
I think that with the added syntax you get better view of the html
page.
I think indenting our existing data type syntax can do the same thing:

root = Node("html", children=[
Node("head", children=[
Node("title", children=[
"Page Title",
])
]),
Node("body", children=[
Attribute("bgco lor", "white"),
"Hello, World!",
]),
])

Set up the __init__ for those classes to do whatever you would have
done with the syntax you proposed.
Repeating things dissapears and you get indentation that corresponds
to the tree.
Indeed.
I think it is very pythonic IMHO.

Adding new punctuation to deal with a particular type is extremely
un-Pythonic.

--
\ "The cost of a thing is the amount of what I call life which is |
`\ required to be exchanged for it, immediately or in the long |
_o__) run." -- Henry David Thoreau |
Ben Finney

[Scott David Daniels]

glomde wrote:

i I would like to extend python so that you could create hiercical
tree structures (XML, HTML etc) easier ...
With syntactical sugar:

# build a tree structure
root = ET.Element("htm l")
*!*root:
*!*head("head") :
*!*title("title ):
*=*text = "Page Title"
*!*body("body") :
*=*bgcolor = "#ffffff"
*=*text = "Hello, World!"

Hunt up PyYAML. It might be what you want.

--Scott David Daniels
sc***********@a cm.org

[glomde]

There are some difference which are quite essential.

First of all I dont se how you set attributes with that and
then I dont see how you can mix python code with the creation.

So how do you do this:

root = ET.Element("htm l")
*!*root:
*!*head("head") :
*!*title("title ):
for i in sections:
!*! section():
*=*Text = section[i]

[glomde]

But you cant mix python code in there when creating the nodes.
That is when it gets quite ugly an unreadable according to me.

But I also relly do think that this:

# build a tree structure
root = ET.Element("htm l")
*!*root:
*!*head("head") :
*!*title("title ):
*=*text = "Page Title"
*!*body("body") :
*=*bgcolor = "#ffffff"
*=*text = "Hello, World!"

Especially if you start having deeper hierachies like. But the big
other plus is that you can
have any python code in beetween.

[glomde]

Actually we did start of with YAML, but realised that we need to have
the power
of a programming language aswell. But I wanted to come up with
something that looked
very clos to YAML since I find it quite readable.

I have implemented the syntax, but as a preprocessor for python and it
works quite nice.

Cheers,

T

[Diez B. Roggisch]

glomde wrote:

There are some difference which are quite essential.

First of all I dont se how you set attributes with that and
Use dicts as childs.
then I dont see how you can mix python code with the creation.

You can put any python expression in there, and in the Node class you can do
what you want.

Seems that you are after a templating-system. Well, there are plenty of them
available, including yours. A preprocessor is nothing but a template system
- see TurboGears-utilized KID (http://kid.lesscode.org/) for example, it
generates python files. And way more readable, because you are working in
the domain of your application (HTML) instead of some crude syntax that is
neither fish or flesh.

Counterquestion : how do you create this:

<?xml version='1.0' encoding='utf-8'?>
<?python
from urllib import urlopen
from elementtree.Ele mentTree import parse, tostring
feed = 'http://naeblis.cx/rtomayko/weblog/index.atom'
root = parse(urlopen(f eed)).getroot()
ns = '{http://purl.org/atom/ns#}'
title = root.findtext(n s + 'title')
?>
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:py="http://purl.org/kid/ns#">
<head>
<title py:content="tit le" />
</head>
<body bgcolor="blue" text="yellow">
<h1 py:content="tit le" />
<table cellpadding="4" cellspacing="4" >
<tr py:for="i, entry in enumerate(root) "
py:if="entry.ta g == ns + 'entry'">
<td py:attrs="bgcol or=('white', 'yellow')[i % 2]">
<a py:attrs="href= entry.find(ns + 'link').attrib['href']"
py:content="ent ry.findtext(ns + 'title')" />
</td>
</tr>
</table>
</body>
</html>
Diez

[Gerard Flanagan]

glomde wrote:

i I would like to extend python so that you could create hiercical
[...]
# build a tree structure
root = ET.Element("htm l")
*!*root:
*!*head("head") :
*!*title("title ):
*=*text = "Page Title"
*!*body("body") :
*=*bgcolor = "#ffffff"
*=*text = "Hello, World!"

I think that with the added syntax you get better view of the html
page.
Repeating things dissapears and you get indentation that corresponds to
the tree.
I think it is very pythonic IMHO.

It could be done quite generic. If the variable, object after '*!*'
must support append
method and if you use '*=*' it must support __setitem__

Any comments?

I personally dislike the nested-indented-brackets type of code given in
other replies, and i think your suggestion has a certain appeal - 'What
you see is what you mean' . But it's not Python.

You also repeat yourself: head("head"), title("title"), body("body")

What about this:

# build a tree structure
root = ET.Element("htm l")
!root
!head
!title
if A is True:
&text = "Page A"
else:
&text = "Page B"
!body
&bgcolor = "#ffffff"
&text = "Hello, World!"

mmm...yamlthon? yython...:-)

All the best

Gerard