| Commit message (Collapse) | Author | Age | Files | Lines |
|---|
| | |
|
| |
|
|
|
| |
This function will then convert the value to proper hex value for further
processing.
|
| |
|
|
| |
exported the function
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Removed the automagic in the dmiMAP_ParseMappingXML(...) function from
automatically decide what to parse (TypeMapping or GroupMapping). Introduced
two new functions instead:
- dmiMAP_ParseMappingXML_GroupName(xmlDoc *xmlmap, const char *name)
Parses the XML mapping document, using the GroupMapping tags and building
up a proper ptzMAP structure for all TypeMap defined in that group.
- dmiMAP_ParseMappingXML_TypeID(xmlDoc *xmlmap, const char *typeid)
Parses the XML mapping document, using only the TypeMapping section in th
mapping document.
Rewrote a lot of internal parts to reuse as much of the existing code as possible.
|
| |
|
|
|
|
|
|
| |
Merged the two XML files into one, and amended relevant code. I still
want to modify the XML tag names, but not yet.
The calls to dmidecode.type() not function as expected, but the others
are broken - this is next.
|
| | |
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
| |
This builds up a list of dicts. Syntax is:
<Map keytype="constant" key="TestData"
valuetype="list:dict" value="/xml/XPath/to/nodes">
<Map keytype="constant" key="field"
valuetype="string" key="ValueNode"/>
</Map>
The parser will iterate all nodes defined in the @value attribute
and the root path will of the nested mapping will be using the path
in @value as the root path for further parsing.
|
| |
|
|
|
| |
This attribute defines a default value when XML source data
is empty
|
| |
|
|
|
|
|
|
| |
If the emptyIsNone attribute is set to "1", the Python result
will be forced to Py_None if the referenced XML value is empty.
When checking if the value is empty, the XML value is right trimmed
to remove trailing spaces. Only spaces are are removed.
|
| |
|
|
|
|
|
|
|
| |
When using one of the list types as valuetype, the Map tag now
also supports fixedsize and index_attr attributes.
- fixedsize : Defines a fixed size of the list
- index_attr : Defines an attribute name of the input XML data
which contains the list index for the value
|
| |
|
|
|
|
|
|
| |
- Supports relative XPaths now by using the rootpath attribute in the
Map tag. This path is then set for all elements inside this Map tag.
- Rewrote the parser to recurse correctly. The former version did not
recurse well on the very outer (first) Map level.
|
| |
|
|
|
|
|
| |
This reverts commit 4b925a1433b65c217e787804df3cf349d6b387aa.
Discovered that XPath got the needed power for filtering, no need for
this extra feature
|
| | |
|
| |
|
|
|
|
| |
Using these attributes, only XML data (from the given XPath in 'filter')
which matches the value in 'filtervalue' will be added to the Python
data.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
* Added support boolean and list:boolean value types
* Traversing child nodes and having dynamic keys
Now it is possible to do the following:
** test.xml **
<?xml version="1.0" encoding="UTF-8"?>
<testdata>
<list>
<value enabled="1">Option 1</value>
<value enabled="0">Option 2</value>
<value enabled="1">Option 3</value>
</list>
</testdata>
** mapping.xml **
<?xml version="1.0" encoding="UTF-8"?>
<dmidecode_fieldmap version="1">
<Mapping name="example">
<Map keytype="string" key="/testdata/list/value"
valuetype="boolean" value="/testdata/list/value/@enabled"/>
</Mapping>
</dmidecode_fieldmap>
Which should result in:
{'Option 1': True, 'Option 2': False, 'Option 3': True'}
|
|
|
The xmlpythonizer module will convert any XML data (xmlNode
or xmlDoc) and format it as a Python object. The formatting is
defined in it's own XML file.
Basic format:
<dmidecode_fieldmap version="1">
<Mapping name="{name of mapping table}">
<Map keytype="{key type}" key="{key value}"
valuetype="{value type} value="{value}"/>
</Mapping>
</dmidecode_fieldmap>
The keytype and key attributes defines the key in the Python Dict. The
root element will always be a Python Dict structure. The valid key types
are:
* constant
Uses the value in {key} as the key value
* string, integer, float
Uses a string value from the data XML to be converted to Python. The
value set in the key attribute defines an XPath value which points to the
data to be used as a Python dict key.
Since Python only supports C strings in the C interface for Python dict
keys, integer and float will be treated as strings.
The valuetype and value attributes are similar to the keys, but with some more
features. Valid valuetypes are:
* constant
The value given in the value attribute will be used in the value in
the Python result.
* string, integer, float
The value given in the value attribute defines the XPath to the data XML,
of where to retrieve the value for the given key.
The valuetype defines if the data should be understood as a string, integer
or float in the Python result.
* list:string, list:integer, list:float
This does the same as the string, integer or float type, with a tweak. The
data will be put into a list. If the XPath given returns multiple nodes,
all of them will be added to this list.
* dict
The dict valuetype is more special. It should not contain any value
attribute. On the other hand, it should contain a sub-level of <Map> tags.
In this way, you can build up a multi dimensional Python dict.
Example:
** pythonmap.xml **
<?xml version="1.0" encoding="UTF-8"?>
<dmidecode_fieldmap version="1">
<Mapping name="example_map">
<Map keytype="constant" key="DemoCase" valuetype="constant" value="XML Pythonizing"/>
<Map keytype="constant" key="String1" valuetype="string" value="/example/string1"/>
<Map keytype="constant" key="AttribString1" valuetype="integer" value="/example/string1/@int_value"/>
<Map keytype="string" key="/example/keyset/@value" valuetype="dict">
<Map keytype="constant" key="Value1" valuetype="string" value="/example/keyset/value1"/>
<Map keytype="constant" key="ValueList" valuetype="list:string" value="/example/keyset/valuelist"/>
</Map>
</Mapping>
</dmidecode_fieldmap>
** exampledata.xml **
<?xml version="1.0" encoding="UTF-8"?>
<example>
<string1 int_value="1234">String value #1</string1>
<keyset value="TestData">
<value1>More test data</value1>
<valuelist>Value1 in list</valuelist>
<valuelist>Value2 in list</valuelist>
<valuelist>Value3 in list</valuelist>
</keyset>
</example>
** C code snippet **
void xmlpythonizer() {
xmlDoc *xmlmap = NULL;
xmlDoc *xmldata = NULL;
ptzMAP *mapping = NULL;
PyObject *pythondata = NULL;
// Read XML files
xmlmap = xmlReadFile("pythonmap.xml", NULL, 0);
xmldata = xmlReadFile("exampledata.xml", NULL, 0);
// Parse the mapping XML
mapping = dmiMAP_ParseMappingXML(xmlmap, "example_map");
// Parse the xmldata into a Python object
pythondata = pythonizeXMLdoc(mapping, xmldata);
// ..... the program continues to do something useful
}
The result stored inside the pythondata object should now be
something similar to:
{'DemoCase': 'XML Pythonizing',
'String1': 'String value #1',
'AttribString1: 1234,
'TestData': {'Value1': 'More test data',
'ValueList': ['Value1 in list','Value2 in list','Value3 in list']}
}
|
