# XML
``` python
from IPython.display import Markdown
from pprint import pprint
from fastcore.test import test_eq, test_ne
```
## FT functions
------------------------------------------------------------------------
source
### attrmap
``` python
def attrmap(
o
):
```
------------------------------------------------------------------------
source
### valmap
``` python
def valmap(
o
):
```
------------------------------------------------------------------------
source
### FT
``` python
def FT(
tag:str, cs:tuple, attrs:dict=None, void_:bool=False, kwargs:VAR_KEYWORD
):
```
*A ‘Fast Tag’ structure, containing `tag`,`children`,and `attrs`*
------------------------------------------------------------------------
source
### ft
``` python
def ft(
tag:str, c:VAR_POSITIONAL, void_:bool=False, attrmap:callable=attrmap, valmap:callable=valmap, ft_cls:type=FT,
kw:VAR_KEYWORD
):
```
*Create an [`FT`](https://fastcore.fast.ai/xml.html#ft) structure for
[`to_xml()`](https://fastcore.fast.ai/xml.html#to_xml)*
The main HTML tags are exported as
[`ft`](https://fastcore.fast.ai/xml.html#ft) partials.
Attributes are passed as keywords. Use ‘klass’ and ‘fr’ instead of
‘class’ and ‘for’, to avoid Python reserved word clashes.
------------------------------------------------------------------------
source
### Html
``` python
def Html(
c:VAR_POSITIONAL, doctype:bool=True, kwargs:VAR_KEYWORD
)->FT:
```
*An HTML tag, optionally preceeded by `!DOCTYPE HTML`*
``` python
samp = Html(
Head(Title('Some page')),
Body(Div('Some text\nanother line', (Input(name="jph's"), Img(src="filename", data=1)),
cls=['myclass', 'another'],
style={'padding':1, 'margin':2}))
)
pprint(samp)
```
(!doctype((),{'html': True}),
html((head((title(('Some page',),{}),),{}), body((div(('Some text\nanother line', input((),{'name': "jph's"}), img((),{'src': 'filename', 'data': 1})),{'class': 'myclass another', 'style': 'padding:1; margin:2'}),),{})),{}))
``` python
elem = P('Some text', id="myid")
print(elem.tag)
print(elem.children)
print(elem.attrs)
```
p
('Some text',)
{'id': 'myid'}
You can get and set attrs directly:
``` python
elem.id = 'newid'
print(elem.id, elem.get('id'), elem.get('foo', 'missing'))
elem
```
newid newid missing
p(('Some text',),{'id': 'newid'})
------------------------------------------------------------------------
source
### Safe
``` python
def Safe(
args:VAR_POSITIONAL, kwargs:VAR_KEYWORD
):
```
*str(object=’’) -\> str* str(bytes_or_buffer\[, encoding\[, errors\]\])
-\> str
Create a new string object from the given object. If encoding or errors
is specified, then the object must expose a data buffer that will be
decoded using the given encoding and error handler. Otherwise, returns
the result of object.\_\_str\_\_() (if defined) or repr(object).
encoding defaults to sys.getdefaultencoding(). errors defaults to
‘strict’.
## Conversion to XML/HTML
------------------------------------------------------------------------
source
### to_xml
``` python
def to_xml(
elms:VAR_POSITIONAL, lvl:int=0, indent:bool=True, do_escape:bool=True
):
```
*Convert [`ft`](https://fastcore.fast.ai/xml.html#ft) element tree into
an XML string*
------------------------------------------------------------------------
source
### FT.\_\_html\_\_
``` python
def __html__(
):
```
``` python
test_eq(to_xml(B('Bold Text'), Div(P('Paragraph Text'))),
'Bold Text\n\n')
```
``` python
to_xml(Div(""), do_escape=True)
```
"<script>alert('XSS')</script>
\n"
``` python
h = to_xml(samp, do_escape=False)
print(h)
```
Some page
``` python
c = I('hello')
print(c)
```
hello
``` python
c
```
hello
``` python
class PageTitle:
def __ft__(self): return H1("Hello")
class HomePage:
def __ft__(self): return Div(PageTitle(), Div('hello'))
h = to_xml(Div(HomePage()))
expected_output = """
"""
assert h == expected_output
```
``` python
print(h)
```
``` python
h = to_xml(samp, indent=False)
print(h)
```
Some page
Interoperability both directions with Django and Jinja using the
[**html**()
protocol](https://jinja.palletsprojects.com/en/3.1.x/templates/#jinja-filters.escape):
``` python
def _esc(s): return s.__html__() if hasattr(s, '__html__') else Safe(escape(s))
r = Safe('Hello from Django')
print(to_xml(Div(r)))
print(_esc(Div(P('Hello from fastcore <3'))))
```
Hello from Django
FT attributes are rendered with
[`to_xml`](https://fastcore.fast.ai/xml.html#to_xml):
``` python
print(to_xml(P('hi', value=Div('ho'))))
```
hi
FT components also stringify with
[`to_xml`](https://fastcore.fast.ai/xml.html#to_xml):
``` python
print(Div('ho'))
```
ho
------------------------------------------------------------------------
source
### FT.\_\_hash\_\_
``` python
def __hash__(
):
```
*Return hash(self).*
------------------------------------------------------------------------
source
### FT.\_\_eq\_\_
``` python
def __eq__(
other
):
```
*Return self==value.*
[`FT`](https://fastcore.fast.ai/xml.html#ft) object equality and hashing
is based on tag, attrs, and children.
``` python
test_eq(Div('hello', id='x'), Div('hello', id='x'))
test_ne(Div('hello'), Div('goodbye'))
test_ne(Div('hello', id='a'), Div('hello', id='b'))
test_ne(P('hello'), Div('hello'))
test_eq(hash(Div('hello', id='x')), hash(Div('hello', id='x')))
assert hash(Div('hello')), hash(Div('goodbye'))
```
------------------------------------------------------------------------
source
### dict2xml
``` python
def dict2xml(
d, do_escape:bool=False, unwrap:NoneType=None
):
```
*Convert `d` to XML tags, one per key/value pair, unwrapping if only
single key in `unwrap` exists*
[`dict2xml`](https://fastcore.fast.ai/xml.html#dict2xml) takes a Python
dictionary and converts each key-value pair into an XML element where
the key becomes the tag name and the value becomes its text content. All
elements are concatenated via
[`to_xml`](https://fastcore.fast.ai/xml.html#to_xml):
``` python
d = {'name': 'Jeremy', 'lang': 'Python'}
print(dict2xml(d))
```
Jeremy
Python
If there’s only one key, it is returned if it matches anything in
`unwrap`:
``` python
d = {'name': 'Jeremy'}
print(dict2xml(d, unwrap='name'))
```
Jeremy
## Display
------------------------------------------------------------------------
source
### highlight
``` python
def highlight(
s, lang:str='html'
):
```
*Markdown to syntax-highlight `s` in language `lang`*
------------------------------------------------------------------------
source
### showtags
``` python
def showtags(
s
):
```
You can also reorder the children to come *after* the attrs, if you use
this alternative syntax for [`FT`](https://fastcore.fast.ai/xml.html#ft)
where the children are in a second pair of `()` (behind the scenes this
is because [`FT`](https://fastcore.fast.ai/xml.html#ft) implements
`__call__` to add children).
``` python
hl_md(
Body(klass='myclass')(
Div(style='padding:3px')(
'Some text 1<2',
I(spurious=True)('in italics'),
Input(name='me'),
Img(src="filename", data=1)
)
))
```
------------------------------------------------------------------------
source
### **getattr**
``` python
def __getattr__(
tag
):
```