ipxact-compiler 0.1.2__tar.gz → 0.2.0__tar.gz

ipxact_compiler-0.2.0/PKG-INFO

@@ -0,0 +1,188 @@
+Metadata-Version: 2.4
+Name: ipxact-compiler
+Version: 0.2.0
+Summary: Parses IEEE 1685-2022 IP-XACT XML into a Python object model.
+Author: Maxime Travaillard
+License-Expression: LGPL-3.0-only
+Project-URL: Repository, https://github.com/IP-XACT/ipxact-compiler
+Project-URL: Issues, https://github.com/IP-XACT/ipxact-compiler/issues
+Keywords: IP-XACT,IEEE 1685,XML,Compiler
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lxml
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# ipxact-compiler
+
+A Python library that parses [IEEE 1685-2022](https://standards.ieee.org/ieee/1685/10307/) IP-XACT
+XML documents into a Python object model.
+
+It is a standalone, general-purpose parsing library, not tied to any specific downstream tool or
+flow. `ipxact-compiler` reads IP-XACT and hands you back Python objects; it does not resolve
+cross-file references, link a design, validate semantic consistency, or generate any output.
+That is the job of tools built on top of it.
+
+## What it supports
+
+Five IP-XACT top-level document types are supported for now:
+
+- `component`
+- `design`
+- `designConfiguration`
+- `busDefinition`
+- `abstractionDefinition`
+
+The object model covers the IEEE 1685-2022 XSD schema for these document types: every element and
+attribute the schema allows in them has a place in the object model and is read by the parser. This
+is checked against the official Accellera XSD files, with XML documents generated from the schema
+itself.
+
+### How values are represented
+
+- **Expressions are `Expression` objects.** Fields typed as an IP-XACT expression (parameter values,
+  addresses, sizes, vector and array bounds, and similar) hold an `Expression` with the raw `value`
+  text and its optional `minimum`/`maximum` bounds. Expressions are not evaluated: `"DATA_W-1"` stays
+  `"DATA_W-1"`. [XactFlow](https://github.com/IP-XACT/XactFlow) provides an evaluator
+  (`xactflow.evaluate`).
+- **`xml:id` attributes** are kept as `xml_id` fields. Plain text elements that can carry an `xml:id`
+  (`viewRef`, `group`, `dependency`, ...) are `TextValue` objects (`value` and `xml_id`).
+- **Attributes from other namespaces**, where the schema allows them, are kept in `other_attributes`
+  dictionaries, keyed by `{namespace}name`.
+- **`vendorExtensions` is opaque.** Each extension is kept as a raw XML string, not modeled
+  per-vendor.
+- **References are kept as references.** VLNV references (`busType`, `componentRef`, ...) and the
+  `*DefinitionRef` elements that point into a `typeDefinitions` document are stored as they are
+  written; resolving them is left to the caller.
+
+### What is not kept
+
+- XML comments and processing instructions.
+- `xsi:` attributes, such as `xsi:schemaLocation` on the root element. On elements that have
+  `other_attributes`, they are kept there like any other foreign attribute.
+- The relative order of sibling elements that the schema lets you mix but that end up in separate
+  lists: `interconnection` and `monitorInterconnection`, and the different kinds of instantiations.
+  Order within each list is kept.
+- Whether an optional element or attribute with a schema default was written out or omitted: both give
+  the default value.
+- The `invert` attribute of a `portMap` is not typed in the XSD; it is read as a boolean.
+
+Other IP-XACT document types (`typeDefinitions`, `catalog`, `abstractor`, `generatorChain`) are not
+parsed.
+
+## Installation
+
+```bash
+pip install ipxact-compiler
+```
+
+Or, for local development:
+
+```bash
+git clone https://github.com/IP-XACT/ipxact-compiler.git
+cd ipxact-compiler
+pip install -e ".[dev]"
+```
+
+Requires Python >= 3.9. The only runtime dependency is [`lxml`](https://lxml.de/).
+
+## Usage
+
+```python
+import ipxact
+
+component = ipxact.parse_file("path/to/some_component.xml")
+
+component.vlnv            # VLNV
+component.bus_interfaces  # list[BusInterface]
+component.memory_maps     # list[MemoryMap]
+component.model           # Model | None
+
+register = component.memory_maps[0].items[0].registers[0]
+register.size             # Expression(value="32", minimum=None, maximum=None, ...)
+register.size.value       # "32"
+```
+
+`ipxact.parse_file(path)` reads a file, figures out its document type from the root element, and
+returns the matching dataclass (`Component`, `Design`, `DesignConfiguration`, `BusDefinition`, or
+`AbstractionDefinition`).
+
+Every schema class (`Component`, `VLNV`, `BusInterface`, `Register`, `Field`, `Expression`, and so
+on) is re-exported at the top level, so `ipxact.<ClassName>` works without reaching into submodules.
+
+### Validation
+
+Parsing does not validate by default. The IEEE 1685-2022 XSD files are shipped with the package, so
+validation works offline:
+
+```python
+issues = ipxact.validate("path/to/some_component.xml")   # [] when valid
+for issue in issues:
+    print(issue.line, issue.message)
+
+component = ipxact.parse_file("path/to/some_component.xml", validate=True)
+# raises ipxact.ValidationError (with .issues) if the file is not valid
+```
+
+`ipxact.validate()` also accepts an lxml tree or element, so tools that write IP-XACT can validate
+their output before saving it. `ipxact.xsd_path()` gives the folder holding the XSD files
+(`index.xsd` is the entry point) for tools that need the files themselves.
+
+XSD validation checks the structure, types and values of a document, and the uniqueness and reference
+rules the schema defines (for example, two parameters with the same `parameterId`). It does not check
+the Semantic Consistency Rules of the standard.
+
+## Design principles
+
+- **Single-file parsing only.** `ipxact-compiler` never opens a second file on its own. Resolving
+  VLNV references across a library of files (for example, finding the `Component` that a `Design`'s
+  instance refers to) is left to the caller.
+- **Input files are assumed to be valid.** Unless you ask for validation, the parser assumes the
+  IP-XACT documents you give it are well-formed and conform to the standard. This is why it favors
+  defaulting over raising on missing or malformed data. Use `validate=True` or `ipxact.validate()`
+  when the input may not be valid.
+- **The XSD files are shipped, not downloaded.** We decided to ship a copy of the official
+  Accellera files instead of downloading them when needed:
+  - Validation works offline, including in CI.
+  - Validation results only change when we decide to update. The published 1685-2022 files can be
+    updated at the same URL (two of the current files were last changed in September 2024, the others in July 2023); with a copy,
+    taking such an update is a deliberate change, tested like any other.
+  - The website only serves the files over plain HTTP.
+
+  The online URL (for example in `xsi:schemaLocation`) is only a hint of where to find the schema.
+  The schema itself is identified by its namespace, so a local copy is the same schema. To update the
+  copy, replace the files (see `src/ipxact/xsd/1685-2022/README.md`).
+
+## Known limitations / ideas for later
+
+These are open items, not commitments.
+
+- **No deliberate error-handling philosophy yet.** Right now, malformed input either silently
+  produces a default value or raises whatever low-level Python exception happens to occur (a
+  `ValueError`, an `AttributeError`, etc.) rather than a clear, intentional error type. Deciding on
+  and implementing a consistent policy (raise vs. warn vs. silently default, and what exception
+  types/messages to use) is still open.
+- **No Semantic Consistency Rule (SCR) checking.** This rules are out of scope for this library.
+  They are handled by [XactFlow](https://github.com/IP-XACT/XactFlow), including the rules that
+  can be checked on a single document.
+- **No dedicated documentation yet.** This README covers the basics, but a proper documentation site
+  (full API reference, more usage examples) is planned for the future.
+
+## License
+
+LGPL-3.0. See [`LICENSE`](LICENSE).
+
+The IEEE 1685-2022 XSD files in `src/ipxact/xsd/1685-2022/` are Accellera's, unmodified, under the
+Apache License 2.0 (see the `LICENSE` file in that folder).

ipxact_compiler-0.2.0/README.md

@@ -0,0 +1,161 @@
+# ipxact-compiler
+
+A Python library that parses [IEEE 1685-2022](https://standards.ieee.org/ieee/1685/10307/) IP-XACT
+XML documents into a Python object model.
+
+It is a standalone, general-purpose parsing library, not tied to any specific downstream tool or
+flow. `ipxact-compiler` reads IP-XACT and hands you back Python objects; it does not resolve
+cross-file references, link a design, validate semantic consistency, or generate any output.
+That is the job of tools built on top of it.
+
+## What it supports
+
+Five IP-XACT top-level document types are supported for now:
+
+- `component`
+- `design`
+- `designConfiguration`
+- `busDefinition`
+- `abstractionDefinition`
+
+The object model covers the IEEE 1685-2022 XSD schema for these document types: every element and
+attribute the schema allows in them has a place in the object model and is read by the parser. This
+is checked against the official Accellera XSD files, with XML documents generated from the schema
+itself.
+
+### How values are represented
+
+- **Expressions are `Expression` objects.** Fields typed as an IP-XACT expression (parameter values,
+  addresses, sizes, vector and array bounds, and similar) hold an `Expression` with the raw `value`
+  text and its optional `minimum`/`maximum` bounds. Expressions are not evaluated: `"DATA_W-1"` stays
+  `"DATA_W-1"`. [XactFlow](https://github.com/IP-XACT/XactFlow) provides an evaluator
+  (`xactflow.evaluate`).
+- **`xml:id` attributes** are kept as `xml_id` fields. Plain text elements that can carry an `xml:id`
+  (`viewRef`, `group`, `dependency`, ...) are `TextValue` objects (`value` and `xml_id`).
+- **Attributes from other namespaces**, where the schema allows them, are kept in `other_attributes`
+  dictionaries, keyed by `{namespace}name`.
+- **`vendorExtensions` is opaque.** Each extension is kept as a raw XML string, not modeled
+  per-vendor.
+- **References are kept as references.** VLNV references (`busType`, `componentRef`, ...) and the
+  `*DefinitionRef` elements that point into a `typeDefinitions` document are stored as they are
+  written; resolving them is left to the caller.
+
+### What is not kept
+
+- XML comments and processing instructions.
+- `xsi:` attributes, such as `xsi:schemaLocation` on the root element. On elements that have
+  `other_attributes`, they are kept there like any other foreign attribute.
+- The relative order of sibling elements that the schema lets you mix but that end up in separate
+  lists: `interconnection` and `monitorInterconnection`, and the different kinds of instantiations.
+  Order within each list is kept.
+- Whether an optional element or attribute with a schema default was written out or omitted: both give
+  the default value.
+- The `invert` attribute of a `portMap` is not typed in the XSD; it is read as a boolean.
+
+Other IP-XACT document types (`typeDefinitions`, `catalog`, `abstractor`, `generatorChain`) are not
+parsed.
+
+## Installation
+
+```bash
+pip install ipxact-compiler
+```
+
+Or, for local development:
+
+```bash
+git clone https://github.com/IP-XACT/ipxact-compiler.git
+cd ipxact-compiler
+pip install -e ".[dev]"
+```
+
+Requires Python >= 3.9. The only runtime dependency is [`lxml`](https://lxml.de/).
+
+## Usage
+
+```python
+import ipxact
+
+component = ipxact.parse_file("path/to/some_component.xml")
+
+component.vlnv            # VLNV
+component.bus_interfaces  # list[BusInterface]
+component.memory_maps     # list[MemoryMap]
+component.model           # Model | None
+
+register = component.memory_maps[0].items[0].registers[0]
+register.size             # Expression(value="32", minimum=None, maximum=None, ...)
+register.size.value       # "32"
+```
+
+`ipxact.parse_file(path)` reads a file, figures out its document type from the root element, and
+returns the matching dataclass (`Component`, `Design`, `DesignConfiguration`, `BusDefinition`, or
+`AbstractionDefinition`).
+
+Every schema class (`Component`, `VLNV`, `BusInterface`, `Register`, `Field`, `Expression`, and so
+on) is re-exported at the top level, so `ipxact.<ClassName>` works without reaching into submodules.
+
+### Validation
+
+Parsing does not validate by default. The IEEE 1685-2022 XSD files are shipped with the package, so
+validation works offline:
+
+```python
+issues = ipxact.validate("path/to/some_component.xml")   # [] when valid
+for issue in issues:
+    print(issue.line, issue.message)
+
+component = ipxact.parse_file("path/to/some_component.xml", validate=True)
+# raises ipxact.ValidationError (with .issues) if the file is not valid
+```
+
+`ipxact.validate()` also accepts an lxml tree or element, so tools that write IP-XACT can validate
+their output before saving it. `ipxact.xsd_path()` gives the folder holding the XSD files
+(`index.xsd` is the entry point) for tools that need the files themselves.
+
+XSD validation checks the structure, types and values of a document, and the uniqueness and reference
+rules the schema defines (for example, two parameters with the same `parameterId`). It does not check
+the Semantic Consistency Rules of the standard.
+
+## Design principles
+
+- **Single-file parsing only.** `ipxact-compiler` never opens a second file on its own. Resolving
+  VLNV references across a library of files (for example, finding the `Component` that a `Design`'s
+  instance refers to) is left to the caller.
+- **Input files are assumed to be valid.** Unless you ask for validation, the parser assumes the
+  IP-XACT documents you give it are well-formed and conform to the standard. This is why it favors
+  defaulting over raising on missing or malformed data. Use `validate=True` or `ipxact.validate()`
+  when the input may not be valid.
+- **The XSD files are shipped, not downloaded.** We decided to ship a copy of the official
+  Accellera files instead of downloading them when needed:
+  - Validation works offline, including in CI.
+  - Validation results only change when we decide to update. The published 1685-2022 files can be
+    updated at the same URL (two of the current files were last changed in September 2024, the others in July 2023); with a copy,
+    taking such an update is a deliberate change, tested like any other.
+  - The website only serves the files over plain HTTP.
+
+  The online URL (for example in `xsi:schemaLocation`) is only a hint of where to find the schema.
+  The schema itself is identified by its namespace, so a local copy is the same schema. To update the
+  copy, replace the files (see `src/ipxact/xsd/1685-2022/README.md`).
+
+## Known limitations / ideas for later
+
+These are open items, not commitments.
+
+- **No deliberate error-handling philosophy yet.** Right now, malformed input either silently
+  produces a default value or raises whatever low-level Python exception happens to occur (a
+  `ValueError`, an `AttributeError`, etc.) rather than a clear, intentional error type. Deciding on
+  and implementing a consistent policy (raise vs. warn vs. silently default, and what exception
+  types/messages to use) is still open.
+- **No Semantic Consistency Rule (SCR) checking.** This rules are out of scope for this library.
+  They are handled by [XactFlow](https://github.com/IP-XACT/XactFlow), including the rules that
+  can be checked on a single document.
+- **No dedicated documentation yet.** This README covers the basics, but a proper documentation site
+  (full API reference, more usage examples) is planned for the future.
+
+## License
+
+LGPL-3.0. See [`LICENSE`](LICENSE).
+
+The IEEE 1685-2022 XSD files in `src/ipxact/xsd/1685-2022/` are Accellera's, unmodified, under the
+Apache License 2.0 (see the `LICENSE` file in that folder).

{ipxact_compiler-0.1.2 → ipxact_compiler-0.2.0}/pyproject.toml

@@ -48,4 +48,4 @@ version = {attr = "ipxact.__version__"}
 where = ["src"]
 
 [tool.setuptools.package-data]
-ipxact = ["py.typed"]
+ipxact = ["py.typed", "xsd/*/*.xsd", "xsd/*/LICENSE", "xsd/*/README.md"]

ipxact_compiler-0.2.0/src/ipxact/__init__.py

@@ -0,0 +1,17 @@
+__version__ = "0.2.0"
+
+from .parser import parse_element, parse_file
+from .schema import *  # noqa: F401,F403
+from .schema import __all__ as _schema_all
+from .validation import ValidationError, ValidationIssue, validate, xsd_path
+
+__all__ = [
+    *_schema_all,
+    "parse_element",
+    "parse_file",
+    "validate",
+    "xsd_path",
+    "ValidationError",
+    "ValidationIssue",
+    "__version__",
+]

{ipxact_compiler-0.1.2 → ipxact_compiler-0.2.0}/src/ipxact/parser/abstractiondefinition_parser.py

@@ -5,6 +5,8 @@ from lxml import etree
 from ..schema.abstractiondefinition import (
     AbstractionDefinition,
     AbstractionPort,
+    Packet,
+    PacketField,
     PortConstraints,
     Presence,
     RequiresDriver,
@@ -22,11 +24,14 @@ from .common_parser import (
     child,
     children,
     elem_text,
+    expr,
     parse_assertions,
     parse_children,
     parse_choices,
     parse_drive_constraint,
+    parse_optional_expression,
     parse_load_constraint,
+    parse_name_group,
     parse_parameters,
     parse_protocol,
     parse_qualifier,
@@ -34,7 +39,9 @@ from .common_parser import (
     parse_vendor_extensions,
     parse_vlnv,
     parse_vlnv_ref,
+    required_expr,
     text,
+    xml_id,
 )
 
 
@@ -49,9 +56,8 @@ def parse_abstractiondefinition(root: etree._Element) -> AbstractionDefinition:
         choices=parse_choices(root),
         parameters=parse_parameters(root),
         assertions=parse_assertions(root),
-        display_name=text(root, "displayName"),
-        short_description=text(root, "shortDescription"),
-        description=text(root, "description"),
+        **parse_name_group(root),
+        xml_id=xml_id(root),
         vendor_extensions=parse_vendor_extensions(root),
     )
 
@@ -65,7 +71,7 @@ def _parse_port_constraints(elem: etree._Element) -> PortConstraints:
 
 
 def _parse_requires_driver(elem: etree._Element) -> RequiresDriver:
-    return RequiresDriver(value=as_bool(elem.text, False), driver_type=elem.get("driverType", "any"))
+    return RequiresDriver(value=as_bool(elem_text(elem), False), driver_type=elem.get("driverType", "any"))
 
 
 def _parse_wire_mode_constraints(elem: etree._Element) -> WireModeConstraints:
@@ -76,10 +82,10 @@ def _parse_wire_mode_constraints(elem: etree._Element) -> WireModeConstraints:
     mirrored_mode_constraints_elem = child(elem, "mirroredModeConstraints")
     return WireModeConstraints(
         presence=Presence(presence) if presence else Presence.OPTIONAL,
-        width=elem_text(width_elem),
+        width=parse_optional_expression(width_elem),
         width_all_bits_required=attr_bool(width_elem, "allBits", False) if width_elem is not None else False,
-        # direction defaults to "out" when absent
-        direction=elem_text(direction_elem) or "out",
+        # default to out and missing means no restiction, so None.
+        direction=(elem_text(direction_elem) or "out") if direction_elem is not None else None,
         mode_constraints=(
             _parse_port_constraints(mode_constraints_elem) if mode_constraints_elem is not None else None
         ),
@@ -92,7 +98,9 @@ def _parse_wire_mode_constraints(elem: etree._Element) -> WireModeConstraints:
 
 
 def _parse_wire_system_constraints(elem: etree._Element) -> WireSystemConstraints:
-    return WireSystemConstraints(group=text(elem, "group") or "", constraints=_parse_wire_mode_constraints(elem))
+    return WireSystemConstraints(
+        group=text(elem, "group") or "", constraints=_parse_wire_mode_constraints(elem), xml_id=xml_id(elem)
+    )
 
 
 def _parse_wire_abstraction_port(elem: etree._Element) -> WireAbstractionPort:
@@ -104,7 +112,7 @@ def _parse_wire_abstraction_port(elem: etree._Element) -> WireAbstractionPort:
         on_system=[_parse_wire_system_constraints(e) for e in children(elem, "onSystem")],
         on_initiator=_parse_wire_mode_constraints(on_initiator_elem) if on_initiator_elem is not None else None,
         on_target=_parse_wire_mode_constraints(on_target_elem) if on_target_elem is not None else None,
-        default_value=text(elem, "defaultValue"),
+        default_value=expr(elem, "defaultValue"),
         requires_driver=_parse_requires_driver(requires_driver_elem) if requires_driver_elem is not None else None,
     )
 
@@ -115,17 +123,18 @@ def _parse_transactional_mode_constraints(elem: etree._Element) -> Transactional
     kind_elem = child(elem, "kind")
     return TransactionalModeConstraints(
         presence=Presence(presence) if presence else Presence.OPTIONAL,
-        # initiative defaults to "requires" when absent
-        initiative=elem_text(initiative_elem) or "requires",
+        # Same rule as <direction>: missing means "not restricted", default is "requires".
+        initiative=(elem_text(initiative_elem) or "requires") if initiative_elem is not None else None,
         kind=elem_text(kind_elem),
-        bus_width=text(elem, "busWidth"),
+        kind_custom=kind_elem.get("custom") if kind_elem is not None else None,
+        bus_width=expr(elem, "busWidth"),
         protocol=parse_protocol(elem),
     )
 
 
 def _parse_transactional_system_constraints(elem: etree._Element) -> TransactionalSystemConstraints:
     return TransactionalSystemConstraints(
-        group=text(elem, "group") or "", constraints=_parse_transactional_mode_constraints(elem)
+        group=text(elem, "group") or "", constraints=_parse_transactional_mode_constraints(elem), xml_id=xml_id(elem)
     )
 
 
@@ -142,6 +151,30 @@ def _parse_transactional_abstraction_port(elem: etree._Element) -> Transactional
     )
 
 
+def _parse_packet_field(elem: etree._Element) -> PacketField:
+    return PacketField(
+        name=text(elem, "name") or "",
+        width=required_expr(elem, "width"),
+        value=expr(elem, "value"),
+        endianness=text(elem, "endianness"),
+        qualifier=parse_qualifier(elem),
+        **parse_name_group(elem),
+        xml_id=xml_id(elem),
+        vendor_extensions=parse_vendor_extensions(elem),
+    )
+
+
+def _parse_packet(elem: etree._Element) -> Packet:
+    return Packet(
+        name=text(elem, "name") or "",
+        packet_fields=parse_children(elem, "packetFields", "packetField", _parse_packet_field),
+        endianness=text(elem, "endianness"),
+        **parse_name_group(elem),
+        xml_id=xml_id(elem),
+        vendor_extensions=parse_vendor_extensions(elem),
+    )
+
+
 def _parse_abstraction_port(elem: etree._Element) -> AbstractionPort:
     wire_elem = child(elem, "wire")
     transactional_elem = child(elem, "transactional")
@@ -151,9 +184,9 @@ def _parse_abstraction_port(elem: etree._Element) -> AbstractionPort:
         transactional=(
             _parse_transactional_abstraction_port(transactional_elem) if transactional_elem is not None else None
         ),
+        packets=parse_children(elem, "packets", "packet", _parse_packet),
         match=bool_text(elem, "match", False),
-        display_name=text(elem, "displayName"),
-        short_description=text(elem, "shortDescription"),
-        description=text(elem, "description"),
+        **parse_name_group(elem),
+        xml_id=xml_id(elem),
         vendor_extensions=parse_vendor_extensions(elem),
     )

{ipxact_compiler-0.1.2 → ipxact_compiler-0.2.0}/src/ipxact/parser/busdefinition_parser.py

@@ -6,14 +6,17 @@ from ..schema.busdefinition import BusDefinition
 from .common_parser import (
     bool_text,
     child,
+    expr,
     parse_assertions,
+    parse_children,
     parse_choices,
+    parse_name_group,
     parse_parameters,
-    parse_texts,
     parse_vendor_extensions,
     parse_vlnv,
     parse_vlnv_ref,
-    text,
+    text_value,
+    xml_id,
 )
 
 
@@ -26,14 +29,13 @@ def parse_busdefinition(root: etree._Element) -> BusDefinition:
         is_addressable=bool_text(root, "isAddressable", False),
         broadcast=bool_text(root, "broadcast"),
         extends=parse_vlnv_ref(extends_elem) if extends_elem is not None else None,
-        max_initiators=text(root, "maxInitiators"),
-        max_targets=text(root, "maxTargets"),
-        system_group_names=parse_texts(root, "systemGroupNames", "systemGroupName"),
+        max_initiators=expr(root, "maxInitiators"),
+        max_targets=expr(root, "maxTargets"),
+        system_group_names=parse_children(root, "systemGroupNames", "systemGroupName", text_value),
         choices=parse_choices(root),
         parameters=parse_parameters(root),
         assertions=parse_assertions(root),
-        display_name=text(root, "displayName"),
-        short_description=text(root, "shortDescription"),
-        description=text(root, "description"),
+        **parse_name_group(root),
+        xml_id=xml_id(root),
         vendor_extensions=parse_vendor_extensions(root),
     )